1150425352

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/mstable/mStable-contracts/commit/<a class=hub.com/mstable/mStable-contracts/commit/59ae9b9bcd250640660b9131a10c2e90ad887fce">59ae9b9bc<a href="https://github.com/mstable/mStable-contracts/commit/59ae9b9bcd250640660b9131a10c2e90ad887fce">">Merge </a><a class="double-link" href="https://github.com/mstable/mStable-contracts/commit/<a class="double-link" href="https://github.com/mstable/mStable-contracts/commit/8cb8e7926117d484af1bd9630e056df3dc8f0d43">8cb8e7926</a>">8cb8e7926</a><a href="https://github.com/mstable/mStable-contracts/commit/59ae9b9bcd250640660b9131a10c2e90ad887fce"> into 2d116c303">2d116c303</a>

Pull Request Pull Request #207: feat: Unit based cooldown

Run Details

1011 of 1186 branches covered (85.24%)

Branch coverage included in aggregate %.

25 of 25 new or added lines in 2 files covered. (100.0%)

2483 of 2705 relevant lines covered (91.79%)

1029.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.07

/contracts/governance/staking/StakedToken.sol

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.6;
pragma abicoder v2;

import "hardhat/console.sol";

import { IStakedToken } from "./interfaces/IStakedToken.sol";
import { GamifiedVotingToken } from "./GamifiedVotingToken.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Root } from "../../shared/Root.sol";
import "./GamifiedTokenStructs.sol";

/**
 * @title StakedToken
 * @notice StakedToken is a non-transferrable ERC20 token that allows users to stake and withdraw, earning voting rights.
 * Scaled balance is determined by quests a user completes, and the length of time they keep the raw balance wrapped.
 * Stakers can unstake, after the elapsed cooldown period, and before the end of the unstake window. Users voting/earning
 * power is slashed during this time, and they may face a redemption fee if they leave early.
 * The reason for this unstake window is that this StakedToken acts as a source of insurance value for the mStable system,
 * which can access the funds via the Recollateralisation module, up to the amount defined in `safetyData`.
 * Voting power can be used for a number of things: voting in the mStable DAO/emission dials, boosting rewards, earning
 * rewards here. While a users "balance" is unique to themselves, they can choose to delegate their voting power (which will apply
 * to voting in the mStable DAO and emission dials).
 * @author mStable
 * @dev Only whitelisted contracts can communicate with this contract, in order to avoid having tokenised wrappers that
 * could potentially circumvent our unstaking procedure.
 **/
contract StakedToken is IStakedToken, GamifiedVotingToken {
    using SafeERC20 for IERC20;

    /// @notice Core token that is staked and tracked (e.g. MTA)
    IERC20 public immutable STAKED_TOKEN;
    /// @notice Seconds a user must wait after she initiates her cooldown before withdrawal is possible
    uint256 public immutable COOLDOWN_SECONDS;
    /// @notice Window in which it is possible to withdraw, following the cooldown period
    uint256 public immutable UNSTAKE_WINDOW;
    /// @notice A week
    uint256 private constant ONE_WEEK = 7 days;

    struct SafetyData {
        /// Percentage of collateralisation where 100% = 1e18
        uint128 collateralisationRatio;
        /// Slash % where 100% = 1e18
        uint128 slashingPercentage;
    }

    /// @notice Data relating to the re-collateralisation safety module
    SafetyData public safetyData;

    /// @notice Whitelisted smart contract integrations
    mapping(address => bool) public whitelistedWrappers;

    event Staked(address indexed user, uint256 amount, address delegatee);
    event Withdraw(address indexed user, address indexed to, uint256 amount);
    event Cooldown(address indexed user, uint256 percentage);
    event CooldownExited(address indexed user);
    event SlashRateChanged(uint256 newRate);
    event Recollateralised();
    event WrapperWhitelisted(address wallet);
    event WrapperBlacklisted(address wallet);

    /***************************************
                    INIT
    ****************************************/

    /**
     * @param _signer Signer address is used to verify completion of quests off chain
     * @param _nexus System nexus
     * @param _rewardsToken Token that is being distributed as a reward. eg MTA
     * @param _stakedToken Core token that is staked and tracked (e.g. MTA)
     * @param _cooldownSeconds Seconds a user must wait after she initiates her cooldown before withdrawal is possible
     * @param _unstakeWindow Window in which it is possible to withdraw, following the cooldown period
     */
    constructor(
        address _signer,
        address _nexus,
        address _rewardsToken,
        address _stakedToken,
        uint256 _cooldownSeconds,
        uint256 _unstakeWindow
    ) GamifiedVotingToken(_signer, _nexus, _rewardsToken) {
        STAKED_TOKEN = IERC20(_stakedToken);
        COOLDOWN_SECONDS = _cooldownSeconds;
        UNSTAKE_WINDOW = _unstakeWindow;
    }

    /**
     * @param _nameArg Token name
     * @param _symbolArg Token symbol
     * @param _rewardsDistributorArg mStable Rewards Distributor
     */
    function initialize(
        string memory _nameArg,
        string memory _symbolArg,
        address _rewardsDistributorArg
    ) external initializer {
        __GamifiedToken_init(_nameArg, _symbolArg, _rewardsDistributorArg);
        safetyData = SafetyData({ collateralisationRatio: 1e18, slashingPercentage: 0 });
    }

    /**
     * @dev Only the recollateralisation module, as specified in the mStable Nexus, can execute this
     */
    modifier onlyRecollateralisationModule() {
        require(_msgSender() == _recollateraliser(), "Only Recollateralisation Module");
        _;
    }

    /**
     * @dev This protects against fn's being called after a recollateralisation event, when the contract is essentially finished
     */
    modifier onlyBeforeRecollateralisation() {
        _onlyBeforeRecollateralisation();
        _;
    }

    function _onlyBeforeRecollateralisation() internal view {
        require(safetyData.collateralisationRatio == 1e18, "Only while fully collateralised");
    }

    /**
     * @dev Only whitelisted contracts can call core fns. mStable governors can whitelist and de-whitelist wrappers.
     * Access may be given to yield optimisers to boost rewards, but creating unlimited and ungoverned wrappers is unadvised.
     */
    modifier assertNotContract() {
        _assertNotContract();
        _;
    }

    function _assertNotContract() internal view {
        if (_msgSender() != tx.origin) {
            require(
                whitelistedWrappers[_msgSender()],
                "Transactions from non-whitelisted smart contracts not allowed"
            );
        }
    }

    /***************************************
                    ACTIONS
    ****************************************/

    /**
     * @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
     * boosts their voting power.
     * @param _amount Units of STAKED_TOKEN to stake
     */
    function stake(uint256 _amount) external override {
        _transferAndStake(_amount, address(0), false);
    }

    /**
     * @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
     * boosts their voting power.
     * @param _amount Units of STAKED_TOKEN to stake
     * @param _exitCooldown Bool signalling whether to take this opportunity to end any outstanding cooldown and
     * return the user back to their full voting power
     */
    function stake(uint256 _amount, bool _exitCooldown) external {
        _transferAndStake(_amount, address(0), _exitCooldown);
    }

    /**
     * @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
     * boosts their voting power. Take the opportunity to change delegatee.
     * @param _amount Units of STAKED_TOKEN to stake
     * @param _delegatee Address of the user to whom the sender would like to delegate their voting power
     */
    function stake(uint256 _amount, address _delegatee) external override {
        _transferAndStake(_amount, _delegatee, false);
    }

    /**
     * @dev Transfers tokens from sender before calling `_settleStake`
     */
    function _transferAndStake(
        uint256 _amount,
        address _delegatee,
        bool _exitCooldown
    ) internal {
        STAKED_TOKEN.safeTransferFrom(_msgSender(), address(this), _amount);
        _settleStake(_amount, _delegatee, _exitCooldown);
    }

    /**
     * @dev Internal stake fn. Can only be called by whitelisted contracts/EOAs and only before a recollateralisation event.
     * NOTE - Assumes tokens have already been transferred
     * @param _amount Units of STAKED_TOKEN to stake
     * @param _delegatee Address of the user to whom the sender would like to delegate their voting power
     * @param _exitCooldown Bool signalling whether to take this opportunity to end any outstanding cooldown and
     * return the user back to their full voting power
     */
    function _settleStake(
        uint256 _amount,
        address _delegatee,
        bool _exitCooldown
    ) internal onlyBeforeRecollateralisation assertNotContract {
        require(_amount != 0, "INVALID_ZERO_AMOUNT");

        // 1. Apply the delegate if it has been chosen (else it defaults to the sender)
        if (_delegatee != address(0)) {
            _delegate(_msgSender(), _delegatee);
        }

        // 2. Deal with cooldown
        //      If a user is currently in a cooldown period, re-calculate their cooldown timestamp
        CooldownData memory oldCooldown = stakersCooldowns[_msgSender()];
        //      If we have missed the unstake window, or the user has chosen to exit the cooldown,
        //      then reset the timestamp to 0
        bool exitCooldown = _exitCooldown ||
            block.timestamp > (oldCooldown.timestamp + COOLDOWN_SECONDS + UNSTAKE_WINDOW);
        if (exitCooldown) {
            emit CooldownExited(_msgSender());
        }

        // 3. Settle the stake by depositing the STAKED_TOKEN and minting voting power
        _mintRaw(_msgSender(), _amount, exitCooldown);

        emit Staked(_msgSender(), _amount, _delegatee);
    }

    /**
     * @dev Withdraw raw tokens from the system, following an elapsed cooldown period.
     * Note - May be subject to a transfer fee, depending on the users weightedTimestamp
     * @param _amount Units of raw token to withdraw
     * @param _recipient Address of beneficiary who will receive the raw tokens
     * @param _amountIncludesFee Is the `_amount` specified inclusive of any applicable redemption fee?
     * @param _exitCooldown Should we take this opportunity to exit the cooldown period?
     **/
    function withdraw(
        uint256 _amount,
        address _recipient,
        bool _amountIncludesFee,
        bool _exitCooldown
    ) external override {
        _withdraw(_amount, _recipient, _amountIncludesFee, _exitCooldown);
    }

    /**
     * @dev Withdraw raw tokens from the system, following an elapsed cooldown period.
     * Note - May be subject to a transfer fee, depending on the users weightedTimestamp
     * @param _amount Units of raw token to withdraw
     * @param _recipient Address of beneficiary who will receive the raw tokens
     * @param _amountIncludesFee Is the `_amount` specified inclusive of any applicable redemption fee?
     * @param _exitCooldown Should we take this opportunity to exit the cooldown period?
     **/
    function _withdraw(
        uint256 _amount,
        address _recipient,
        bool _amountIncludesFee,
        bool _exitCooldown
    ) internal assertNotContract {
        require(_amount != 0, "INVALID_ZERO_AMOUNT");

        // Is the contract post-recollateralisation?
        if (safetyData.collateralisationRatio != 1e18) {
            // 1. If recollateralisation has occured, the contract is finished and we can skip all checks
            _burnRaw(_msgSender(), _amount, false);
            // 2. Return a proportionate amount of tokens, based on the collateralisation ratio
            STAKED_TOKEN.safeTransfer(
                _recipient,
                (_amount * safetyData.collateralisationRatio) / 1e18
            );
            emit Withdraw(_msgSender(), _recipient, _amount);
        } else {
            // 1. If no recollateralisation has occured, the user must be within their UNSTAKE_WINDOW period in order to withdraw
            CooldownData memory cooldown = stakersCooldowns[_msgSender()];
            require(
                block.timestamp > cooldown.timestamp + COOLDOWN_SECONDS,
                "INSUFFICIENT_COOLDOWN"
            );
            require(
                block.timestamp - (cooldown.timestamp + COOLDOWN_SECONDS) <= UNSTAKE_WINDOW,
                "UNSTAKE_WINDOW_FINISHED"
            );

            // 2. Get current balance
            Balance memory balance = _balances[_msgSender()];

            // 3. Apply redemption fee
            //      e.g. (55e18 / 5e18) - 2e18 = 9e18 / 100 = 9e16
            uint256 feeRate = calcRedemptionFeeRate(balance.weightedTimestamp);
            //      fee = amount * 1e18 / feeRate
            //      totalAmount = amount + fee
            uint256 totalWithdraw = _amountIncludesFee
                ? _amount
                : (_amount * (1e18 + feeRate)) / 1e18;
            uint256 userWithdrawal = (totalWithdraw * 1e18) / (1e18 + feeRate);

            //      Check for percentage withdrawal
            uint256 maxWithdrawal = cooldown.units;
            require(totalWithdraw <= maxWithdrawal, "Exceeds max withdrawal");

            // 4. Exit cooldown if the user has specified, or if they have withdrawn everything
            // Otherwise, update the percentage remaining proportionately
            bool exitCooldown = _exitCooldown || totalWithdraw == maxWithdrawal;

            // 5. Settle the withdrawal by burning the voting tokens
            _burnRaw(_msgSender(), totalWithdraw, exitCooldown);
            //      Log any redemption fee to the rewards contract
            _notifyAdditionalReward(totalWithdraw - userWithdrawal);
            //      Finally transfer tokens back to recipient
            STAKED_TOKEN.safeTransfer(_recipient, userWithdrawal);

            emit Withdraw(_msgSender(), _recipient, _amount);
        }
    }

    /**
     * @dev Enters a cooldown period, after which (and before the unstake window elapses) a user will be able
     * to withdraw part or all of their staked tokens. Note, during this period, a users voting power is significantly reduced.
     * If a user already has a cooldown period, then it will reset to the current block timestamp, so use wisely.
     * @param _units Units of stake to cooldown for
     **/
    function startCooldown(uint256 _units) external override {
        _startCooldown(_units);
    }

    /**
     * @dev Ends the cooldown of the sender and give them back their full voting power. This can be used to signal that
     * the user no longer wishes to exit the system. Note, the cooldown can also be reset, more smoothly, as part of a stake or
     * withdraw transaction.
     **/
    function endCooldown() external {
        require(stakersCooldowns[_msgSender()].timestamp != 0, "No cooldown");

        _exitCooldownPeriod(_msgSender());

        emit CooldownExited(_msgSender());
    }

    /**
     * @dev Enters a cooldown period, after which (and before the unstake window elapses) a user will be able
     * to withdraw part or all of their staked tokens. Note, during this period, a users voting power is significantly reduced.
     * If a user already has a cooldown period, then it will reset to the current block timestamp, so use wisely.
     * @param _units Units of stake to cooldown for
     **/
    function _startCooldown(uint256 _units) internal {
        require(balanceOf(_msgSender()) != 0, "INVALID_BALANCE_ON_COOLDOWN");

        _enterCooldownPeriod(_msgSender(), _units);

        emit Cooldown(_msgSender(), _units);
    }

    /***************************************
                    ADMIN
    ****************************************/

    /**
     * @dev This is a write function allowing the whitelisted recollateralisation module to slash stakers here and take
     * the capital to use to recollateralise any lost value in the system. Trusting that the recollateralisation module has
     * sufficient protections put in place. Note, once this has been executed, the contract is now finished, and undercollateralised,
     * meaning that all users must withdraw, and will only receive a proportionate amount back relative to the colRatio.
     **/
    function emergencyRecollateralisation()
        external
        onlyRecollateralisationModule
        onlyBeforeRecollateralisation
    {
        // 1. Change collateralisation rate
        safetyData.collateralisationRatio = 1e18 - safetyData.slashingPercentage;
        // 2. Take slashing percentage
        uint256 balance = STAKED_TOKEN.balanceOf(address(this));
        STAKED_TOKEN.safeTransfer(
            _recollateraliser(),
            (balance * safetyData.slashingPercentage) / 1e18
        );
        // 3. No functions should work anymore because the colRatio has changed
        emit Recollateralised();
    }

    /**
     * @dev Governance can change the slashing percentage here (initially 0). This is the amount of a stakers capital that is at
     * risk in the recollateralisation process.
     * @param _newRate Rate, where 50% == 5e17
     **/
    function changeSlashingPercentage(uint256 _newRate)
        external
        onlyGovernor
        onlyBeforeRecollateralisation
    {
        require(safetyData.collateralisationRatio == 1e18, "Process already begun");
        require(_newRate <= 5e17, "Cannot exceed 50%");

        safetyData.slashingPercentage = SafeCast.toUint128(_newRate);

        emit SlashRateChanged(_newRate);
    }

    /**
     * @dev Allows governance to whitelist a smart contract to interact with the StakedToken (for example a yield aggregator or simply
     * a Gnosis SAFE or other)
     * @param _wrapper Address of the smart contract to list
     **/
    function whitelistWrapper(address _wrapper) external onlyGovernor {
        whitelistedWrappers[_wrapper] = true;

        emit WrapperWhitelisted(_wrapper);
    }

    /**
     * @dev Allows governance to blacklist a smart contract to end it's interaction with the StakedToken
     * @param _wrapper Address of the smart contract to blacklist
     **/
    function blackListWrapper(address _wrapper) external onlyGovernor {
        whitelistedWrappers[_wrapper] = false;

        emit WrapperBlacklisted(_wrapper);
    }

    /***************************************
            BACKWARDS COMPATIBILITY
    ****************************************/

    /**
     * @dev Allows for backwards compatibility with createLock fn, giving basic args to stake
     * @param _value Units to stake
     **/
    function createLock(
        uint256 _value,
        uint256 /* _unlockTime */
    ) external {
        _transferAndStake(_value, address(0), false);
    }

    /**
     * @dev Allows for backwards compatibility with increaseLockAmount fn by simply staking more
     * @param _value Units to stake
     **/
    function increaseLockAmount(uint256 _value) external {
        _transferAndStake(_value, address(0), false);
    }

    /**
     * @dev Does nothing, because there is no lockup here.
     **/
    function increaseLockLength(
        uint256 /* _unlockTime */
    ) external virtual {
        return;
    }

    /**
     * @dev Backwards compatibility. Previously a lock would run out and a user would call this. Now, it will take 2 calls
     * to exit in order to leave. The first will initiate the cooldown period, and the second will execute a full withdrawal.
     **/
    function exit() external virtual {
        // Since there is no immediate exit here, this can be called twice
        // If there is no cooldown, or the cooldown has passed the unstake window, enter cooldown
        uint128 ts = stakersCooldowns[_msgSender()].timestamp;
        if (ts == 0 || block.timestamp > ts + COOLDOWN_SECONDS + UNSTAKE_WINDOW) {
            (uint256 raw, uint256 cooldownUnits) = rawBalanceOf(_msgSender());
            _startCooldown(raw + cooldownUnits);
        }
        // Else withdraw all available
        else {
            _withdraw(stakersCooldowns[_msgSender()].units, _msgSender(), true, false);
        }
    }

    /***************************************
                    GETTERS
    ****************************************/

    /**
     * @dev fee = sqrt(300/x)-2.5, where x = weeks since user has staked
     * @param _weightedTimestamp The users weightedTimestamp
     * @return _feeRate where 1% == 1e16
     */
    function calcRedemptionFeeRate(uint32 _weightedTimestamp)
        public
        view
        returns (uint256 _feeRate)
    {
        uint256 weeksStaked = ((block.timestamp - _weightedTimestamp) * 1e18) / ONE_WEEK;
        if (weeksStaked > 2e18) {
            // e.g. weeks = 1  = sqrt(300e18) = 17320508075
            // e.g. weeks = 10 = sqrt(30e18) =   5477225575
            // e.g. weeks = 26 = sqrt(11.5) =    3391164991
            _feeRate = Root.sqrt(300e36 / weeksStaked) * 1e7;
            // e.g. weeks = 1  = 173e15 - 25e15 = 148e15 or 14.8%
            // e.g. weeks = 10 =  55e15 - 25e15 = 30e15 or 3%
            // e.g. weeks = 26 =  34e15 - 25e15 = 9e15 or 0.9%
            _feeRate = _feeRate < 25e15 ? 0 : _feeRate - 25e15;
        } else {
            _feeRate = 1e17;
        }
    }

    uint256[47] private __gap;
}

1	// SPDX-License-Identifier: AGPL-3.0-or-later
2	pragma solidity 0.8.6;
3	pragma abicoder v2;
4
5	import "hardhat/console.sol";
6
7	import { IStakedToken } from "./interfaces/IStakedToken.sol";
8	import { GamifiedVotingToken } from "./GamifiedVotingToken.sol";
9	import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
10	import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
11	import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
12	import { Root } from "../../shared/Root.sol";
13	import "./GamifiedTokenStructs.sol";
14
15	/**
16	* @title StakedToken
17	* @notice StakedToken is a non-transferrable ERC20 token that allows users to stake and withdraw, earning voting rights.
18	* Scaled balance is determined by quests a user completes, and the length of time they keep the raw balance wrapped.
19	* Stakers can unstake, after the elapsed cooldown period, and before the end of the unstake window. Users voting/earning
20	* power is slashed during this time, and they may face a redemption fee if they leave early.
21	* The reason for this unstake window is that this StakedToken acts as a source of insurance value for the mStable system,
22	* which can access the funds via the Recollateralisation module, up to the amount defined in `safetyData`.
23	* Voting power can be used for a number of things: voting in the mStable DAO/emission dials, boosting rewards, earning
24	* rewards here. While a users "balance" is unique to themselves, they can choose to delegate their voting power (which will apply
25	* to voting in the mStable DAO and emission dials).
26	* @author mStable
27	* @dev Only whitelisted contracts can communicate with this contract, in order to avoid having tokenised wrappers that
28	* could potentially circumvent our unstaking procedure.
29	**/
30	contract StakedToken is IStakedToken, GamifiedVotingToken {
31	using SafeERC20 for IERC20;
32
33	/// @notice Core token that is staked and tracked (e.g. MTA)
34	IERC20 public immutable STAKED_TOKEN;
35	/// @notice Seconds a user must wait after she initiates her cooldown before withdrawal is possible
36	uint256 public immutable COOLDOWN_SECONDS;
37	/// @notice Window in which it is possible to withdraw, following the cooldown period
38	uint256 public immutable UNSTAKE_WINDOW;
39	/// @notice A week
40	uint256 private constant ONE_WEEK = 7 days;
41
42	struct SafetyData {
43	/// Percentage of collateralisation where 100% = 1e18
44	uint128 collateralisationRatio;
45	/// Slash % where 100% = 1e18
46	uint128 slashingPercentage;
47	}
48
49	/// @notice Data relating to the re-collateralisation safety module
50	SafetyData public safetyData;
51
52	/// @notice Whitelisted smart contract integrations
53	mapping(address => bool) public whitelistedWrappers;
54
55	event Staked(address indexed user, uint256 amount, address delegatee);
56	event Withdraw(address indexed user, address indexed to, uint256 amount);
57	event Cooldown(address indexed user, uint256 percentage);
58	event CooldownExited(address indexed user);
59	event SlashRateChanged(uint256 newRate);
60	event Recollateralised();
61	event WrapperWhitelisted(address wallet);
62	event WrapperBlacklisted(address wallet);
63
64	/***************************************
65	INIT
66	****************************************/
67
68	/**
69	* @param _signer Signer address is used to verify completion of quests off chain
70	* @param _nexus System nexus
71	* @param _rewardsToken Token that is being distributed as a reward. eg MTA
72	* @param _stakedToken Core token that is staked and tracked (e.g. MTA)
73	* @param _cooldownSeconds Seconds a user must wait after she initiates her cooldown before withdrawal is possible
74	* @param _unstakeWindow Window in which it is possible to withdraw, following the cooldown period
75	*/
76	constructor(
77	address _signer,
78	address _nexus,
79	address _rewardsToken,
80	address _stakedToken,
81	uint256 _cooldownSeconds,
82	uint256 _unstakeWindow
83	) GamifiedVotingToken(_signer, _nexus, _rewardsToken) {
84	STAKED_TOKEN = IERC20(_stakedToken);	195✔
85	COOLDOWN_SECONDS = _cooldownSeconds;	195✔
86	UNSTAKE_WINDOW = _unstakeWindow;	195✔
87	}
88
89	/**
90	* @param _nameArg Token name
91	* @param _symbolArg Token symbol
92	* @param _rewardsDistributorArg mStable Rewards Distributor
93	*/
94	function initialize(
95	string memory _nameArg,
96	string memory _symbolArg,
97	address _rewardsDistributorArg
98	) external initializer {
99	__GamifiedToken_init(_nameArg, _symbolArg, _rewardsDistributorArg);	195✔
100	safetyData = SafetyData({ collateralisationRatio: 1e18, slashingPercentage: 0 });	195✔
101	}
102
103	/**
104	* @dev Only the recollateralisation module, as specified in the mStable Nexus, can execute this
105	*/
106	modifier onlyRecollateralisationModule() {
107	require(_msgSender() == _recollateraliser(), "Only Recollateralisation Module");	×
108	_;	×
109	}
110
111	/**
112	* @dev This protects against fn's being called after a recollateralisation event, when the contract is essentially finished
113	*/
114	modifier onlyBeforeRecollateralisation() {
115	_onlyBeforeRecollateralisation();	893✔
116	_;	893✔
117	}
118
119	function _onlyBeforeRecollateralisation() internal view {
120	require(safetyData.collateralisationRatio == 1e18, "Only while fully collateralised");	893!
121	}
122
123	/**
124	* @dev Only whitelisted contracts can call core fns. mStable governors can whitelist and de-whitelist wrappers.
125	* Access may be given to yield optimisers to boost rewards, but creating unlimited and ungoverned wrappers is unadvised.
126	*/
127	modifier assertNotContract() {
128	_assertNotContract();	950✔
129	_;	950✔
130	}
131
132	function _assertNotContract() internal view {
133	if (_msgSender() != tx.origin) {	950!
134	require(	×
135	whitelistedWrappers[_msgSender()],
136	"Transactions from non-whitelisted smart contracts not allowed"
137	);
138	}
139	}
140
141	/***************************************
142	ACTIONS
143	****************************************/
144
145	/**
146	* @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
147	* boosts their voting power.
148	* @param _amount Units of STAKED_TOKEN to stake
149	*/
150	function stake(uint256 _amount) external override {
151	_transferAndStake(_amount, address(0), false);	26✔
152	}
153
154	/**
155	* @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
156	* boosts their voting power.
157	* @param _amount Units of STAKED_TOKEN to stake
158	* @param _exitCooldown Bool signalling whether to take this opportunity to end any outstanding cooldown and
159	* return the user back to their full voting power
160	*/
161	function stake(uint256 _amount, bool _exitCooldown) external {
162	_transferAndStake(_amount, address(0), _exitCooldown);	13✔
163	}
164
165	/**
166	* @dev Stake an `_amount` of STAKED_TOKEN in the system. This amount is added to the users stake and
167	* boosts their voting power. Take the opportunity to change delegatee.
168	* @param _amount Units of STAKED_TOKEN to stake
169	* @param _delegatee Address of the user to whom the sender would like to delegate their voting power
170	*/
171	function stake(uint256 _amount, address _delegatee) external override {
172	_transferAndStake(_amount, _delegatee, false);	854✔
173	}
174
175	/**
176	* @dev Transfers tokens from sender before calling `_settleStake`
177	*/
178	function _transferAndStake(
179	uint256 _amount,
180	address _delegatee,
181	bool _exitCooldown
182	) internal {
183	STAKED_TOKEN.safeTransferFrom(_msgSender(), address(this), _amount);	893✔
184	_settleStake(_amount, _delegatee, _exitCooldown);	893✔
185	}
186
187	/**
188	* @dev Internal stake fn. Can only be called by whitelisted contracts/EOAs and only before a recollateralisation event.
189	* NOTE - Assumes tokens have already been transferred
190	* @param _amount Units of STAKED_TOKEN to stake
191	* @param _delegatee Address of the user to whom the sender would like to delegate their voting power
192	* @param _exitCooldown Bool signalling whether to take this opportunity to end any outstanding cooldown and
193	* return the user back to their full voting power
194	*/
195	function _settleStake(
196	uint256 _amount,
197	address _delegatee,
198	bool _exitCooldown
199	) internal onlyBeforeRecollateralisation assertNotContract {
200	require(_amount != 0, "INVALID_ZERO_AMOUNT");	893!
201
202	// 1. Apply the delegate if it has been chosen (else it defaults to the sender)
203	if (_delegatee != address(0)) {	893✔
204	_delegate(_msgSender(), _delegatee);	854✔
205	}
206
207	// 2. Deal with cooldown
208	// If a user is currently in a cooldown period, re-calculate their cooldown timestamp
209	CooldownData memory oldCooldown = stakersCooldowns[_msgSender()];	893✔
210	// If we have missed the unstake window, or the user has chosen to exit the cooldown,
211	// then reset the timestamp to 0
212	bool exitCooldown = _exitCooldown \|\|	893✔
213	block.timestamp > (oldCooldown.timestamp + COOLDOWN_SECONDS + UNSTAKE_WINDOW);
214	if (exitCooldown) {	893✔
215	emit CooldownExited(_msgSender());	880✔
216	}
217
218	// 3. Settle the stake by depositing the STAKED_TOKEN and minting voting power
219	_mintRaw(_msgSender(), _amount, exitCooldown);	893✔
220
221	emit Staked(_msgSender(), _amount, _delegatee);	826✔
222	}
223
224	/**
225	* @dev Withdraw raw tokens from the system, following an elapsed cooldown period.
226	* Note - May be subject to a transfer fee, depending on the users weightedTimestamp
227	* @param _amount Units of raw token to withdraw
228	* @param _recipient Address of beneficiary who will receive the raw tokens
229	* @param _amountIncludesFee Is the `_amount` specified inclusive of any applicable redemption fee?
230	* @param _exitCooldown Should we take this opportunity to exit the cooldown period?
231	**/
232	function withdraw(
233	uint256 _amount,
234	address _recipient,
235	bool _amountIncludesFee,
236	bool _exitCooldown
237	) external override {
238	_withdraw(_amount, _recipient, _amountIncludesFee, _exitCooldown);	57✔
239	}
240
241	/**
242	* @dev Withdraw raw tokens from the system, following an elapsed cooldown period.
243	* Note - May be subject to a transfer fee, depending on the users weightedTimestamp
244	* @param _amount Units of raw token to withdraw
245	* @param _recipient Address of beneficiary who will receive the raw tokens
246	* @param _amountIncludesFee Is the `_amount` specified inclusive of any applicable redemption fee?
247	* @param _exitCooldown Should we take this opportunity to exit the cooldown period?
248	**/
249	function _withdraw(
250	uint256 _amount,
251	address _recipient,
252	bool _amountIncludesFee,
253	bool _exitCooldown
254	) internal assertNotContract {
255	require(_amount != 0, "INVALID_ZERO_AMOUNT");	57✔
256
257	// Is the contract post-recollateralisation?
258	if (safetyData.collateralisationRatio != 1e18) {	56!
259	// 1. If recollateralisation has occured, the contract is finished and we can skip all checks
260	_burnRaw(_msgSender(), _amount, false);	×
261	// 2. Return a proportionate amount of tokens, based on the collateralisation ratio
262	STAKED_TOKEN.safeTransfer(	×
263	_recipient,
264	(_amount * safetyData.collateralisationRatio) / 1e18
265	);
266	emit Withdraw(_msgSender(), _recipient, _amount);	×
267	} else {
268	// 1. If no recollateralisation has occured, the user must be within their UNSTAKE_WINDOW period in order to withdraw
269	CooldownData memory cooldown = stakersCooldowns[_msgSender()];	56✔
270	require(	56✔
271	block.timestamp > cooldown.timestamp + COOLDOWN_SECONDS,
272	"INSUFFICIENT_COOLDOWN"
273	);
274	require(	55✔
275	block.timestamp - (cooldown.timestamp + COOLDOWN_SECONDS) <= UNSTAKE_WINDOW,
276	"UNSTAKE_WINDOW_FINISHED"
277	);
278
279	// 2. Get current balance
280	Balance memory balance = _balances[_msgSender()];	53✔
281
282	// 3. Apply redemption fee
283	// e.g. (55e18 / 5e18) - 2e18 = 9e18 / 100 = 9e16
284	uint256 feeRate = calcRedemptionFeeRate(balance.weightedTimestamp);	53✔
285	// fee = amount * 1e18 / feeRate
286	// totalAmount = amount + fee
287	uint256 totalWithdraw = _amountIncludesFee	53✔
288	? _amount
289	: (_amount * (1e18 + feeRate)) / 1e18;
290	uint256 userWithdrawal = (totalWithdraw * 1e18) / (1e18 + feeRate);	53✔
291
292	// Check for percentage withdrawal
293	uint256 maxWithdrawal = cooldown.units;	53✔
294	require(totalWithdraw <= maxWithdrawal, "Exceeds max withdrawal");	53✔
295
296	// 4. Exit cooldown if the user has specified, or if they have withdrawn everything
297	// Otherwise, update the percentage remaining proportionately
298	bool exitCooldown = _exitCooldown \|\| totalWithdraw == maxWithdrawal;	52✔
299
300	// 5. Settle the withdrawal by burning the voting tokens
301	_burnRaw(_msgSender(), totalWithdraw, exitCooldown);	52✔
302	// Log any redemption fee to the rewards contract
303	_notifyAdditionalReward(totalWithdraw - userWithdrawal);	52✔
304	// Finally transfer tokens back to recipient
305	STAKED_TOKEN.safeTransfer(_recipient, userWithdrawal);	52✔
306
307	emit Withdraw(_msgSender(), _recipient, _amount);	50✔
308	}
309	}
310
311	/**
312	* @dev Enters a cooldown period, after which (and before the unstake window elapses) a user will be able
313	* to withdraw part or all of their staked tokens. Note, during this period, a users voting power is significantly reduced.
314	* If a user already has a cooldown period, then it will reset to the current block timestamp, so use wisely.
315	* @param _units Units of stake to cooldown for
316	**/
317	function startCooldown(uint256 _units) external override {
318	_startCooldown(_units);	368✔
319	}
320
321	/**
322	* @dev Ends the cooldown of the sender and give them back their full voting power. This can be used to signal that
323	* the user no longer wishes to exit the system. Note, the cooldown can also be reset, more smoothly, as part of a stake or
324	* withdraw transaction.
325	**/
326	function endCooldown() external {
327	require(stakersCooldowns[_msgSender()].timestamp != 0, "No cooldown");	143!
328
329	_exitCooldownPeriod(_msgSender());	143✔
330
331	emit CooldownExited(_msgSender());	121✔
332	}
333
334	/**
335	* @dev Enters a cooldown period, after which (and before the unstake window elapses) a user will be able
336	* to withdraw part or all of their staked tokens. Note, during this period, a users voting power is significantly reduced.
337	* If a user already has a cooldown period, then it will reset to the current block timestamp, so use wisely.
338	* @param _units Units of stake to cooldown for
339	**/
340	function _startCooldown(uint256 _units) internal {
341	require(balanceOf(_msgSender()) != 0, "INVALID_BALANCE_ON_COOLDOWN");	368✔
342
343	_enterCooldownPeriod(_msgSender(), _units);	366✔
344
345	emit Cooldown(_msgSender(), _units);	336✔
346	}
347
348	/***************************************
349	ADMIN
350	****************************************/
351
352	/**
353	* @dev This is a write function allowing the whitelisted recollateralisation module to slash stakers here and take
354	* the capital to use to recollateralise any lost value in the system. Trusting that the recollateralisation module has
355	* sufficient protections put in place. Note, once this has been executed, the contract is now finished, and undercollateralised,
356	* meaning that all users must withdraw, and will only receive a proportionate amount back relative to the colRatio.
357	**/
358	function emergencyRecollateralisation()
359	external
360	onlyRecollateralisationModule
361	onlyBeforeRecollateralisation
362	{
363	// 1. Change collateralisation rate
364	safetyData.collateralisationRatio = 1e18 - safetyData.slashingPercentage;	×
365	// 2. Take slashing percentage
366	uint256 balance = STAKED_TOKEN.balanceOf(address(this));	×
367	STAKED_TOKEN.safeTransfer(	×
368	_recollateraliser(),
369	(balance * safetyData.slashingPercentage) / 1e18
370	);
371	// 3. No functions should work anymore because the colRatio has changed
372	emit Recollateralised();	×
373	}
374
375	/**
376	* @dev Governance can change the slashing percentage here (initially 0). This is the amount of a stakers capital that is at
377	* risk in the recollateralisation process.
378	* @param _newRate Rate, where 50% == 5e17
379	**/
380	function changeSlashingPercentage(uint256 _newRate)
381	external
382	onlyGovernor
383	onlyBeforeRecollateralisation
384	{
385	require(safetyData.collateralisationRatio == 1e18, "Process already begun");	×
386	require(_newRate <= 5e17, "Cannot exceed 50%");	×
387
388	safetyData.slashingPercentage = SafeCast.toUint128(_newRate);	×
389
390	emit SlashRateChanged(_newRate);	×
391	}
392
393	/**
394	* @dev Allows governance to whitelist a smart contract to interact with the StakedToken (for example a yield aggregator or simply
395	* a Gnosis SAFE or other)
396	* @param _wrapper Address of the smart contract to list
397	**/
398	function whitelistWrapper(address _wrapper) external onlyGovernor {
399	whitelistedWrappers[_wrapper] = true;	×
400
401	emit WrapperWhitelisted(_wrapper);	×
402	}
403
404	/**
405	* @dev Allows governance to blacklist a smart contract to end it's interaction with the StakedToken
406	* @param _wrapper Address of the smart contract to blacklist
407	**/
408	function blackListWrapper(address _wrapper) external onlyGovernor {
409	whitelistedWrappers[_wrapper] = false;	×
410
411	emit WrapperBlacklisted(_wrapper);	×
412	}
413
414	/***************************************
415	BACKWARDS COMPATIBILITY
416	****************************************/
417
418	/**
419	* @dev Allows for backwards compatibility with createLock fn, giving basic args to stake
420	* @param _value Units to stake
421	**/
422	function createLock(
423	uint256 _value,
424	uint256 /* _unlockTime */
425	) external {
426	_transferAndStake(_value, address(0), false);	×
427	}
428
429	/**
430	* @dev Allows for backwards compatibility with increaseLockAmount fn by simply staking more
431	* @param _value Units to stake
432	**/
433	function increaseLockAmount(uint256 _value) external {
434	_transferAndStake(_value, address(0), false);	×
435	}
436
437	/**
438	* @dev Does nothing, because there is no lockup here.
439	**/
440	function increaseLockLength(
441	uint256 /* _unlockTime */
442	) external virtual {
443	return;	×
444	}
445
446	/**
447	* @dev Backwards compatibility. Previously a lock would run out and a user would call this. Now, it will take 2 calls
448	* to exit in order to leave. The first will initiate the cooldown period, and the second will execute a full withdrawal.
449	**/
450	function exit() external virtual {
451	// Since there is no immediate exit here, this can be called twice
452	// If there is no cooldown, or the cooldown has passed the unstake window, enter cooldown
453	uint128 ts = stakersCooldowns[_msgSender()].timestamp;	×
454	if (ts == 0 \|\| block.timestamp > ts + COOLDOWN_SECONDS + UNSTAKE_WINDOW) {	×
455	(uint256 raw, uint256 cooldownUnits) = rawBalanceOf(_msgSender());	×
456	_startCooldown(raw + cooldownUnits);	×
457	}
458	// Else withdraw all available
459	else {
460	_withdraw(stakersCooldowns[_msgSender()].units, _msgSender(), true, false);	×
461	}
462	}
463
464	/***************************************
465	GETTERS
466	****************************************/
467
468	/**
469	* @dev fee = sqrt(300/x)-2.5, where x = weeks since user has staked
470	* @param _weightedTimestamp The users weightedTimestamp
471	* @return _feeRate where 1% == 1e16
472	*/
473	function calcRedemptionFeeRate(uint32 _weightedTimestamp)
474	public
475	view
476	returns (uint256 _feeRate)
477	{
478	uint256 weeksStaked = ((block.timestamp - _weightedTimestamp) * 1e18) / ONE_WEEK;	53✔
479	if (weeksStaked > 2e18) {	53!
480	// e.g. weeks = 1 = sqrt(300e18) = 17320508075
481	// e.g. weeks = 10 = sqrt(30e18) = 5477225575
482	// e.g. weeks = 26 = sqrt(11.5) = 3391164991
483	_feeRate = Root.sqrt(300e36 / weeksStaked) * 1e7;	×
484	// e.g. weeks = 1 = 173e15 - 25e15 = 148e15 or 14.8%
485	// e.g. weeks = 10 = 55e15 - 25e15 = 30e15 or 3%
486	// e.g. weeks = 26 = 34e15 - 25e15 = 9e15 or 0.9%
487	_feeRate = _feeRate < 25e15 ? 0 : _feeRate - 25e15;	×
488	} else {
489	_feeRate = 1e17;	53✔
490	}
491	}
492
493	uint256[47] private __gap;
494	}

mstable / mStable-contracts / 1150425352

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous