add staking contracts (#76)

Add sQuartz: Deposit Quartz for sQuartz and over time claim performance fees from Sandclock yield strategies. Additionally receive bonus multiplier points (inspired by GMX reward mechanism) at 100% APR which can be compounded in order to claim a bigger portion of the staking rewards. Redeem sQuartz for Quartz, which will proportionally burn some of the earned multiplier points for that account. The first 30 days of a deposit special rules apply: no additional deposits allowed and in order to withdraw/transfer a fee needs to be paid (starts at 10% of the amount and linearly decreases to zero over 30 days). 

---------

Co-authored-by: Fei Yang <[email protected]>
Co-authored-by: brkomir <[email protected]>

Author: 3 people

script/DeployStakingSepolia.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.13;
+
+import {CREATE3Script} from "./base/CREATE3Script.sol";
+import {RewardTracker} from "../src/staking/RewardTracker.sol";
+import {MockERC20} from "solmate/test/utils/mocks/MockERC20.sol";
+
+contract DeployScript is CREATE3Script {
+    bytes32 public constant DISTRIBUTOR = keccak256("DISTRIBUTOR");
+    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
+
+    constructor() CREATE3Script(vm.envString("VERSION")) {}
+
+    function run() external returns (RewardTracker sQuartz) {
+        uint256 deployerPrivateKey = uint256(vm.envBytes32("PRIVATE_KEY"));
+
+        MockERC20 quartz;
+        address WETH = 0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9; // weth on sepolia
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        quartz = new MockERC20("Mock Quartz", "QUARTZ", 18);
+        sQuartz = new RewardTracker(address(msg.sender), address(quartz), "Staked Quartz", "sQuartz", WETH, 30 days);
+
+        vm.stopBroadcast();
+    }
+}

src/staking/BonusTracker.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.10;
+
+import {ERC20} from "solmate/tokens/ERC20.sol";
+import {ERC4626} from "solmate/mixins/ERC4626.sol";
+import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
+import {ReentrancyGuard} from "openzeppelin-contracts/security/ReentrancyGuard.sol";
+
+abstract contract BonusTracker is ERC4626, ReentrancyGuard {
+    using FixedPointMathLib for uint256;
+
+    event BonusPaid(address indexed user, uint256 bonus);
+    event BonusBurned(address indexed user, uint256 bonus);
+
+    uint256 internal constant PRECISION = 1e30;
+
+    /// @notice The last Unix timestamp (in seconds) when bonusPerTokenStored was updated
+    uint64 public lastBonusUpdateTime;
+
+    /// @notice The last stored bonusPerToken value
+    uint256 public bonusPerTokenStored;
+
+    /// @notice The total bonus amount currently held by users
+    uint256 public totalBonus;
+
+    /// @notice The bonusPerToken value when an account last compounded/withdrew bonus
+    mapping(address => uint256) public userBonusPerTokenPaid;
+
+    /// @notice The number of multiplier points compounded for an account
+    mapping(address => uint256) public multiplierPointsOf;
+
+    /// @notice The bonusOf() value when an account last staked/withdrew bonus
+    mapping(address => uint256) public bonus;
+
+    constructor(ERC20 _asset, string memory _name, string memory _symbol) ERC4626(_asset, _name, _symbol) {
+        lastBonusUpdateTime = uint64(block.timestamp);
+    }
+
+    /// @notice Claim bonus
+    function boost() external nonReentrant returns (uint256 _bonus) {
+        _updateReward(msg.sender);
+        _updateBonus(msg.sender);
+        _bonus = bonus[msg.sender];
+
+        if (_bonus > 0) {
+            bonus[msg.sender] = 0;
+            multiplierPointsOf[msg.sender] += _bonus;
+            totalBonus += _bonus;
+            emit BonusPaid(msg.sender, _bonus);
+        }
+    }
+
+    /// @notice The latest time at which stakers are earning bonus.
+    function lastTimeBonusApplicable() public view returns (uint64) {
+        return uint64(block.timestamp);
+    }
+
+    /// @notice The amount of bonus tokens each staked token has earned so far
+    function bonusPerToken() external view returns (uint256) {
+        return _bonusPerToken(lastTimeBonusApplicable());
+    }
+
+    /// @notice The amount of bonus tokens an account has accrued so far.
+    function bonusOf(address _account) external view returns (uint256) {
+        return _earnedBonus(_account, balanceOf[_account], _bonusPerToken(lastTimeBonusApplicable()), bonus[_account]);
+    }
+
+    function _earnedBonus(address account, uint256 accountBalance, uint256 bonusPerToken_, uint256 accountBonus)
+        internal
+        view
+        returns (uint256)
+    {
+        return accountBalance.mulDivDown(bonusPerToken_ - userBonusPerTokenPaid[account], PRECISION) + accountBonus;
+    }
+
+    function _bonusPerToken(uint256 lastTimeBonusApplicable_) internal view returns (uint256) {
+        return bonusPerTokenStored + (lastTimeBonusApplicable_ - lastBonusUpdateTime).mulDivDown(PRECISION, 365 days);
+    }
+
+    function _updateBonus(address _account) internal {
+        // storage loads
+        uint256 accountBalance = balanceOf[_account];
+        uint64 lastTimeBonusApplicable_ = lastTimeBonusApplicable();
+        uint256 bonusPerToken_ = _bonusPerToken(lastTimeBonusApplicable_);
+
+        // accrue bonus
+        bonusPerTokenStored = bonusPerToken_;
+        lastBonusUpdateTime = lastTimeBonusApplicable_;
+        bonus[_account] = _earnedBonus(_account, accountBalance, bonusPerToken_, bonus[_account]);
+        userBonusPerTokenPaid[_account] = bonusPerToken_;
+    }
+
+    function _updateReward(address) internal virtual {}
+}

src/staking/DebtTracker.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.10;
+
+import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
+
+abstract contract DebtTracker {
+    using FixedPointMathLib for uint256;
+
+    event DebtAdded(address indexed user, uint256 debt, uint64 timestamp);
+    event DebtPaid(address indexed user, uint256 debt);
+
+    error UserHasDebt();
+
+    /// @notice The initial debt for an account
+    mapping(address => uint256) public debtOf;
+
+    /// @notice The debt start time for a user
+    mapping(address => uint64) public debtStartTimeFor;
+
+    /// @notice The treasury address that recieves any paid debt
+    address public treasury;
+
+    /// @notice The amount of current debt left for an account
+    function debtFor(address _account) external view returns (uint256) {
+        return _debtFor(_account);
+    }
+
+    function _updateDebt(address _account) internal {
+        // storage loads
+        uint64 now_ = uint64(block.timestamp);
+        uint256 startTime_ = debtStartTimeFor[_account];
+
+        // if 30 days has passed: eliminate debt
+        if (now_ - startTime_ >= 30 days) {
+            debtOf[_account] = 0;
+        }
+    }
+
+    function _debtFor(address _account) internal view returns (uint256) {
+        // storage loads
+        uint64 now_ = uint64(block.timestamp);
+        uint256 startTime = debtStartTimeFor[_account];
+        uint256 delta = now_ - startTime;
+        uint256 debt = debtOf[_account];
+
+        // if 30 days passed: no debt
+        if (delta >= 30 days) return 0;
+
+        // otherwise debt decreases linearly to 0 over 30 days
+        return (debt - debt.mulDivDown(delta, 30 days));
+    }
+}