@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/contracts/base/Vault.sol

@@ -0,0 +1,344 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+
+import "./interface/IStrategy.sol";
+import "./interface/IVault.sol";
+import "./interface/IController.sol";
+import "./interface/IUpgradeSource.sol";
+import "./inheritance/ControllableInit.sol";
+import "./VaultStorage.sol";
+
+contract Vault is ERC20Upgradeable, IVault, IUpgradeSource, ControllableInit, VaultStorage {
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+  using AddressUpgradeable for address;
+  using SafeMathUpgradeable for uint256;
+
+  event Withdraw(address indexed beneficiary, uint256 amount);
+  event Deposit(address indexed beneficiary, uint256 amount);
+  event Invest(uint256 amount);
+  event StrategyAnnounced(address newStrategy, uint256 time);
+  event StrategyChanged(address newStrategy, address oldStrategy);
+
+
+  constructor() public {
+  }
+
+  // the function is name differently to not cause inheritance clash in truffle and allows tests
+  function initializeVault(
+    address _storage,
+    address _underlying,
+    uint256 _toInvestNumerator,
+    uint256 _toInvestDenominator
+  ) public override initializer {
+    require(_toInvestNumerator <= _toInvestDenominator, "cannot invest more than 100%");
+    require(_toInvestDenominator != 0, "cannot divide by 0");
+
+    __ERC20_init(
+      string(abi.encodePacked("miFARM_", ERC20Upgradeable(_underlying).symbol())),
+      string(abi.encodePacked("bf", ERC20Upgradeable(_underlying).symbol()))
+    );
+    _setupDecimals(ERC20Upgradeable(_underlying).decimals());
+
+    ControllableInit.initialize(
+      _storage
+    );
+
+    uint256 underlyingUnit = 10 ** uint256(ERC20Upgradeable(address(_underlying)).decimals());
+    uint256 implementationDelay = 12 hours;
+    uint256 strategyChangeDelay = 12 hours;
+    VaultStorage.initialize(
+      _underlying,
+      _toInvestNumerator,
+      _toInvestDenominator,
+      underlyingUnit,
+      implementationDelay,
+      strategyChangeDelay
+    );
+  }
+
+  function strategy() public view override returns(address) {
+    return _strategy();
+  }
+
+  function underlying() public view override returns(address) {
+    return _underlying();
+  }
+
+  function underlyingUnit() public view returns(uint256) {
+    return _underlyingUnit();
+  }
+
+  function vaultFractionToInvestNumerator() public view returns(uint256) {
+    return _vaultFractionToInvestNumerator();
+  }
+
+  function vaultFractionToInvestDenominator() public view returns(uint256) {
+    return _vaultFractionToInvestDenominator();
+  }
+
+  function nextImplementation() public view returns(address) {
+    return _nextImplementation();
+  }
+
+  function nextImplementationTimestamp() public view returns(uint256) {
+    return _nextImplementationTimestamp();
+  }
+
+  function nextImplementationDelay() public view returns(uint256) {
+    return _nextImplementationDelay();
+  }
+
+  modifier whenStrategyDefined() {
+    require(address(strategy()) != address(0), "Strategy must be defined");
+    _;
+  }
+
+  // Only smart contracts will be affected by this modifier
+  modifier defense() {
+    require(
+      (msg.sender == tx.origin) ||                // If it is a normal user and not smart contract,
+                                                  // then the requirement will pass
+      !IController(controller()).greyList(msg.sender), // If it is a smart contract, then
+      "This smart contract has been grey listed"  // make sure that it is not on our greyList.
+    );
+    _;
+  }
+
+  /**
+  * Chooses the best strategy and re-invests. If the strategy did not change, it just calls
+  * doHardWork on the current strategy. Call this through controller to claim hard rewards.
+  */
+  function doHardWork() whenStrategyDefined onlyControllerOrGovernance external override {
+    // ensure that new funds are invested too
+    invest();
+    IStrategy(strategy()).doHardWork();
+  }
+
+  /*
+  * Returns the cash balance across all users in this contract.
+  */
+  function underlyingBalanceInVault() view public override returns (uint256) {
+    return IERC20Upgradeable(underlying()).balanceOf(address(this));
+  }
+
+  /* Returns the current underlying (e.g., DAI's) balance together with
+   * the invested amount (if DAI is invested elsewhere by the strategy).
+  */
+  function underlyingBalanceWithInvestment() view public override returns (uint256) {
+    if (address(strategy()) == address(0)) {
+      // initial state, when not set
+      return underlyingBalanceInVault();
+    }
+    return underlyingBalanceInVault().add(IStrategy(strategy()).investedUnderlyingBalance());
+  }
+
+  function getPricePerFullShare() public view override returns (uint256) {
+    return totalSupply() == 0
+        ? underlyingUnit()
+        : underlyingUnit().mul(underlyingBalanceWithInvestment()).div(totalSupply());
+  }
+
+  /* get the user's share (in underlying)
+  */
+  function underlyingBalanceWithInvestmentForHolder(address holder) view external override returns (uint256) {
+    if (totalSupply() == 0) {
+      return 0;
+    }
+    return underlyingBalanceWithInvestment()
+        .mul(balanceOf(holder))
+        .div(totalSupply());
+  }
+
+  function futureStrategy() public view returns (address) {
+    return _futureStrategy();
+  }
+
+  function strategyUpdateTime() public view returns (uint256) {
+    return _strategyUpdateTime();
+  }
+
+  function strategyTimeLock() public view returns (uint256) {
+    return _strategyTimeLock();
+  }
+
+  function canUpdateStrategy(address _strategy) public view returns(bool) {
+    return strategy() == address(0) // no strategy was set yet
+      || (_strategy == futureStrategy()
+          && block.timestamp > strategyUpdateTime()
+          && strategyUpdateTime() > 0); // or the timelock has passed
+  }
+
+  /**
+  * Indicates that the strategy update will happen in the future
+  */
+  function announceStrategyUpdate(address _strategy) public override onlyControllerOrGovernance {
+    // records a new timestamp
+    uint256 when = block.timestamp.add(strategyTimeLock());
+    _setStrategyUpdateTime(when);
+    _setFutureStrategy(_strategy);
+    emit StrategyAnnounced(_strategy, when);
+  }
+
+  /**
+  * Finalizes (or cancels) the strategy update by resetting the data
+  */
+  function finalizeStrategyUpdate() public onlyControllerOrGovernance {
+    _setStrategyUpdateTime(0);
+    _setFutureStrategy(address(0));
+  }
+
+  function setStrategy(address _strategy) public override onlyControllerOrGovernance {
+    require(canUpdateStrategy(_strategy),
+      "The strategy exists and switch timelock did not elapse yet");
+    require(_strategy != address(0), "new _strategy cannot be empty");
+    require(IStrategy(_strategy).underlying() == address(underlying()), "Vault underlying must match Strategy underlying");
+    require(IStrategy(_strategy).vault() == address(this), "the strategy does not belong to this vault");
+
+    emit StrategyChanged(_strategy, strategy());
+    if (address(_strategy) != address(strategy())) {
+      if (address(strategy()) != address(0)) { // if the original strategy (no underscore) is defined
+        IERC20Upgradeable(underlying()).safeApprove(address(strategy()), 0);
+        IStrategy(strategy()).withdrawAllToVault();
+      }
+      _setStrategy(_strategy);
+      IERC20Upgradeable(underlying()).safeApprove(address(strategy()), 0);
+      IERC20Upgradeable(underlying()).safeApprove(address(strategy()), uint256(~0));
+    }
+    finalizeStrategyUpdate();
+  }
+
+  function setVaultFractionToInvest(uint256 numerator, uint256 denominator) external override onlyGovernance {
+    require(denominator > 0, "denominator must be greater than 0");
+    require(numerator <= denominator, "denominator must be greater than or equal to the numerator");
+    _setVaultFractionToInvestNumerator(numerator);
+    _setVaultFractionToInvestDenominator(denominator);
+  }
+
+  function rebalance() external onlyControllerOrGovernance {
+    withdrawAll();
+    invest();
+  }
+
+  function availableToInvestOut() public view returns (uint256) {
+    uint256 wantInvestInTotal = underlyingBalanceWithInvestment()
+        .mul(vaultFractionToInvestNumerator())
+        .div(vaultFractionToInvestDenominator());
+    uint256 alreadyInvested = IStrategy(strategy()).investedUnderlyingBalance();
+    if (alreadyInvested >= wantInvestInTotal) {
+      return 0;
+    } else {
+      uint256 remainingToInvest = wantInvestInTotal.sub(alreadyInvested);
+      return remainingToInvest <= underlyingBalanceInVault()
+        // TODO: we think that the "else" branch of the ternary operation is not
+        // going to get hit
+        ? remainingToInvest : underlyingBalanceInVault();
+    }
+  }
+
+  function invest() internal whenStrategyDefined {
+    uint256 availableAmount = availableToInvestOut();
+    if (availableAmount > 0) {
+      IERC20Upgradeable(underlying()).safeTransfer(address(strategy()), availableAmount);
+      emit Invest(availableAmount);
+    }
+  }
+
+  /*
+  * Allows for depositing the underlying asset in exchange for shares.
+  * Approval is assumed.
+  */
+  function deposit(uint256 amount) external override defense {
+    _deposit(amount, msg.sender, msg.sender);
+  }
+
+  /*
+  * Allows for depositing the underlying asset in exchange for shares
+  * assigned to the holder.
+  * This facilitates depositing for someone else (using DepositHelper)
+  */
+  function depositFor(uint256 amount, address holder) public override defense {
+    _deposit(amount, msg.sender, holder);
+  }
+
+  function withdrawAll() public onlyControllerOrGovernance override whenStrategyDefined {
+    IStrategy(strategy()).withdrawAllToVault();
+  }
+
+  function withdraw(uint256 numberOfShares) override external {
+    require(totalSupply() > 0, "Vault has no shares");
+    require(numberOfShares > 0, "numberOfShares must be greater than 0");
+    uint256 totalSupply = totalSupply();
+    _burn(msg.sender, numberOfShares);
+
+    uint256 underlyingAmountToWithdraw = underlyingBalanceWithInvestment()
+        .mul(numberOfShares)
+        .div(totalSupply);
+    if (underlyingAmountToWithdraw > underlyingBalanceInVault()) {
+      // withdraw everything from the strategy to accurately check the share value
+      if (numberOfShares == totalSupply) {
+        IStrategy(strategy()).withdrawAllToVault();
+      } else {
+        uint256 missing = underlyingAmountToWithdraw.sub(underlyingBalanceInVault());
+        IStrategy(strategy()).withdrawToVault(missing);
+      }
+      // recalculate to improve accuracy
+      underlyingAmountToWithdraw = MathUpgradeable.min(underlyingBalanceWithInvestment()
+          .mul(numberOfShares)
+          .div(totalSupply), underlyingBalanceInVault());
+    }
+
+    IERC20Upgradeable(underlying()).safeTransfer(msg.sender, underlyingAmountToWithdraw);
+
+    // update the withdrawal amount for the holder
+    emit Withdraw(msg.sender, underlyingAmountToWithdraw);
+  }
+
+  function _deposit(uint256 amount, address sender, address beneficiary) internal {
+    require(amount > 0, "Cannot deposit 0");
+    require(beneficiary != address(0), "holder must be defined");
+
+    if (address(strategy()) != address(0)) {
+      require(IStrategy(strategy()).depositArbCheck(), "Too much arb");
+    }
+
+    uint256 toMint = totalSupply() == 0
+        ? amount
+        : amount.mul(totalSupply()).div(underlyingBalanceWithInvestment());
+    _mint(beneficiary, toMint);
+
+    IERC20Upgradeable(underlying()).safeTransferFrom(sender, address(this), amount);
+
+    // update the contribution amount for the beneficiary
+    emit Deposit(beneficiary, amount);
+  }
+
+  /**
+  * Schedules an upgrade for this vault's proxy.
+  */
+  function scheduleUpgrade(address impl) public onlyGovernance {
+    _setNextImplementation(impl);
+    _setNextImplementationTimestamp(block.timestamp.add(nextImplementationDelay()));
+  }
+
+  function shouldUpgrade() external view override returns (bool, address) {
+    return (
+      nextImplementationTimestamp() != 0
+        && block.timestamp > nextImplementationTimestamp()
+        && nextImplementation() != address(0),
+      nextImplementation()
+    );
+  }
+
+  function finalizeUpgrade() external override onlyGovernance {
+    _setNextImplementation(address(0));
+    _setNextImplementationTimestamp(0);
+  }
+}

package/contracts/base/VaultERC4626.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./interface/IERC4626.sol";
+import "./VaultV2.sol";
+
+contract VaultERC4626 is IERC4626, VaultV2 {
+
+    /// By default, the constant `10` is a uint8. This implicitly converts it to `uint256`
+    uint256 public constant TEN = 10;
+
+    function asset() public view override returns (address) {
+        return underlying();
+    }
+
+    function totalAssets() public view override returns (uint256) {
+        return underlyingBalanceWithInvestment();
+    }
+
+    function assetsPerShare() public view override returns (uint256) {
+        return convertToAssets(TEN ** decimals());
+    }
+
+    function assetsOf(address _depositor) public view override returns (uint256) {
+        return totalAssets() * balanceOf(_depositor) / totalSupply();
+    }
+
+    function maxDeposit(address /*caller*/) public view override returns (uint256) {
+        return uint(-1);
+    }
+
+    function previewDeposit(uint256 _assets) public view override returns (uint256) {
+        return convertToShares(_assets);
+    }
+
+    function deposit(uint256 _assets, address _receiver) public override nonReentrant defense returns (uint256) {
+        uint shares = convertToShares(_assets);
+        _deposit(_assets, msg.sender, _receiver);
+        return shares;
+    }
+
+    function maxMint(address /*caller*/) public view override returns (uint256) {
+        return uint(-1);
+    }
+
+    function previewMint(uint256 _shares) public view override returns (uint256) {
+        return convertToAssets(_shares);
+    }
+
+    function mint(uint256 _shares, address _receiver) public override nonReentrant defense returns (uint256) {
+        uint assets = convertToAssets(_shares);
+        _deposit(assets, msg.sender, _receiver);
+        return assets;
+    }
+
+    function maxWithdraw(address _caller) public view override returns (uint256) {
+        return assetsOf(_caller);
+    }
+
+    function previewWithdraw(uint256 _assets) public view override returns (uint256) {
+        return convertToShares(_assets);
+    }
+
+    function withdraw(
+        uint256 _assets,
+        address _receiver,
+        address _owner
+    )
+    public override
+    nonReentrant
+    defense
+    returns (uint256) {
+        uint256 shares = convertToShares(_assets);
+        _withdraw(shares, _receiver, _owner);
+        return shares;
+    }
+
+    function maxRedeem(address _caller) public view override returns (uint256) {
+        return balanceOf(_caller);
+    }
+
+    function previewRedeem(uint256 _shares) public view override returns (uint256) {
+        return convertToAssets(_shares);
+    }
+
+    function redeem(
+        uint256 _shares,
+        address _receiver,
+        address _owner
+    )
+    public override
+    nonReentrant
+    defense
+    returns (uint256) {
+        uint256 assets = convertToAssets(_shares);
+        _withdraw(_shares, _receiver, _owner);
+        return assets;
+    }
+
+    // ========================= Conversion Functions =========================
+
+    function convertToAssets(uint256 _shares) public view returns (uint256) {
+        return totalAssets() == 0 || totalSupply() == 0
+            ? _shares * (TEN ** ERC20Upgradeable(underlying()).decimals()) / (TEN ** decimals())
+            : _shares * totalAssets() / totalSupply();
+    }
+
+    function convertToShares(uint256 _assets) public view returns (uint256) {
+        return totalAssets() == 0 || totalSupply() == 0
+            ? _assets * (TEN ** decimals()) / (TEN ** ERC20Upgradeable(underlying()).decimals())
+            : _assets * totalSupply() / totalAssets();
+    }
+}

package/contracts/base/VaultProxy.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "./interface/IUpgradeSource.sol";
+import "./upgradability/BaseUpgradeabilityProxy.sol";
+
+contract VaultProxy is BaseUpgradeabilityProxy {
+
+  constructor(address _implementation) public {
+    _setImplementation(_implementation);
+  }
+
+  /**
+  * The main logic. If the timer has elapsed and there is a schedule upgrade,
+  * the governance can upgrade the vault
+  */
+  function upgrade() external {
+    (bool should, address newImplementation) = IUpgradeSource(address(this)).shouldUpgrade();
+    require(should, "Upgrade not scheduled");
+    _upgradeTo(newImplementation);
+
+    // the finalization needs to be executed on itself to update the storage of this proxy
+    // it also needs to be invoked by the governance, not by address(this), so delegatecall is needed
+    (bool success,) = address(this).delegatecall(
+      abi.encodeWithSignature("finalizeUpgrade()")
+    );
+
+    require(success, "Issue when finalizing the upgrade");
+  }
+
+  function implementation() external view returns (address) {
+    return _implementation();
+  }
+}

package/contracts/base/VaultStorage.sol

@@ -0,0 +1,199 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+
+contract VaultStorage is Initializable {
+
+  bytes32 internal constant _STRATEGY_SLOT = 0xf1a169aa0f736c2813818fdfbdc5755c31e0839c8f49831a16543496b28574ea;
+  bytes32 internal constant _UNDERLYING_SLOT = 0x1994607607e11d53306ef62e45e3bd85762c58d9bf38b5578bc4a258a26a7371;
+  bytes32 internal constant _UNDERLYING_UNIT_SLOT = 0xa66bc57d4b4eed7c7687876ca77997588987307cb13ecc23f5e52725192e5fff;
+  bytes32 internal constant _VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT = 0x39122c9adfb653455d0c05043bd52fcfbc2be864e832efd3abc72ce5a3d7ed5a;
+  bytes32 internal constant _VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT = 0x469a3bad2fab7b936c45eecd1f5da52af89cead3e2ed7f732b6f3fc92ed32308;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_SLOT = 0xb1acf527cd7cd1668b30e5a9a1c0d845714604de29ce560150922c9d8c0937df;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_TIMESTAMP_SLOT = 0x3bc747f4b148b37be485de3223c90b4468252967d2ea7f9fcbd8b6e653f434c9;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_DELAY_SLOT = 0x82ddc3be3f0c1a6870327f78f4979a0b37b21b16736ef5be6a7a7a35e530bcf0;
+  bytes32 internal constant _STRATEGY_TIME_LOCK_SLOT = 0x6d02338b2e4c913c0f7d380e2798409838a48a2c4d57d52742a808c82d713d8b;
+  bytes32 internal constant _FUTURE_STRATEGY_SLOT = 0xb441b53a4e42c2ca9182bc7ede99bedba7a5d9360d9dfbd31fa8ee2dc8590610;
+  bytes32 internal constant _STRATEGY_UPDATE_TIME_SLOT = 0x56e7c0e75875c6497f0de657009613a32558904b5c10771a825cc330feff7e72;
+  bytes32 internal constant _ALLOW_SHARE_PRICE_DECREASE_SLOT = 0x22f7033891e85fc76735ebd320e0d3f546da431c4729c2f6d2613b11923aaaed;
+  bytes32 internal constant _WITHDRAW_BEFORE_REINVESTING_SLOT = 0x4215fbb95dc0890d3e1660fb9089350f2d3f350c0a756934874cae6febf42a79;
+
+  constructor() public {
+    assert(_STRATEGY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.strategy")) - 1));
+    assert(_UNDERLYING_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.underlying")) - 1));
+    assert(_UNDERLYING_UNIT_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.underlyingUnit")) - 1));
+    assert(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.vaultFractionToInvestNumerator")) - 1));
+    assert(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.vaultFractionToInvestDenominator")) - 1));
+    assert(_NEXT_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextImplementation")) - 1));
+    assert(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextImplementationTimestamp")) - 1));
+    assert(_NEXT_IMPLEMENTATION_DELAY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextImplementationDelay")) - 1));
+    assert(_STRATEGY_TIME_LOCK_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.strategyTimeLock")) - 1));
+    assert(_FUTURE_STRATEGY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.futureStrategy")) - 1));
+    assert(_STRATEGY_UPDATE_TIME_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.strategyUpdateTime")) - 1));
+    assert(_ALLOW_SHARE_PRICE_DECREASE_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.allowSharePriceDecrease")) - 1));
+    assert(_WITHDRAW_BEFORE_REINVESTING_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.withdrawBeforeReinvesting")) - 1));
+  }
+
+  function initialize(
+    address _underlying,
+    uint256 _toInvestNumerator,
+    uint256 _toInvestDenominator,
+    uint256 _underlyingUnit,
+    uint256 _implementationChangeDelay,
+    uint256 _strategyChangeDelay
+  ) public initializer {
+    _setUnderlying(_underlying);
+    _setVaultFractionToInvestNumerator(_toInvestNumerator);
+    _setVaultFractionToInvestDenominator(_toInvestDenominator);
+    _setUnderlyingUnit(_underlyingUnit);
+    _setNextImplementationDelay(_implementationChangeDelay);
+    _setStrategyTimeLock(_strategyChangeDelay);
+    _setStrategyUpdateTime(0);
+    _setFutureStrategy(address(0));
+    _setAllowSharePriceDecrease(false);
+    _setWithdrawBeforeReinvesting(false);
+  }
+
+  function _setStrategy(address _address) internal {
+    setAddress(_STRATEGY_SLOT, _address);
+  }
+
+  function _strategy() internal view returns (address) {
+    return getAddress(_STRATEGY_SLOT);
+  }
+
+  function _setUnderlying(address _address) internal {
+    setAddress(_UNDERLYING_SLOT, _address);
+  }
+
+  function _underlying() internal view returns (address) {
+    return getAddress(_UNDERLYING_SLOT);
+  }
+
+  function _setUnderlyingUnit(uint256 _value) internal {
+    setUint256(_UNDERLYING_UNIT_SLOT, _value);
+  }
+
+  function _underlyingUnit() internal view returns (uint256) {
+    return getUint256(_UNDERLYING_UNIT_SLOT);
+  }
+
+  function _setVaultFractionToInvestNumerator(uint256 _value) internal {
+    setUint256(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT, _value);
+  }
+
+  function _vaultFractionToInvestNumerator() internal view returns (uint256) {
+    return getUint256(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT);
+  }
+
+  function _setVaultFractionToInvestDenominator(uint256 _value) internal {
+    setUint256(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT, _value);
+  }
+
+  function _vaultFractionToInvestDenominator() internal view returns (uint256) {
+    return getUint256(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT);
+  }
+
+  function _setAllowSharePriceDecrease(bool _value) internal {
+    setBoolean(_ALLOW_SHARE_PRICE_DECREASE_SLOT, _value);
+  }
+
+  function _allowSharePriceDecrease() internal view returns (bool) {
+    return getBoolean(_ALLOW_SHARE_PRICE_DECREASE_SLOT);
+  }
+
+  function _setWithdrawBeforeReinvesting(bool _value) internal {
+    setBoolean(_WITHDRAW_BEFORE_REINVESTING_SLOT, _value);
+  }
+
+  function _withdrawBeforeReinvesting() internal view returns (bool) {
+    return getBoolean(_WITHDRAW_BEFORE_REINVESTING_SLOT);
+  }
+
+  function _setNextImplementation(address _address) internal {
+    setAddress(_NEXT_IMPLEMENTATION_SLOT, _address);
+  }
+
+  function _nextImplementation() internal view returns (address) {
+    return getAddress(_NEXT_IMPLEMENTATION_SLOT);
+  }
+
+  function _setNextImplementationTimestamp(uint256 _value) internal {
+    setUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT, _value);
+  }
+
+  function _nextImplementationTimestamp() internal view returns (uint256) {
+    return getUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT);
+  }
+
+  function _setNextImplementationDelay(uint256 _value) internal {
+    setUint256(_NEXT_IMPLEMENTATION_DELAY_SLOT, _value);
+  }
+
+  function _nextImplementationDelay() internal view returns (uint256) {
+    return getUint256(_NEXT_IMPLEMENTATION_DELAY_SLOT);
+  }
+
+  function _setStrategyTimeLock(uint256 _value) internal {
+    setUint256(_STRATEGY_TIME_LOCK_SLOT, _value);
+  }
+
+  function _strategyTimeLock() internal view returns (uint256) {
+    return getUint256(_STRATEGY_TIME_LOCK_SLOT);
+  }
+
+  function _setFutureStrategy(address _value) internal {
+    setAddress(_FUTURE_STRATEGY_SLOT, _value);
+  }
+
+  function _futureStrategy() internal view returns (address) {
+    return getAddress(_FUTURE_STRATEGY_SLOT);
+  }
+
+  function _setStrategyUpdateTime(uint256 _value) internal {
+    setUint256(_STRATEGY_UPDATE_TIME_SLOT, _value);
+  }
+
+  function _strategyUpdateTime() internal view returns (uint256) {
+    return getUint256(_STRATEGY_UPDATE_TIME_SLOT);
+  }
+
+  function setBoolean(bytes32 slot, bool _value) internal {
+    setUint256(slot, _value ? 1 : 0);
+  }
+
+  function getBoolean(bytes32 slot) internal view returns (bool) {
+    return (getUint256(slot) == 1);
+  }
+
+  function setAddress(bytes32 slot, address _address) private {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _address)
+    }
+  }
+
+  function setUint256(bytes32 slot, uint256 _value) private {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _value)
+    }
+  }
+
+  function getAddress(bytes32 slot) private view returns (address str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  function getUint256(bytes32 slot) private view returns (uint256 str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  uint256[50] private ______gap;
+}