@harvest-finance/harvest-strategy-arbitrum 0.0.1-security → 1.0.1

package/contracts/base/VaultStorage.sol

@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/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_STRATEGY_SLOT = 0xcd7bd9250b0e02f3b13eccf8c73ef5543cb618e0004628f9ca53b65fbdbde2d0;
+    bytes32 internal constant _NEXT_STRATEGY_TIMESTAMP_SLOT = 0x5d2b24811886ad126f78c499d71a932a5435795e4f2f6552f0900f12d663cdcf;
+    bytes32 internal constant _INVEST_ON_DEPOSIT_SLOT = 0xf7bd21df2fc19bd074b391db8b42bdc473ae2e1b3067fdb7b05f39bd9eda16ea;
+    bytes32 internal constant _COMPOUND_ON_WITHDRAW_SLOT = 0x724ff40d01b658bcc822d9ceb05c9e2f446998b3033585f9bcac7fd7929aaca7;
+    bytes32 internal constant _PAUSED_SLOT = 0xf1cf856d03630b74791fc293cfafd739932a5a075b02d357fb7a726a38777930;
+    bytes32 internal constant _DECIMALS_SLOT = 0x246bc3666321037fcc8ce5afddcaab1759373f2b839e69dcb1f4c90cffa41f37;
+
+    /**
+     * @dev Storage slot with the address of the current implementation.
+     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    constructor() {
+        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_STRATEGY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextStrategy")) - 1));
+        assert(_NEXT_STRATEGY_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextStrategyTimestamp")) - 1));
+        assert(_INVEST_ON_DEPOSIT_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.investOnDeposit")) - 1));
+        assert(_COMPOUND_ON_WITHDRAW_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.compoundOnWithdraw")) - 1));
+        assert(_PAUSED_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.paused")) - 1));
+        assert(_DECIMALS_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.decimals")) - 1));
+    }
+
+    function initialize(
+        address _underlying,
+        uint256 _toInvestNumerator,
+        uint256 _toInvestDenominator,
+        uint256 _underlyingUnit
+    ) public initializer {
+        _setUnderlying(_underlying);
+        _setVaultFractionToInvestNumerator(_toInvestNumerator);
+        _setVaultFractionToInvestDenominator(_toInvestDenominator);
+        _setUnderlyingUnit(_underlyingUnit);
+        _setNextStrategyTimestamp(0);
+        _setNextStrategy(address(0));
+        _setInvestOnDeposit(true);
+    }
+
+    function _setDecimals(uint256 _value) internal {
+        setUint256(_DECIMALS_SLOT, _value);
+    }
+
+    function _decimals() internal view returns (uint256) {
+        return getUint256(_DECIMALS_SLOT);
+    }
+
+    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 _setInvestOnDeposit(bool _value) internal {
+        setBoolean(_INVEST_ON_DEPOSIT_SLOT, _value);
+    }
+
+    function _investOnDeposit() internal view returns (bool) {
+        return getBoolean(_INVEST_ON_DEPOSIT_SLOT);
+    }
+
+    function _setCompoundOnWithdraw(bool _value) internal {
+        setBoolean(_COMPOUND_ON_WITHDRAW_SLOT, _value);
+    }
+
+    function _compoundOnWithdraw() internal view returns (bool) {
+        return getBoolean(_COMPOUND_ON_WITHDRAW_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 _setNextStrategy(address _value) internal {
+        setAddress(_NEXT_STRATEGY_SLOT, _value);
+    }
+
+    function _nextStrategy() internal view returns (address) {
+        return getAddress(_NEXT_STRATEGY_SLOT);
+    }
+
+    function _setNextStrategyTimestamp(uint256 _value) internal {
+        setUint256(_NEXT_STRATEGY_TIMESTAMP_SLOT, _value);
+    }
+
+    function _nextStrategyTimestamp() internal view returns (uint256) {
+        return getUint256(_NEXT_STRATEGY_TIMESTAMP_SLOT);
+    }
+
+    function _implementation() internal view returns (address) {
+        return getAddress(_IMPLEMENTATION_SLOT);
+    }
+
+    function _paused() internal view returns (bool) {
+        return getBoolean(_PAUSED_SLOT);
+    }
+
+    function _setPaused(bool _value) internal {
+        setBoolean(_PAUSED_SLOT, _value);
+    }
+
+    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) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, _address)
+        }
+    }
+
+    function setUint256(bytes32 slot, uint256 _value) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, _value)
+        }
+    }
+
+    function getAddress(bytes32 slot) internal view returns (address str) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            str := sload(slot)
+        }
+    }
+
+    function getUint256(bytes32 slot) internal view returns (uint256 str) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            str := sload(slot)
+        }
+    }
+
+    uint256[50] private ______gap;
+}

package/contracts/base/VaultV1.sol

@@ -0,0 +1,371 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/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";
+import "./interface/IERC4626.sol";
+
+contract VaultV1 is ERC20Upgradeable, IUpgradeSource, ControllableInit, VaultStorage {
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+  using AddressUpgradeable for address;
+  using SafeMathUpgradeable for uint256;
+
+  event Invest(uint256 amount);
+  event StrategyAnnounced(address newStrategy, uint256 time);
+  event StrategyChanged(address newStrategy, address oldStrategy);
+
+  constructor() {
+  }
+
+  // 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 initializer {
+    require(_toInvestNumerator <= _toInvestDenominator, "cannot invest more than 100%");
+    require(_toInvestDenominator != 0, "cannot divide by 0");
+
+    __ERC20_init(
+      string(abi.encodePacked("FARM_", ERC20Upgradeable(_underlying).symbol())),
+      string(abi.encodePacked("f", ERC20Upgradeable(_underlying).symbol()))
+    );
+    _setDecimals(ERC20Upgradeable(_underlying).decimals());
+
+    ControllableInit.initialize(
+      _storage
+    );
+
+    uint256 underlyingUnit = 10 ** uint256(ERC20Upgradeable(address(_underlying)).decimals());
+    VaultStorage.initialize(
+      _underlying,
+      _toInvestNumerator,
+      _toInvestDenominator,
+      underlyingUnit
+    );
+  }
+
+  function decimals() public view override returns(uint8) {
+    return uint8(_decimals());
+  }
+
+  function strategy() public view returns(address) {
+    return _strategy();
+  }
+
+  function underlying() public view 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 IController(controller()).nextImplementationDelay();
+  }
+
+  function setInvestOnDeposit(bool value) external onlyGovernance {
+    _setInvestOnDeposit(value);
+  }
+
+  function investOnDeposit() public view returns (bool) {
+    return _investOnDeposit();
+  }
+
+  function setCompoundOnWithdraw(bool value) external onlyGovernance {
+    _setCompoundOnWithdraw(value);
+  }
+
+  function compoundOnWithdraw() public view returns (bool) {
+    return _compoundOnWithdraw();
+  }
+
+  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 {
+    // 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 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 returns (uint256) {
+    if (address(strategy()) == address(0)) {
+      // initial state, when not set
+      return underlyingBalanceInVault();
+    }
+    return underlyingBalanceInVault().add(IStrategy(strategy()).investedUnderlyingBalance());
+  }
+
+  function getPricePerFullShare() public view returns (uint256) {
+    return totalSupply() == 0
+        ? underlyingUnit()
+        : underlyingUnit().mul(underlyingBalanceWithInvestment()).div(totalSupply());
+  }
+
+  /* get the user's share (in underlying)
+  */
+  function underlyingBalanceWithInvestmentForHolder(address holder) view external returns (uint256) {
+    if (totalSupply() == 0) {
+      return 0;
+    }
+    return underlyingBalanceWithInvestment()
+        .mul(balanceOf(holder))
+        .div(totalSupply());
+  }
+
+  function nextStrategy() public view returns (address) {
+    return _nextStrategy();
+  }
+
+  function nextStrategyTimestamp() public view returns (uint256) {
+    return _nextStrategyTimestamp();
+  }
+
+  function canUpdateStrategy(address _strategy) public view returns (bool) {
+    bool isStrategyNotSetYet = strategy() == address(0);
+    bool hasTimelockPassed = block.timestamp > nextStrategyTimestamp() && nextStrategyTimestamp() != 0;
+    return isStrategyNotSetYet || (_strategy == nextStrategy() && hasTimelockPassed);
+  }
+
+  /**
+  * Indicates that the strategy update will happen in the future
+  */
+  function announceStrategyUpdate(address _strategy) public onlyControllerOrGovernance {
+    // records a new timestamp
+    uint256 when = block.timestamp.add(nextImplementationDelay());
+    _setNextStrategyTimestamp(when);
+    _setNextStrategy(_strategy);
+    emit StrategyAnnounced(_strategy, when);
+  }
+
+  /**
+  * Finalizes (or cancels) the strategy update by resetting the data
+  */
+  function finalizeStrategyUpdate() public onlyControllerOrGovernance {
+    _setNextStrategyTimestamp(0);
+    _setNextStrategy(address(0));
+  }
+
+  function setStrategy(address _strategy) public 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()), type(uint256).max);
+    }
+    finalizeStrategyUpdate();
+  }
+
+  function setVaultFractionToInvest(uint256 numerator, uint256 denominator) external 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 nonReentrant defense returns (uint256 minted) {
+    minted = _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 nonReentrant defense returns (uint256 minted) {
+    minted = _deposit(amount, msg.sender, holder);
+  }
+
+  function withdraw(uint256 shares) external nonReentrant defense returns (uint256 amtUnderlying) {
+    amtUnderlying = _withdraw(shares, msg.sender, msg.sender);
+  }
+
+  function withdrawAll() public onlyControllerOrGovernance whenStrategyDefined {
+    IStrategy(strategy()).withdrawAllToVault();
+  }
+
+  function _deposit(uint256 amount, address sender, address beneficiary) internal returns (uint256) {
+    require(amount > 0, "Cannot deposit 0");
+    require(beneficiary != address(0), "holder must be defined");
+
+    IERC20Upgradeable(underlying()).safeTransferFrom(sender, address(this), amount);
+    
+    if (investOnDeposit()) {
+      invest();
+      IStrategy(strategy()).doHardWork();
+    }
+
+    uint256 toMint = totalSupply() == 0
+        ? amount
+        : amount.mul(totalSupply()).div(underlyingBalanceWithInvestment().sub(amount));
+    _mint(beneficiary, toMint);
+
+    emit IERC4626.Deposit(sender, beneficiary, amount, toMint);
+    return toMint;
+  }
+
+  function _withdraw(uint256 numberOfShares, address receiver, address owner) internal returns (uint256) {
+    require(totalSupply() > 0, "Vault has no shares");
+    require(numberOfShares > 0, "numberOfShares must be greater than 0");
+    uint256 totalSupply = totalSupply();
+
+    address sender = msg.sender;
+    if (sender != owner) {
+      uint256 currentAllowance = allowance(owner, sender);
+      if (currentAllowance != type(uint256).max) {
+        require(currentAllowance >= numberOfShares, "ERC20: transfer amount exceeds allowance");
+        _approve(owner, sender, currentAllowance - numberOfShares);
+      }
+    }
+    _burn(owner, numberOfShares);
+
+    if (compoundOnWithdraw()) {
+      IStrategy(strategy()).doHardWork();
+    }
+
+    uint256 underlyingAmountToWithdraw = underlyingBalanceWithInvestment()
+        .mul(numberOfShares)
+        .div(totalSupply);
+    if (underlyingAmountToWithdraw > underlyingBalanceInVault()) {
+      if (numberOfShares == totalSupply) {
+        IStrategy(strategy()).withdrawAllToVault();
+      } else {
+        uint256 missing = underlyingAmountToWithdraw.sub(underlyingBalanceInVault());
+        IStrategy(strategy()).withdrawToVault(missing);
+      }
+      underlyingAmountToWithdraw = MathUpgradeable.min(underlyingBalanceWithInvestment()
+          .mul(numberOfShares)
+          .div(totalSupply), underlyingBalanceInVault());
+    }
+
+    IERC20Upgradeable(underlying()).safeTransfer(receiver, underlyingAmountToWithdraw);
+    emit IERC4626.Withdraw(sender, receiver, owner, underlyingAmountToWithdraw, numberOfShares);
+    return underlyingAmountToWithdraw;
+  }
+
+  /**
+  * 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 {
+    _setDecimals(ERC20Upgradeable(underlying()).decimals());
+    _setInvestOnDeposit(true);
+    _setCompoundOnWithdraw(true);
+    _setNextImplementation(address(0));
+    _setNextImplementationTimestamp(0);
+  }
+
+  uint256[50] private ______gap;
+}