Harvest Finance V2

1pragma solidity 0.5.16;
2​
3import "@openzeppelin/contracts-ethereum-package/contracts/math/Math.sol";
4import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
5import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol";
6import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol";
7import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol";
8import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol";
9import "./hardworkInterface/IStrategy.sol";
10import "./hardworkInterface/IStrategyV2.sol";
11import "./hardworkInterface/IVault.sol";
12import "./hardworkInterface/IController.sol";
13import "./hardworkInterface/IUpgradeSource.sol";
14import "./ControllableInit.sol";
15import "./VaultStorage.sol";
16​
17contract Vault is ERC20, ERC20Detailed, IVault, IUpgradeSource, ControllableInit, VaultStorage {
18  using SafeERC20 for IERC20;
19  using Address for address;
20  using SafeMath for uint256;
21​
22  event Withdraw(address indexed beneficiary, uint256 amount);
23  event Deposit(address indexed beneficiary, uint256 amount);
24  event Invest(uint256 amount);
25  event StrategyAnnounced(address newStrategy, uint256 time);
26  event StrategyChanged(address newStrategy, address oldStrategy);
27​
28  modifier whenStrategyDefined() {
29    require(address(strategy()) != address(0), "Strategy must be defined");
30    _;
31  }
32​
33  // Only smart contracts will be affected by this modifier
34  modifier defense() {
35    require(
36      (msg.sender == tx.origin) ||                // If it is a normal user and not smart contract,
37      // then the requirement will pass
38      !IController(controller()).greyList(msg.sender), // If it is a smart contract, then
39      "This smart contract has been grey listed"  // make sure that it is not on our greyList.
40    );
41    _;
42  }
43​
44  constructor() public {
45  }
46​
47  // the function is name differently to not cause inheritance clash in truffle and allows tests
48  function initializeVault(address _storage,
49    address _underlying,
50    uint256 _toInvestNumerator,
51    uint256 _toInvestDenominator
52  ) public initializer {
53    require(_toInvestNumerator <= _toInvestDenominator, "cannot invest more than 100%");
54    require(_toInvestDenominator != 0, "cannot divide by 0");
55​
56    ERC20Detailed.initialize(
57      string(abi.encodePacked("FARM_", ERC20Detailed(_underlying).symbol())),
58      string(abi.encodePacked("f", ERC20Detailed(_underlying).symbol())),
59      ERC20Detailed(_underlying).decimals()
60    );
61    ControllableInit.initialize(
62      _storage
63    );
64​
65    uint256 underlyingUnit = 10 ** uint256(ERC20Detailed(address(_underlying)).decimals());
66    uint256 implementationDelay = 12 hours;
67    uint256 strategyChangeDelay = 12 hours;
68    VaultStorage.initialize(
69      _underlying,
70      _toInvestNumerator,
71      _toInvestDenominator,
72      underlyingUnit,
73      implementationDelay,
74      strategyChangeDelay
75    );
76  }
77​
78  function strategy() public view returns(address) {
79    return _strategy();
80  }
81​
82  function underlying() public view returns(address) {
83    return _underlying();
84  }
85​
86  function underlyingUnit() public view returns(uint256) {
87    return _underlyingUnit();
88  }
89​
90  function vaultFractionToInvestNumerator() public view returns(uint256) {
91    return _vaultFractionToInvestNumerator();
92  }
93​
94  function vaultFractionToInvestDenominator() public view returns(uint256) {
95    return _vaultFractionToInvestDenominator();
96  }
97​
98  function nextImplementation() public view returns(address) {
99    return _nextImplementation();
100  }
101​
102  function nextImplementationTimestamp() public view returns(uint256) {
103    return _nextImplementationTimestamp();
104  }
105​
106  function nextImplementationDelay() public view returns(uint256) {
107    return _nextImplementationDelay();
108  }
109​
110  /**
111  * Chooses the best strategy and re-invests. If the strategy did not change, it just calls
112  * doHardWork on the current strategy. Call this through controller to claim hard rewards.
113  */
114  function doHardWork() external whenStrategyDefined onlyControllerOrGovernance {
115    uint256 sharePriceBeforeHardWork = getPricePerFullShare();
116    if (_withdrawBeforeReinvesting()) {
117      IStrategy(strategy()).withdrawAllToVault();
118    }
119​
120    // ensure that new funds are invested too
121    invest();
122    IStrategy(strategy()).doHardWork();
123    uint256 sharePriceAfterHardWork = getPricePerFullShare();
124​
125    if (!allowSharePriceDecrease()) {
126      require(sharePriceBeforeHardWork <= sharePriceAfterHardWork, "Share price should not decrease");
127    }
128  }
129​
130  /*
131  * Returns the cash balance across all users in this contract.
132  */
133  function underlyingBalanceInVault() view public returns (uint256) {
134    return IERC20(underlying()).balanceOf(address(this));
135  }
136​
137  /* Returns the current underlying (e.g., DAI's) balance together with
138   * the invested amount (if DAI is invested elsewhere by the strategy).
139  */
140  function underlyingBalanceWithInvestment() view public returns (uint256) {
141    if (address(strategy()) == address(0)) {
142      // initial state, when not set
143      return underlyingBalanceInVault();
144    }
145    return underlyingBalanceInVault().add(IStrategy(strategy()).investedUnderlyingBalance());
146  }
147​
148  function getPricePerFullShare() public view returns (uint256) {
149    return totalSupply() == 0
150        ? underlyingUnit()
151        : underlyingUnit().mul(underlyingBalanceWithInvestment()).div(totalSupply());
152  }
153​
154  function getEstimatedWithdrawalAmount(uint256 numberOfShares) public view returns (uint256 realTimeCalculatedValue) {
155    return numberOfShares.mul(getPricePerFullShare()).div(underlyingUnit());
156  }
157​
158  function underlyingBalanceWithInvestmentForHolder(address holder) view external returns (uint256) {
159    // for compatibility
160    uint256 estimatedWithdrawal = getEstimatedWithdrawalAmount(balanceOf(holder));
161    return estimatedWithdrawal;
162  }
163​
164  function futureStrategy() public view returns (address) {
165    return _futureStrategy();
166  }
167​
168  function strategyUpdateTime() public view returns (uint256) {
169    return _strategyUpdateTime();
170  }
171​
172  function strategyTimeLock() public view returns (uint256) {
173    return _strategyTimeLock();
174  }
175​
176  function canUpdateStrategy(address _strategy) public view returns(bool) {
177    return strategy() == address(0) // no strategy was set yet
178      || (_strategy == futureStrategy()
179          && block.timestamp > strategyUpdateTime()
180          && strategyUpdateTime() > 0); // or the timelock has passed
181  }
182​
183  /**
184  * Indicates that the strategy update will happen in the future
185  */
186  function announceStrategyUpdate(address _strategy) public onlyControllerOrGovernance {
187    // records a new timestamp
188    uint256 when = block.timestamp.add(strategyTimeLock());
189    _setStrategyUpdateTime(when);
190    _setFutureStrategy(_strategy);
191    emit StrategyAnnounced(_strategy, when);
192  }
193​
194  /**
195  * Finalizes (or cancels) the strategy update by resetting the data
196  */
197  function finalizeStrategyUpdate() public onlyControllerOrGovernance {
198    _setStrategyUpdateTime(0);
199    _setFutureStrategy(address(0));
200  }
201​
202  function setStrategy(address _strategy) public onlyControllerOrGovernance {
203    require(canUpdateStrategy(_strategy),
204      "The strategy exists and switch timelock did not elapse yet");
205    require(_strategy != address(0), "new _strategy cannot be empty");
206    require(IStrategy(_strategy).underlying() == address(underlying()), "Vault underlying must match Strategy underlying");
207    require(IStrategy(_strategy).vault() == address(this), "the strategy does not belong to this vault");
208​
209    emit StrategyChanged(_strategy, strategy());
210    if (address(_strategy) != address(strategy()) {
211      if (address(strategy()) != address(0)) { / if the original strategy (no underscore) is defined
212        IERC20(underlying()).safeApprove(address(strategy()), 0);
213        IStrategy(strategy()).withdrawAllToVault();
214      }
215      _setStrategy(_strategy);
216      IERC20(underlying()).safeApprove(address(strategy()), 0);
217      IERC20(underlying()).safeApprove(address(strategy()), uint256(~0));
218    }
219    finalizeStrategyUpdate();
220  }
221​
222  function setVaultFractionToInvest(uint256 numerator, uint256 denominator) external onlyGovernance {
223    require(denominator > 0, "denominator must be greater than 0");
224    require(numerator <= denominator, "denominator must be greater than or equal to the numerator");
225    _setVaultFractionToInvestNumerator(numerator);
226    _setVaultFractionToInvestDenominator(denominator);
227  }
228​
229  function setWithdrawBeforeReinvesting(bool value) external onlyGovernance {
230    _setWithdrawBeforeReinvesting(value);
231  }

Solidity Contracts

JavaScript Tests