Yield Yak

1// SPDX-License-Identifier: MIT
2pragma solidity 0.8.13;
3
4import "../lib/Ownable.sol";
5import "../lib/SafeMath.sol";
6import "../lib/SafeERC20.sol";
7
8/**
9 * @title YY Staking
10 * @author Yield Yak
11 * @notice YyStaking is a contract that allows ERC20 dpeosits and receives rewards from token balances which may be
12 * transferred in without an additional function call. The contract is based on StableJoeStaking from Trader Joe.
13 * Users deposit X and receive a share of what has been sent based on their participation of the total deposits.
14 * It is similar to a MasterChef, but we allow for claiming of different reward tokens.
15 * Every time `updateReward(token)` is called, We distribute the balance of that tokens as rewards to users that are
16 * currently staking inside this contract, and they can claim it using `withdraw(0)`
17 */
18contract YyStaking is Ownable {
19    using SafeMath for uint256;
20    using SafeERC20 for IERC20;
21
22    /// @notice Info of each user
23    struct UserInfo {
24        uint256 amount;
25        mapping(IERC20 => uint256) rewardDebt;
26        /**
27         * @notice We do some fancy math here. Basically, any point in time, the amount of deposit tokens
28         * entitled to a user but is pending to be distributed is:
29         *
30         *   pending reward = (user.amount * accRewardPerShare) - user.rewardDebt[token]
31         *
32         * Whenever a user deposits or withdraws. Here's what happens:
33         *   1. accRewardPerShare (and `lastRewardBalance`) gets updated
34         *   2. User receives the pending reward sent to his/her address
35         *   3. User's `amount` gets updated
36         *   4. User's `rewardDebt[token]` gets updated
37         */
38    }
39
40    /// @notice Farm deposit token
41    IERC20 public depositToken;
42
43    /// @dev Internal balance of depositToken, this gets updated on user deposits / withdrawals
44    /// this allows to reward users with depositToken
45    uint256 public internalBalance;
46
47    /// @notice Array of tokens that users can claim
48    IERC20[] public rewardTokens;
49    mapping(IERC20 => bool) public isRewardToken;
50
51    /// @notice Last reward balance of `token`
52    mapping(IERC20 => uint256) public lastRewardBalance;
53
54    address public feeCollector;
55
56    /// @notice The deposit fee, scaled to `DEPOSIT_FEE_PERCENT_PRECISION`
57    uint256 public depositFeePercent;
58
59    /// @dev The precision of `depositFeePercent`
60    uint256 internal constant DEPOSIT_FEE_PERCENT_PRECISION = 10000;
61
62    /// @notice Accumulated `token` rewards per share, scaled to `ACC_REWARD_PER_SHARE_PRECISION`
63    mapping(IERC20 => uint256) public accRewardPerShare;
64    /// @notice The precision of `accRewardPerShare`
65    uint256 public ACC_REWARD_PER_SHARE_PRECISION;
66
67    /// @dev Info of each user that stakes
68    mapping(address => UserInfo) private userInfo;
69
70    /// @notice Emitted when a user deposits
71    event Deposit(address indexed user, uint256 amount, uint256 fee);
72
73    /// @notice Emitted when feeCollector changes the fee collector
74    event FeeCollectorChanged(address newFeeCollector, address oldFeeCollector);
75
76    /// @notice Emitted when owner changes the deposit fee percentage
77    event DepositFeeChanged(uint256 newFee, uint256 oldFee);
78
79    /// @notice Emitted when a user withdraws
80    event Withdraw(address indexed user, uint256 amount);
81
82    /// @notice Emitted when a user claims reward
83    event ClaimReward(address indexed user, address indexed rewardToken, uint256 amount);
84
85    /// @notice Emitted when a user emergency withdraws
86    event EmergencyWithdraw(address indexed user, uint256 amount);
87
88    /// @notice Emitted when owner adds a token to the reward tokens list
89    event RewardTokenAdded(address token);
90
91    /// @notice Emitted when owner removes a token from the reward tokens list
92    event RewardTokenRemoved(address token);
93
94    constructor(
95        IERC20 _depositToken,
96        IERC20 _rewardToken,
97        address _feeCollector
98    ) {
99        require(address(_depositToken) != address(0), "YyStaking::depositToken can't be address(0)");
100        require(address(_rewardToken) != address(0), "YyStaking::rewardToken can't be address(0)");
101        require(_feeCollector != address(0), "YyStaking::feeCollector can't be address(0)");
102
103        depositToken = _depositToken;
104        feeCollector = _feeCollector;
105
106        isRewardToken[_rewardToken] = true;
107        rewardTokens.push(_rewardToken);
108        ACC_REWARD_PER_SHARE_PRECISION = 1e24;
109    }
110
111    /**
112     * @notice Deposit for reward token allocation
113     * @param amount The amount of depositToken to deposit
114     */
115    function deposit(uint256 amount) external {
116        _deposit(msg.sender, amount);
117    }
118
119    /**
120     * @notice Deposit on behalf of another account
121     * @param account Account to deposit for
122     * @param amount The amount of depositToken to deposit
123     */
124    function depositFor(address account, uint256 amount) external {
125        _deposit(account, amount);
126    }
127
128    /**
129     * @notice Deposit using Permit
130     * @param amount The amount of depositToken to deposit
131     * @param deadline The time at which to expire the signature
132     * @param v The recovery byte of the signature
133     * @param r Half of the ECDSA signature pair
134     * @param s Half of the ECDSA signature pair
135     */
136    function depositWithPermit(
137        uint256 amount,
138        uint256 deadline,
139        uint8 v,
140        bytes32 r,
141        bytes32 s
142    ) external {
143        depositToken.permit(msg.sender, address(this), amount, deadline, v, r, s);
144        _deposit(msg.sender, amount);
145    }
146
147    function _deposit(address _account, uint256 _amount) internal {
148        UserInfo storage user = userInfo[_account];
149
150        uint256 _fee = _amount.mul(depositFeePercent).div(DEPOSIT_FEE_PERCENT_PRECISION);
151        uint256 _amountMinusFee = _amount.sub(_fee);
152
153        uint256 _previousAmount = user.amount;
154        uint256 _newAmount = user.amount.add(_amountMinusFee);
155        user.amount = _newAmount;
156
157        uint256 _len = rewardTokens.length;
158        for (uint256 i; i < _len; i++) {
159            IERC20 _token = rewardTokens[i];
160            updateReward(_token);
161
162            uint256 _previousRewardDebt = user.rewardDebt[_token];
163            user.rewardDebt[_token] = _newAmount.mul(accRewardPerShare[_token]).div(ACC_REWARD_PER_SHARE_PRECISION);
164
165            if (_previousAmount != 0) {
166                uint256 _pending = _previousAmount
167                    .mul(accRewardPerShare[_token])
168                    .div(ACC_REWARD_PER_SHARE_PRECISION)
169                    .sub(_previousRewardDebt);
170                if (_pending != 0) {

JavaScript Tests