ProtoFi

1// SPDX-License-Identifier: MIT
2pragma solidity >= 0.6.12;
3
4import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
5import "@openzeppelin/contracts/math/SafeMath.sol";
6import "@openzeppelin/contracts/access/Ownable.sol";
7import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
8
9
10/**
11This is the MoneyPot contract.
12It will be used to distribute shares rewards to ELCTs stakers.
13This is owned by the team, and the team will be able to set start and end blocks to distribute
14daily or weekly rewards to ELCTs stakers.
15Owner --> TBD, it should be activated daily, do we need a timelock?
16Modified from Pancake SmartChef contract (https://bscscan.com/address/0xABFd8d1942628124aB971937154f826Bce86DcbC#code)
17 */
18contract MoneyPot is Ownable, ReentrancyGuard {
19    using SafeMath for uint256;
20    using SafeERC20 for IERC20;
21
22    // Info of each user.
23    struct UserInfo {
24        uint256 amount;     // How many LP tokens the user has provided.
25        uint256 rewardDebt; // Reward debt. See explanation below.
26    }
27
28    // Info of each pool.
29    struct PoolInfo {
30        IERC20 stakeToken;           // Address of LP token contract.
31        uint256 allocPoint;       // How many allocation points assigned to this pool.
32        uint256 lastRewardBlock;  // Last block number that reward distribution occurs.
33        uint256 accRewardPerShare; // Accumulated reward per share, times 1e12. See below.
34    }
35
36    // Token to stake
37    IERC20 public stakingToken;
38    // Token used as reward
39    IERC20 public rewardToken;
40
41    // Reward token given per block
42    uint256 public rewardPerBlock;
43
44    // Info of each pool.
45    PoolInfo[] public poolInfo;
46    // Info of each user that stakes LP tokens.
47    mapping (address => UserInfo) public userInfo;
48    // Total allocation points. Must be the sum of all allocation points in all pools.
49    uint256 private totalAllocPoint = 0;
50    // The block number when reward mining starts.
51    uint256 public startBlock;
52    // The block number when reward mining ends.
53    uint256 public bonusEndBlock;
54
55    event Deposit(address indexed user, uint256 amount);
56    event Withdraw(address indexed user, uint256 amount);
57    event EmergencyWithdraw(address indexed user, uint256 amount);
58    event StopReward(uint256 blockNumber);
59
60    constructor(
61        IERC20 _stakingToken,
62        IERC20 _rewardToken,
63        uint256 _rewardPerBlock,
64        uint256 _startBlock,
65        uint256 _bonusEndBlock
66    ) public {
67        stakingToken = _stakingToken;
68        rewardToken = _rewardToken;
69        rewardPerBlock = _rewardPerBlock;
70        startBlock = _startBlock;
71        bonusEndBlock = _bonusEndBlock;
72
73        // staking pool
74        poolInfo.push(PoolInfo({
75            stakeToken: _stakingToken,
76            allocPoint: 1000, // Max allocation to this single pool
77            lastRewardBlock: startBlock,
78            accRewardPerShare: 0
79        }));
80        totalAllocPoint = 1000;
81    }
82
83    // Can be used for emergency to instantly stop rewards
84    function stopReward() public onlyOwner {
85        bonusEndBlock = block.number;
86        emit StopReward(block.number);
87    }
88
89    // Return reward multiplier over the given _from to _to block.
90    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
91        if (_to <= bonusEndBlock) {
92            return _to.sub(_from);
93        } else if (_from >= bonusEndBlock) {
94            return 0;
95        } else {
96            return bonusEndBlock.sub(_from);
97        }
98    }
99
100    // View function to see pending Reward on frontend.
101    function pendingReward(address _user) external view returns (uint256) {
102        PoolInfo storage pool = poolInfo[0];
103        UserInfo storage user = userInfo[_user];
104        uint256 accRewardPerShare = pool.accRewardPerShare;
105        uint256 stokenSupply = pool.stakeToken.balanceOf(address(this));
106        if (block.number > pool.lastRewardBlock && stokenSupply != 0) {
107            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
108            uint256 tokenReward = multiplier.mul(rewardPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
109            accRewardPerShare = accRewardPerShare.add(tokenReward.mul(1e12).div(stokenSupply));
110        }
111        return user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
112    }
113
114    // Update reward variables of the given pool to be up-to-date.
115    function updatePool(uint256 _pid) public {
116        PoolInfo storage pool = poolInfo[_pid];
117        if (block.number <= pool.lastRewardBlock) {
118            return;
119        }
120        uint256 stokenSupply = pool.stakeToken.balanceOf(address(this));
121        if (stokenSupply == 0) {
122            pool.lastRewardBlock = block.number;
123            return;
124        }
125        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
126        uint256 tokenReward = multiplier.mul(rewardPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
127        pool.accRewardPerShare = pool.accRewardPerShare.add(tokenReward.mul(1e12).div(stokenSupply));
128        pool.lastRewardBlock = block.number;
129    }
130
131    // Update reward variables for all pools. Be careful of gas spending!
132    function massUpdatePools() public {
133        uint256 length = poolInfo.length;
134        for (uint256 pid = 0; pid < length; ++pid) {
135            updatePool(pid);
136        }
137    }
138
139
140    // Stake staking tokens to moneypot
141    function deposit(uint256 _amount) public nonReentrant {
142        PoolInfo storage pool = poolInfo[0];
143        UserInfo storage user = userInfo[msg.sender];
144
145        updatePool(0);
146        if (user.amount > 0) {
147            uint256 pending = user.amount.mul(pool.accRewardPerShare).div(1e12).sub(user.rewardDebt);
148            if(pending > 0) {
149                rewardToken.safeTransfer(address(msg.sender), pending);
150            }
151        }
152        if(_amount > 0) {
153            pool.stakeToken.safeTransferFrom(address(msg.sender), address(this), _amount);
154            user.amount = user.amount.add(_amount);
155        }
156        user.rewardDebt = user.amount.mul(pool.accRewardPerShare).div(1e12);
157
158        emit Deposit(msg.sender, _amount);
159    }
160
161
162    /**
163    Sets the startBlock and bonusEndBlock for the moneypot, making it easy to update
164    the blocks distribute new rewards later in time. Resets also the lastRewardBlock.
165     */
166    function setBlocksBoundaries(uint256 _startBlock, uint256 _endBlock) public onlyOwner {
167        PoolInfo storage pool = poolInfo[0];
168
169        require(pool.lastRewardBlock <= _startBlock, "set: startBlock should be >= to the previous one");
170        require(bonusEndBlock <= _endBlock, "set: endBlock should be >= to the previous one");
171        require(_startBlock <= _endBlock, "set: _startBlock should be >= to endBlock");
172
173        updatePool(0);
174
175        pool.lastRewardBlock = _startBlock;
176        startBlock = _startBlock;
177        bonusEndBlock = _endBlock;
178    }
179
180    // Withdraw stake tokens from STAKING.
181    function withdraw(uint256 _amount) public nonReentrant {
182        PoolInfo storage pool = poolInfo[0];
183        UserInfo storage user = userInfo[msg.sender];
184        require(user.amount >= _amount, "withdraw: not good");
185        updatePool(0);
186        uint256 pending = user.amount.mul(pool.accRewardPerShare).div(1e12).sub(user.rewardDebt);
187        if(pending > 0) {
188            rewardToken.safeTransfer(address(msg.sender), pending);
189        }
190        if(_amount > 0) {
191            user.amount = user.amount.sub(_amount);
192            pool.stakeToken.safeTransfer(address(msg.sender), _amount);
193        }
194        user.rewardDebt = user.amount.mul(pool.accRewardPerShare).div(1e12);
195
196        emit Withdraw(msg.sender, _amount);
197    }
198
199    // Withdraw without caring about rewards. EMERGENCY ONLY.
200    function emergencyWithdraw() public nonReentrant {
201        PoolInfo storage pool = poolInfo[0];
202        UserInfo storage user = userInfo[msg.sender];
203        pool.stakeToken.safeTransfer(address(msg.sender), user.amount);
204        user.amount = 0;
205        user.rewardDebt = 0;
206        emit EmergencyWithdraw(msg.sender, user.amount);
207    }
208
209    // Withdraw reward. EMERGENCY ONLY.
210    function emergencyRewardWithdraw(uint256 _amount) public onlyOwner {
211        require(_amount < rewardToken.balanceOf(address(this)), 'not enough token');
212        rewardToken.safeTransfer(address(msg.sender), _amount);
213    }
214
215}

JavaScript Tests