Aura Finance

1pragma solidity 0.8.11;
2
3import { IERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol";
4import { SafeERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol";
5import { Ownable } from "@openzeppelin/contracts-0.8/access/Ownable.sol";
6import { ReentrancyGuard } from "@openzeppelin/contracts-0.8/security/ReentrancyGuard.sol";
7import { AuraMath, AuraMath32, AuraMath112, AuraMath224 } from "../utils/AuraMath.sol";
8import { IAuraLocker } from "../interfaces/IAuraLocker.sol";
9import { IRewardStaking } from "../interfaces/IRewardStaking.sol";
10
11/**
12 * @title   AuraLocker
13 * @author  ConvexFinance
14 * @notice  Effectively allows for rolling 16 week lockups of CVX, and provides balances available
15 *          at each epoch (1 week). Also receives cvxCrv from `CvxStakingProxy` and redistributes
16 *          to depositors.
17 * @dev     Individual and delegatee vote power lookups both use independent accounting mechanisms.
18 */
19contract AuraLocker is ReentrancyGuard, Ownable, IAuraLocker {
20    using AuraMath for uint256;
21    using AuraMath224 for uint224;
22    using AuraMath112 for uint112;
23    using AuraMath32 for uint32;
24    using SafeERC20 for IERC20;
25
26    /* ==========     STRUCTS     ========== */
27
28    struct RewardData {
29        /// Timestamp for current period finish
30        uint32 periodFinish;
31        /// Last time any user took action
32        uint32 lastUpdateTime;
33        /// RewardRate for the rest of the period
34        uint96 rewardRate;
35        /// Ever increasing rewardPerToken rate, based on % of total supply
36        uint96 rewardPerTokenStored;
37    }
38    struct UserData {
39        uint128 rewardPerTokenPaid;
40        uint128 rewards;
41    }
42    struct EarnedData {
43        address token;
44        uint256 amount;
45    }
46    struct Balances {
47        uint112 locked;
48        uint32 nextUnlockIndex;
49    }
50    struct LockedBalance {
51        uint112 amount;
52        uint32 unlockTime;
53    }
54    struct Epoch {
55        uint224 supply;
56        uint32 date; //epoch start date
57    }
58    struct DelegateeCheckpoint {
59        uint224 votes;
60        uint32 epochStart;
61    }
62
63    /* ========== STATE VARIABLES ========== */
64
65    // Rewards
66    address[] public rewardTokens;
67    mapping(address => uint256) public queuedRewards;
68    uint256 public constant newRewardRatio = 830;
69    //     Core reward data
70    mapping(address => RewardData) public rewardData;
71    //     Reward token -> distributor -> is approved to add rewards
72    mapping(address => mapping(address => bool)) public rewardDistributors;
73    //     User -> reward token -> amount
74    mapping(address => mapping(address => UserData)) public userData;
75    //     Duration that rewards are streamed over
76    uint256 public constant rewardsDuration = 86400 * 7;
77    //     Duration of lock/earned penalty period
78    uint256 public constant lockDuration = rewardsDuration * 17;
79
80    // Balances
81    //     Supplies and historic supply
82    uint256 public lockedSupply;
83    //     Epochs contains only the tokens that were locked at that epoch, not a cumulative supply
84    Epoch[] public epochs;
85    //     Mappings for balance data
86    mapping(address => Balances) public balances;
87    mapping(address => LockedBalance[]) public userLocks;
88
89    // Voting
90    //     Stored delegations
91    mapping(address => address) private _delegates;
92    //     Checkpointed votes
93    mapping(address => DelegateeCheckpoint[]) private _checkpointedVotes;
94    //     Delegatee balances (user -> unlock timestamp -> amount)
95    mapping(address => mapping(uint256 => uint256)) public delegateeUnlocks;
96
97    // Config
98    //     Blacklisted smart contract interactions
99    mapping(address => bool) public blacklist;
100    //     Tokens
101    IERC20 public immutable stakingToken;
102    address public immutable cvxCrv;
103    //     Denom for calcs
104    uint256 public constant denominator = 10000;
105    //     Staking cvxCrv
106    address public immutable cvxcrvStaking;
107    //     Incentives
108    uint256 public kickRewardPerEpoch = 100;
109    uint256 public kickRewardEpochDelay = 3;
110    //     Shutdown
111    bool public isShutdown = false;
112
113    // Basic token data
114    string private _name;
115    string private _symbol;
116    uint8 private immutable _decimals;
117
118    /* ========== EVENTS ========== */
119
120    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
121    event DelegateCheckpointed(address indexed delegate);
122
123    event Recovered(address _token, uint256 _amount);
124    event RewardPaid(address indexed _user, address indexed _rewardsToken, uint256 _reward);
125    event Staked(address indexed _user, uint256 _paidAmount, uint256 _lockedAmount);
126    event Withdrawn(address indexed _user, uint256 _amount, bool _relocked);
127    event KickReward(address indexed _user, address indexed _kicked, uint256 _reward);
128    event RewardAdded(address indexed _token, uint256 _reward);
129
130    event BlacklistModified(address account, bool blacklisted);
131    event KickIncentiveSet(uint256 rate, uint256 delay);
132    event Shutdown();
133
134    /***************************************
135                    CONSTRUCTOR
136    ****************************************/
137
138    /**
139     * @param _nameArg          Token name, simples
140     * @param _symbolArg        Token symbol
141     * @param _stakingToken     CVX (0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B)
142     * @param _cvxCrv           cvxCRV (0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7)
143     * @param _cvxCrvStaking    cvxCRV rewards (0x3Fe65692bfCD0e6CF84cB1E7d24108E434A7587e)
144     */
145    constructor(
146        string memory _nameArg,
147        string memory _symbolArg,
148        address _stakingToken,
149        address _cvxCrv,
150        address _cvxCrvStaking
151    ) Ownable() {
152        _name = _nameArg;
153        _symbol = _symbolArg;
154        _decimals = 18;
155
156        stakingToken = IERC20(_stakingToken);
157        cvxCrv = _cvxCrv;
158        cvxcrvStaking = _cvxCrvStaking;
159
160        uint256 currentEpoch = block.timestamp.div(rewardsDuration).mul(rewardsDuration);
161        epochs.push(Epoch({ supply: 0, date: uint32(currentEpoch) }));
162    }
163
164    /***************************************
165                    MODIFIER
166    ****************************************/
167
168    modifier updateReward(address _account) {
169        {
170            Balances storage userBalance = balances[_account];
171            uint256 rewardTokensLength = rewardTokens.length;
172            for (uint256 i = 0; i < rewardTokensLength; i++) {
173                address token = rewardTokens[i];
174                uint256 newRewardPerToken = _rewardPerToken(token);
175                rewardData[token].rewardPerTokenStored = newRewardPerToken.to96();
176                rewardData[token].lastUpdateTime = _lastTimeRewardApplicable(rewardData[token].periodFinish).to32();
177                if (_account != address(0)) {
178                    userData[_account][token] = UserData({
179                        rewardPerTokenPaid: newRewardPerToken.to128(),
180                        rewards: _earned(_account, token, userBalance.locked).to128()
181                    });
182                }
183            }
184        }
185        _;

JavaScript Tests