Hats Finance

1// SPDX-License-Identifier: MIT
2// Disclaimer https://github.com/hats-finance/hats-contracts/blob/main/DISCLAIMER.md
3
4pragma solidity 0.8.6;
5
6
7import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
8import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
9import "openzeppelin-solidity/contracts/utils/math/SafeMath.sol";
10import "./HATToken.sol";
11import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
12
13// Errors:
14// HME01: Pool range is too big
15// HME02: Invalid pool range
16// HME03: Committee not checked in yet
17// HME04: Withdraw: not enough user balance
18// HME05: User amount must be greater than 0
19// HME06: lpToken is already in pool
20contract HATMaster is ReentrancyGuard {
21    using SafeMath for uint256;
22    using SafeERC20 for IERC20;
23
24    struct UserInfo {
25        uint256 amount;     // The user share of the pool based on the amount of lpToken the user has provided.
26        uint256 rewardDebt; // Reward debt. See explanation below.
27      //
28      // We do some fancy math here. Basically, any point in time, the amount of HATs
29      // entitled to a user but is pending to be distributed is:
30      //
31      //   pending reward = (user.amount * pool.rewardPerShare) - user.rewardDebt
32      //
33      // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
34      //   1. The pool's `rewardPerShare` (and `lastRewardBlock`) gets updated.
35      //   2. User receives the pending reward sent to his/her address.
36      //   3. User's `amount` gets updated.
37      //   4. User's `rewardDebt` gets updated.
38    }
39
40    struct PoolUpdate {
41        uint256 blockNumber;// update blocknumber
42        uint256 totalAllocPoint; //totalAllocPoint
43    }
44
45    struct RewardsSplit {
46        //the percentage of the total reward to reward the hacker via vesting contract(claim reported)
47        uint256 hackerVestedReward;
48        //the percentage of the total reward to reward the hacker(claim reported)
49        uint256 hackerReward;
50        // the percentage of the total reward to be sent to the committee
51        uint256 committeeReward;
52        // the percentage of the total reward to be swap to HAT and to be burned
53        uint256 swapAndBurn;
54        // the percentage of the total reward to be swap to HAT and sent to governance
55        uint256 governanceHatReward;
56        // the percentage of the total reward to be swap to HAT and sent to the hacker
57        uint256 hackerHatReward;
58    }
59
60    // Info of each pool.
61    struct PoolInfo {
62        IERC20 lpToken;
63        uint256 allocPoint;
64        uint256 lastRewardBlock;
65        uint256 rewardPerShare;
66        uint256 totalUsersAmount;
67        uint256 lastProcessedTotalAllocPoint;
68        uint256 balance;
69    }
70
71    // Info of each pool.
72    struct PoolReward {
73        RewardsSplit rewardsSplit;
74        uint256[]  rewardsLevels;
75        bool committeeCheckIn;
76        uint256 vestingDuration;
77        uint256 vestingPeriods;
78    }
79
80    HATToken public immutable HAT;
81    uint256 public immutable REWARD_PER_BLOCK;
82    uint256 public immutable START_BLOCK;
83    uint256 public immutable MULTIPLIER_PERIOD;
84    uint256 public constant MULTIPLIERS_LENGTH = 24;
85
86    // Info of each pool.
87    PoolInfo[] public poolInfo;
88    PoolUpdate[] public globalPoolUpdates;
89
90    // Reward Multipliers
91    uint256[24] public rewardMultipliers = [4413, 4413, 8825, 7788, 6873, 6065,
92                                            5353, 4724, 4169, 3679, 3247, 2865,
93                                            2528, 2231, 1969, 1738, 1534, 1353,
94                                            1194, 1054, 930, 821, 724, 639];
95    mapping(address => uint256) public poolId1; // poolId1 count from 1, subtraction 1 before using with poolInfo
96    // Info of each user that stakes LP tokens. pid => user address => info
97    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
98    //pid -> PoolReward
99    mapping (uint256=>PoolReward) internal poolsRewards;
100
101    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
102    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
103    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
104    event SendReward(address indexed user, uint256 indexed pid, uint256 amount, uint256 requestedAmount);
105    event MassUpdatePools(uint256 _fromPid, uint256 _toPid);
106
107    constructor(
108        HATToken _hat,
109        uint256 _rewardPerBlock,
110        uint256 _startBlock,
111        uint256 _multiplierPeriod
112    // solhint-disable-next-line func-visibility
113    ) {
114        HAT = _hat;
115        REWARD_PER_BLOCK = _rewardPerBlock;
116        START_BLOCK = _startBlock;
117        MULTIPLIER_PERIOD = _multiplierPeriod;
118    }
119
120  /**
121   * @dev massUpdatePools - Update reward variables for all pools
122   * Be careful of gas spending!
123   * @param _fromPid update pools range from this pool id
124   * @param _toPid update pools range to this pool id
125   */
126    function massUpdatePools(uint256 _fromPid, uint256 _toPid) external {
127        require(_toPid <= poolInfo.length, "HME01");
128        require(_fromPid <= _toPid, "HME02");
129        for (uint256 pid = _fromPid; pid < _toPid; ++pid) {
130            updatePool(pid);
131        }
132        emit MassUpdatePools(_fromPid, _toPid);
133    }
134
135    function claimReward(uint256 _pid) external {
136        _deposit(_pid, 0);
137    }
138
139    function updatePool(uint256 _pid) public {
140        PoolInfo storage pool = poolInfo[_pid];
141        uint256 lastRewardBlock = pool.lastRewardBlock;
142        if (block.number <= lastRewardBlock) {
143            return;
144        }
145        uint256 totalUsersAmount = pool.totalUsersAmount;
146        uint256 lastPoolUpdate = globalPoolUpdates.length-1;
147        if (totalUsersAmount == 0) {
148            pool.lastRewardBlock = block.number;
149            pool.lastProcessedTotalAllocPoint = lastPoolUpdate;
150            return;
151        }
152        uint256 reward = calcPoolReward(_pid, lastRewardBlock, lastPoolUpdate);
153        uint256 amountCanMint = HAT.minters(address(this));
154        reward = amountCanMint < reward ? amountCanMint : reward;
155        if (reward > 0) {
156            HAT.mint(address(this), reward);
157        }
158        pool.rewardPerShare = pool.rewardPerShare.add(reward.mul(1e12).div(totalUsersAmount));
159        pool.lastRewardBlock = block.number;
160        pool.lastProcessedTotalAllocPoint = lastPoolUpdate;
161    }
162
163    /**
164     * @dev getMultiplier - multiply blocks with relevant multiplier for specific range
165     * @param _from range's from block
166     * @param _to range's to block
167     * will revert if from < START_BLOCK or _to < _from
168     */
169    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256 result) {
170        uint256 i = (_from - START_BLOCK) / MULTIPLIER_PERIOD + 1;
171        for (; i <= MULTIPLIERS_LENGTH; i++) {
172            uint256 endBlock = MULTIPLIER_PERIOD * i + START_BLOCK;
173            if (_to <= endBlock) {
174                break;
175            }
176            result += (endBlock - _from) * rewardMultipliers[i-1];
177            _from = endBlock;
178        }
179        result += (_to - _from) * (i > MULTIPLIERS_LENGTH ? 0 : rewardMultipliers[i-1]);
180    }
181
182    function getRewardForBlocksRange(uint256 _from, uint256 _to, uint256 _allocPoint, uint256 _totalAllocPoint)
183    public
184    view
185    returns (uint256 reward) {
186        if (_totalAllocPoint > 0) {
187            reward = getMultiplier(_from, _to).mul(REWARD_PER_BLOCK).mul(_allocPoint).div(_totalAllocPoint).div(100);
188        }
189    }
190
191    /**
192     * @dev calcPoolReward -
193     * calculate rewards for a pool by iterating over the history of totalAllocPoints updates.
194     * and sum up all rewards periods from pool.lastRewardBlock till current block number.
195     * @param _pid pool id
196     * @param _from block starting calculation
197     * @param _lastPoolUpdate lastPoolUpdate
198     * @return reward
199     */
200    function calcPoolReward(uint256 _pid, uint256 _from, uint256 _lastPoolUpdate) public view returns(uint256 reward) {
201        uint256 poolAllocPoint = poolInfo[_pid].allocPoint;
202        uint256 i = poolInfo[_pid].lastProcessedTotalAllocPoint;
203        for (; i < _lastPoolUpdate; i++) {
204            uint256 nextUpdateBlock = globalPoolUpdates[i+1].blockNumber;
205            reward =
206            reward.add(getRewardForBlocksRange(_from,
207                                            nextUpdateBlock,
208                                            poolAllocPoint,
209                                            globalPoolUpdates[i].totalAllocPoint));
210            _from = nextUpdateBlock;
211        }
212        return reward.add(getRewardForBlocksRange(_from,
213                                                block.number,
214                                                poolAllocPoint,
215                                                globalPoolUpdates[i].totalAllocPoint));
216    }