Beefy.finance

1// SPDX-License-Identifier: MIT
2
3pragma solidity ^0.6.0;
4
5import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
6import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
7import "@openzeppelin/contracts/math/SafeMath.sol";
8import "@openzeppelin/contracts/access/Ownable.sol";
9import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
10
11import "../interfaces/beefy/IStrategy.sol";
12
13/**
14 * @dev Implementation of a vault to deposit funds for yield optimizing.
15 * This is the contract that receives funds and that users interface with.
16 * The yield optimizing strategy itself is implemented in a separate 'Strategy.sol' contract.
17 */
18contract BeefyVaultV6 is ERC20, Ownable, ReentrancyGuard {
19    using SafeERC20 for IERC20;
20    using SafeMath for uint256;
21
22    struct StratCandidate {
23        address implementation;
24        uint proposedTime;
25    }
26
27    // The last proposed strategy to switch to.
28    StratCandidate public stratCandidate;
29    // The strategy currently in use by the vault.
30    IStrategy public strategy;
31    // The minimum time it has to pass before a strat candidate can be approved.
32    uint256 public immutable approvalDelay;
33
34    event NewStratCandidate(address implementation);
35    event UpgradeStrat(address implementation);
36
37    /**
38     * @dev Sets the value of {token} to the token that the vault will
39     * hold as underlying value. It initializes the vault's own 'moo' token.
40     * This token is minted when someone does a deposit. It is burned in order
41     * to withdraw the corresponding portion of the underlying assets.
42     * @param _strategy the address of the strategy.
43     * @param _name the name of the vault token.
44     * @param _symbol the symbol of the vault token.
45     * @param _approvalDelay the delay before a new strat can be approved.
46     */
47    constructor (
48        IStrategy _strategy,
49        string memory _name,
50        string memory _symbol,
51        uint256 _approvalDelay
52    ) public ERC20(
53        _name,
54        _symbol
55    ) {
56        strategy = _strategy;
57        approvalDelay = _approvalDelay;
58    }
59
60    function want() public view returns (IERC20) {
61        return IERC20(strategy.want());
62    }
63
64    /**
65     * @dev It calculates the total underlying value of {token} held by the system.
66     * It takes into account the vault contract balance, the strategy contract balance
67     *  and the balance deployed in other contracts as part of the strategy.
68     */
69    function balance() public view returns (uint) {
70        return want().balanceOf(address(this)).add(IStrategy(strategy).balanceOf());
71    }
72
73    /**
74     * @dev Custom logic in here for how much the vault allows to be borrowed.
75     * We return 100% of tokens for now. Under certain conditions we might
76     * want to keep some of the system funds at hand in the vault, instead
77     * of putting them to work.
78     */
79    function available() public view returns (uint256) {
80        return want().balanceOf(address(this));
81    }
82
83    /**
84     * @dev Function for various UIs to display the current value of one of our yield tokens.
85     * Returns an uint256 with 18 decimals of how much underlying asset one vault share represents.
86     */
87    function getPricePerFullShare() public view returns (uint256) {
88        return totalSupply() == 0 ? 1e18 : balance().mul(1e18).div(totalSupply());
89    }
90
91    /**
92     * @dev A helper function to call deposit() with all the sender's funds.
93     */
94    function depositAll() external {
95        deposit(want().balanceOf(msg.sender));
96    }
97
98    /**
99     * @dev The entrypoint of funds into the system. People deposit with this function
100     * into the vault. The vault is then in charge of sending funds into the strategy.
101     */
102    function deposit(uint _amount) public nonReentrant {
103        strategy.beforeDeposit();
104
105        uint256 _pool = balance();
106        want().safeTransferFrom(msg.sender, address(this), _amount);
107        earn();
108        uint256 _after = balance();
109        _amount = _after.sub(_pool); // Additional check for deflationary tokens
110        uint256 shares = 0;
111        if (totalSupply() == 0) {
112            shares = _amount;
113        } else {
114            shares = (_amount.mul(totalSupply())).div(_pool);
115        }
116        _mint(msg.sender, shares);
117    }
118
119    /**
120     * @dev Function to send funds into the strategy and put them to work. It's primarily called
121     * by the vault's deposit() function.
122     */
123    function earn() public {
124        uint _bal = available();
125        want().safeTransfer(address(strategy), _bal);
126        strategy.deposit();
127    }
128
129    /**
130     * @dev A helper function to call withdraw() with all the sender's funds.
131     */
132    function withdrawAll() external {
133        withdraw(balanceOf(msg.sender));
134    }
135
136    /**
137     * @dev Function to exit the system. The vault will withdraw the required tokens
138     * from the strategy and pay up the token holder. A proportional number of IOU
139     * tokens are burned in the process.
140     */
141    function withdraw(uint256 _shares) public {
142        uint256 r = (balance().mul(_shares)).div(totalSupply());
143        _burn(msg.sender, _shares);
144
145        uint b = want().balanceOf(address(this));
146        if (b < r) {
147            uint _withdraw = r.sub(b);
148            strategy.withdraw(_withdraw);
149            uint _after = want().balanceOf(address(this));
150            uint _diff = _after.sub(b);
151            if (_diff < _withdraw) {
152                r = b.add(_diff);
153            }
154        }
155
156        want().safeTransfer(msg.sender, r);
157    }
158
159    /** 
160     * @dev Sets the candidate for the new strat to use with this vault.
161     * @param _implementation The address of the candidate strategy.  
162     */
163    function proposeStrat(address _implementation) public onlyOwner {
164        require(address(this) == IStrategy(_implementation).vault(), "Proposal not valid for this Vault");
165        stratCandidate = StratCandidate({
166            implementation: _implementation,
167            proposedTime: block.timestamp
168         });
169
170        emit NewStratCandidate(_implementation);
171    }
172
173    /** 
174     * @dev It switches the active strat for the strat candidate. After upgrading, the 
175     * candidate implementation is set to the 0x00 address, and proposedTime to a time 
176     * happening in +100 years for safety. 
177     */
178
179    function upgradeStrat() public onlyOwner {
180        require(stratCandidate.implementation != address(0), "There is no candidate");
181        require(stratCandidate.proposedTime.add(approvalDelay) < block.timestamp, "Delay has not passed");
182
183        emit UpgradeStrat(stratCandidate.implementation);
184
185        strategy.retireStrat();
186        strategy = IStrategy(stratCandidate.implementation);
187        stratCandidate.implementation = address(0);
188        stratCandidate.proposedTime = 5000000000;
189
190        earn();
191    }
192
193    /**
194     * @dev Rescues random funds stuck that the strat can't handle.
195     * @param _token address of the token to rescue.
196     */
197    function inCaseTokensGetStuck(address _token) external onlyOwner {
198        require(_token != address(want()), "!token");
199
200        uint256 amount = IERC20(_token).balanceOf(address(this));
201        IERC20(_token).safeTransfer(msg.sender, amount);
202    }
203}

JavaScript Tests