PancakeSwap V2

1// SPDX-License-Identifier: MIT
2pragma solidity 0.6.12;
3
4import "@openzeppelin/contracts/access/Ownable.sol";
5import "@openzeppelin/contracts/math/SafeMath.sol";
6import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
7import "@openzeppelin/contracts/utils/Pausable.sol";
8import "./interfaces/IMasterChef.sol";
9
10contract CakeVault is Ownable, Pausable {
11    using SafeERC20 for IERC20;
12    using SafeMath for uint256;
13
14    struct UserInfo {
15        uint256 shares; // number of shares for a user
16        uint256 lastDepositedTime; // keeps track of deposited time for potential penalty
17        uint256 cakeAtLastUserAction; // keeps track of cake deposited at the last user action
18        uint256 lastUserActionTime; // keeps track of the last user action time
19    }
20
21    IERC20 public immutable token; // Cake token
22    IERC20 public immutable receiptToken; // Syrup token
23
24    IMasterChef public immutable masterchef;
25
26    mapping(address => UserInfo) public userInfo;
27
28    uint256 public totalShares;
29    uint256 public lastHarvestedTime;
30    address public admin;
31    address public treasury;
32
33    uint256 public constant MAX_PERFORMANCE_FEE = 500; // 5%
34    uint256 public constant MAX_CALL_FEE = 100; // 1%
35    uint256 public constant MAX_WITHDRAW_FEE = 100; // 1%
36    uint256 public constant MAX_WITHDRAW_FEE_PERIOD = 72 hours; // 3 days
37
38    uint256 public performanceFee = 200; // 2%
39    uint256 public callFee = 25; // 0.25%
40    uint256 public withdrawFee = 10; // 0.1%
41    uint256 public withdrawFeePeriod = 72 hours; // 3 days
42
43    event Deposit(address indexed sender, uint256 amount, uint256 shares, uint256 lastDepositedTime);
44    event Withdraw(address indexed sender, uint256 amount, uint256 shares);
45    event Harvest(address indexed sender, uint256 performanceFee, uint256 callFee);
46    event Pause();
47    event Unpause();
48
49    /**
50     * @notice Constructor
51     * @param _token: Cake token contract
52     * @param _receiptToken: Syrup token contract
53     * @param _masterchef: MasterChef contract
54     * @param _admin: address of the admin
55     * @param _treasury: address of the treasury (collects fees)
56     */
57    constructor(
58        IERC20 _token,
59        IERC20 _receiptToken,
60        IMasterChef _masterchef,
61        address _admin,
62        address _treasury
63    ) public {
64        token = _token;
65        receiptToken = _receiptToken;
66        masterchef = _masterchef;
67        admin = _admin;
68        treasury = _treasury;
69
70        // Infinite approve
71        IERC20(_token).safeApprove(address(_masterchef), uint256(-1));
72    }
73
74    /**
75     * @notice Checks if the msg.sender is the admin address
76     */
77    modifier onlyAdmin() {
78        require(msg.sender == admin, "admin: wut?");
79        _;
80    }
81
82    /**
83     * @notice Checks if the msg.sender is a contract or a proxy
84     */
85    modifier notContract() {
86        require(!_isContract(msg.sender), "contract not allowed");
87        require(msg.sender == tx.origin, "proxy contract not allowed");
88        _;
89    }
90
91    /**
92     * @notice Deposits funds into the Cake Vault
93     * @dev Only possible when contract not paused.
94     * @param _amount: number of tokens to deposit (in CAKE)
95     */
96    function deposit(uint256 _amount) external whenNotPaused notContract {
97        require(_amount > 0, "Nothing to deposit");
98
99        uint256 pool = balanceOf();
100        token.safeTransferFrom(msg.sender, address(this), _amount);
101        uint256 currentShares = 0;
102        if (totalShares != 0) {
103            currentShares = (_amount.mul(totalShares)).div(pool);
104        } else {
105            currentShares = _amount;
106        }
107        UserInfo storage user = userInfo[msg.sender];
108
109        user.shares = user.shares.add(currentShares);
110        user.lastDepositedTime = block.timestamp;
111
112        totalShares = totalShares.add(currentShares);
113
114        user.cakeAtLastUserAction = user.shares.mul(balanceOf()).div(totalShares);
115        user.lastUserActionTime = block.timestamp;
116
117        _earn();
118
119        emit Deposit(msg.sender, _amount, currentShares, block.timestamp);
120    }
121
122    /**
123     * @notice Withdraws all funds for a user
124     */
125    function withdrawAll() external notContract {
126        withdraw(userInfo[msg.sender].shares);
127    }
128
129    /**
130     * @notice Reinvests CAKE tokens into MasterChef
131     * @dev Only possible when contract not paused.
132     */
133    function harvest() external notContract whenNotPaused {
134        IMasterChef(masterchef).leaveStaking(0);
135
136        uint256 bal = available();
137        uint256 currentPerformanceFee = bal.mul(performanceFee).div(10000);
138        token.safeTransfer(treasury, currentPerformanceFee);
139
140        uint256 currentCallFee = bal.mul(callFee).div(10000);
141        token.safeTransfer(msg.sender, currentCallFee);
142
143        _earn();
144
145        lastHarvestedTime = block.timestamp;
146
147        emit Harvest(msg.sender, currentPerformanceFee, currentCallFee);
148    }
149
150    /**
151     * @notice Sets admin address
152     * @dev Only callable by the contract owner.
153     */
154    function setAdmin(address _admin) external onlyOwner {
155        require(_admin != address(0), "Cannot be zero address");
156        admin = _admin;
157    }
158
159    /**
160     * @notice Sets treasury address
161     * @dev Only callable by the contract owner.
162     */
163    function setTreasury(address _treasury) external onlyOwner {
164        require(_treasury != address(0), "Cannot be zero address");
165        treasury = _treasury;
166    }
167
168    /**
169     * @notice Sets performance fee
170     * @dev Only callable by the contract admin.
171     */
172    function setPerformanceFee(uint256 _performanceFee) external onlyAdmin {
173        require(_performanceFee <= MAX_PERFORMANCE_FEE, "performanceFee cannot be more than MAX_PERFORMANCE_FEE");
174        performanceFee = _performanceFee;
175    }
176
177    /**
178     * @notice Sets call fee
179     * @dev Only callable by the contract admin.
180     */
181    function setCallFee(uint256 _callFee) external onlyAdmin {
182        require(_callFee <= MAX_CALL_FEE, "callFee cannot be more than MAX_CALL_FEE");
183        callFee = _callFee;
184    }
185
186    /**
187     * @notice Sets withdraw fee
188     * @dev Only callable by the contract admin.
189     */
190    function setWithdrawFee(uint256 _withdrawFee) external onlyAdmin {
191        require(_withdrawFee <= MAX_WITHDRAW_FEE, "withdrawFee cannot be more than MAX_WITHDRAW_FEE");
192        withdrawFee = _withdrawFee;
193    }
194
195    /**
196     * @notice Sets withdraw fee period
197     * @dev Only callable by the contract admin.
198     */
199    function setWithdrawFeePeriod(uint256 _withdrawFeePeriod) external onlyAdmin {
200        require(
201            _withdrawFeePeriod <= MAX_WITHDRAW_FEE_PERIOD,
202            "withdrawFeePeriod cannot be more than MAX_WITHDRAW_FEE_PERIOD"
203        );
204        withdrawFeePeriod = _withdrawFeePeriod;
205    }
206
207    /**
208     * @notice Withdraws from MasterChef to Vault without caring about rewards.
209     * @dev EMERGENCY ONLY. Only callable by the contract admin.
210     */
211    function emergencyWithdraw() external onlyAdmin {
212        IMasterChef(masterchef).emergencyWithdraw(0);
213    }
214
215    /**
216     * @notice Withdraw unexpected tokens sent to the Cake Vault
217     */
218    function inCaseTokensGetStuck(address _token) external onlyAdmin {
219        require(_token != address(token), "Token cannot be same as deposit token");
220        require(_token != address(receiptToken), "Token cannot be same as receipt token");
221
222        uint256 amount = IERC20(_token).balanceOf(address(this));
223        IERC20(_token).safeTransfer(msg.sender, amount);
224    }
225
226    /**
227     * @notice Triggers stopped state
228     * @dev Only possible when contract not paused.
229     */
230    function pause() external onlyAdmin whenNotPaused {
231        _pause();
232        emit Pause();
233    }
234

JavaScript Tests