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

package/contracts/strategies/dolomite/DolomiteLendStrategy.sol

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts/utils/math/Math.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../base/interface/IUniversalLiquidator.sol";
+import "../../base/upgradability/BaseUpgradeableStrategy.sol";
+import "../../base/interface/dolomite/IDolomiteMargin.sol";
+import "../../base/interface/dolomite/IDepositWithdraw.sol";
+import "../../base/interface/dolomite/IRewardsDistributor.sol";
+
+contract DolomiteLendStrategy is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+  address public constant harvestMSIG = address(0xf3D1A027E858976634F81B7c41B09A05A46EdA21);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _MARKET_ID_SLOT = 0x54fed29e040f8360ca8b822de4be5728a7f0714b74e8d5dd23a1d1ac0c75c6a7;
+  bytes32 internal constant _DOLOMITE_MARGIN_SLOT = 0xeb52083a303441dc22b6905f2ddc3b6ee13a44944ed7f2ebb0bcb3baf59e4e61;
+  bytes32 internal constant _DEPOSIT_WITHDRAW_SLOT = 0x096b7d9b1b276278667b14db2373be3a19524b5b48b8b667178d1ae019f52912;
+  bytes32 internal constant _STORED_SUPPLIED_SLOT = 0x280539da846b4989609abdccfea039bd1453e4f710c670b29b9eeaca0730c1a2;
+  bytes32 internal constant _PENDING_FEE_SLOT = 0x0af7af9f5ccfa82c3497f40c7c382677637aee27293a6243a22216b51481bd97;
+
+  // this would be reset on each upgrade
+  address[] public rewardTokens;
+
+  constructor() BaseUpgradeableStrategy() {
+    assert(_MARKET_ID_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.marketId")) - 1));
+    assert(_DOLOMITE_MARGIN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.dolomiteMargin")) - 1));
+    assert(_DEPOSIT_WITHDRAW_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.depositWithdraw")) - 1));
+    assert(_STORED_SUPPLIED_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.storedSupplied")) - 1));
+    assert(_PENDING_FEE_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.pendingFee")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _dolomiteMargin,
+    address _depositWithdraw,
+    uint256 _marketId,
+    address _rewardToken
+  )
+  public initializer {
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _dolomiteMargin,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    require(IDolomiteMargin(_dolomiteMargin).getMarketIdByTokenAddress(_underlying) == _marketId, "Underlying mismatch");
+    _setDolomiteMargin(_dolomiteMargin);
+    _setDepositWithdraw(_depositWithdraw);
+    _setMarketId(_marketId);
+  }
+
+  function currentBalance() public view returns (uint256) {
+    IDolomiteMargin.Info memory account;
+    account.owner = address(this);
+    IDolomiteMargin.Wei memory balanceInfo = IDolomiteMargin(dolomiteMargin()).getAccountWei(account, marketId());
+    uint256 underlyingBalance = balanceInfo.value;
+    return underlyingBalance;
+  }
+
+  function storedBalance() public view returns (uint256) {
+    return getUint256(_STORED_SUPPLIED_SLOT);
+  }
+
+  function _updateStoredBalance() internal {
+    uint256 balance = currentBalance();
+    setUint256(_STORED_SUPPLIED_SLOT, balance);
+  }
+
+  function totalFeeNumerator() public view returns (uint256) {
+    return strategistFeeNumerator().add(platformFeeNumerator()).add(profitSharingNumerator());
+  }
+
+  function pendingFee() public view returns (uint256) {
+    return getUint256(_PENDING_FEE_SLOT);
+  }
+
+  function _accrueFee() internal {
+    uint256 fee;
+    if (currentBalance() > storedBalance()) {
+      uint256 balanceIncrease = currentBalance().sub(storedBalance());
+      fee = balanceIncrease.mul(totalFeeNumerator()).div(feeDenominator());
+    }
+    setUint256(_PENDING_FEE_SLOT, pendingFee().add(fee));
+    _updateStoredBalance();
+  }
+
+  function _handleFee() internal {
+    _accrueFee();
+    uint256 fee = pendingFee();
+    if (fee > 0) {
+      uint256 balanceIncrease = fee.mul(feeDenominator()).div(totalFeeNumerator());
+      _redeem(fee);
+      address _underlying = underlying();
+      if (IERC20(_underlying).balanceOf(address(this)) < fee) {
+        balanceIncrease = IERC20(_underlying).balanceOf(address(this)).mul(feeDenominator()).div(totalFeeNumerator());
+      }
+      _notifyProfitInRewardToken(_underlying, balanceIncrease);
+      setUint256(_PENDING_FEE_SLOT, 0);
+    }
+  }
+
+  function depositArbCheck() public pure returns (bool) {
+    // there's no arb here.
+    return true;
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  /**
+  * The strategy invests by supplying the underlying as a collateral.
+  */
+  function _investAllUnderlying() internal onlyNotPausedInvesting {
+    address _underlying = underlying();
+    uint256 underlyingBalance = IERC20(_underlying).balanceOf(address(this));
+    if (underlyingBalance > 0) {
+      _supply(underlyingBalance);
+    }
+  }
+
+  function withdrawAllToVault() public restricted {
+    _liquidateRewards();
+    address _underlying = underlying();
+    _redeemAll();
+    if (IERC20(_underlying).balanceOf(address(this)) > 0) {
+      IERC20(_underlying).safeTransfer(vault(), IERC20(_underlying).balanceOf(address(this)));
+    }
+    _updateStoredBalance();
+  }
+
+  function emergencyExit() external onlyGovernance {
+    _accrueFee();
+    _redeemAll();
+    _setPausedInvesting(true);
+    _updateStoredBalance();
+  }
+
+  function continueInvesting() public onlyGovernance {
+    _setPausedInvesting(false);
+  }
+
+  function withdrawToVault(uint256 amountUnderlying) public restricted {
+    _accrueFee();
+    address _underlying = underlying();
+    uint256 balance = IERC20(_underlying).balanceOf(address(this));
+    if (amountUnderlying <= balance) {
+      IERC20(_underlying).safeTransfer(vault(), amountUnderlying);
+      return;
+    }
+    uint256 toRedeem = amountUnderlying.sub(balance);
+    // get some of the underlying
+    _redeem(toRedeem);
+    balance = IERC20(_underlying).balanceOf(address(this));
+    // transfer the amount requested (or the amount we have) back to vault()
+    IERC20(_underlying).safeTransfer(vault(), Math.min(amountUnderlying, balance));
+    balance = IERC20(_underlying).balanceOf(address(this));
+    if (balance > 1e1) {
+      _investAllUnderlying();
+    }
+    _updateStoredBalance();
+  }
+
+  /**
+  * Withdraws all assets, liquidates XVS, and invests again in the required ratio.
+  */
+  function doHardWork() public restricted {
+    _liquidateRewards();
+    _investAllUnderlying();
+    _updateStoredBalance();
+  }
+
+  /**
+  * Salvages a token.
+  */
+  function salvage(address recipient, address token, uint256 amount) public onlyGovernance {
+    // To make sure that governance cannot come in and take away the coins
+    require(!unsalvagableTokens(token), "token is defined as not salvagable");
+    IERC20(token).safeTransfer(recipient, amount);
+  }
+
+  function addRewardToken(address _token) public onlyGovernance {
+    rewardTokens.push(_token);
+  }
+
+  function _liquidateRewards() internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+    _handleFee();
+  }
+
+  /**
+  * Returns the current balance.
+  */
+  function investedUnderlyingBalance() public view returns (uint256) {
+    return IERC20(underlying()).balanceOf(address(this))
+    .add(storedBalance())
+    .sub(pendingFee());
+  }
+
+  function _supply(uint256 amount) internal {
+    address _underlying = underlying();
+    address _dolomiteMargin = dolomiteMargin();
+    IERC20(_underlying).safeApprove(_dolomiteMargin, 0);
+    IERC20(_underlying).safeApprove(_dolomiteMargin, amount);
+    IDepositWithdraw(depositWithdraw()).depositWeiIntoDefaultAccount(marketId(), amount);
+  }
+
+  function _redeem(uint256 amountUnderlying) internal {
+    IDepositWithdraw(depositWithdraw()).withdrawWeiFromDefaultAccount(
+      marketId(),
+      amountUnderlying,
+      IDepositWithdraw.BalanceCheckFlag.From
+    );
+  }
+
+  function _redeemAll() internal {
+    IDepositWithdraw(depositWithdraw()).withdrawWeiFromDefaultAccount(
+      marketId(),
+      currentBalance(),
+      IDepositWithdraw.BalanceCheckFlag.From
+    );
+  }
+
+  function _setDolomiteMargin (address _target) internal {
+    setAddress(_DOLOMITE_MARGIN_SLOT, _target);
+  }
+
+  function dolomiteMargin() public view returns (address) {
+    return getAddress(_DOLOMITE_MARGIN_SLOT);
+  }
+
+  function _setDepositWithdraw (address _target) internal {
+    setAddress(_DEPOSIT_WITHDRAW_SLOT, _target);
+  }
+
+  function depositWithdraw() public view returns (address) {
+    return getAddress(_DEPOSIT_WITHDRAW_SLOT);
+  }
+
+  function _setMarketId (uint256 _target) internal {
+    setUint256(_MARKET_ID_SLOT, _target);
+  }
+
+  function marketId() public view returns (uint256) {
+    return getUint256(_MARKET_ID_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+
+  function claimRewards(IRewardsDistributor.ClaimInfo[] calldata _claimInfo) external {
+    IRewardsDistributor(0x2E3D10CC42227aF0ce908F00C76fFe1dE1728b4B).claim(_claimInfo);
+  }
+
+  receive() external payable {}
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_DAI.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_DAI is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      1,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_GMX.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_GMX is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      29,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_USDC.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_USDC is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xaf88d065e77c8cC2239327C5EDb3A432268e5831);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      17,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_USDCe.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_USDCe is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      2,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_USDT.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_USDT is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      5,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_WBTC.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_WBTC is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      4,
+      weth
+    );
+  }
+}

package/contracts/strategies/dolomite/DolomiteLendStrategyMainnet_WETH.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./DolomiteLendStrategy.sol";
+
+contract DolomiteLendStrategyMainnet_WETH is DolomiteLendStrategy {
+
+  constructor() {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    address weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+    DolomiteLendStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0x6Bd780E7fDf01D77e4d475c821f1e7AE05409072),
+      address(0xAdB9D68c613df4AA363B42161E1282117C7B9594),
+      0,
+      weth
+    );
+  }
+}

package/contracts/strategies/fluid/FluidLendStrategy.sol

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts/utils/math/Math.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../base/interface/IUniversalLiquidator.sol";
+import "../../base/upgradability/BaseUpgradeableStrategy.sol";
+import "../../base/interface/IERC4626.sol";
+
+contract FluidLendStrategy is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant weth = address(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
+  address public constant harvestMSIG = address(0xf3D1A027E858976634F81B7c41B09A05A46EdA21);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _FTOKEN_SLOT = 0x462e4d44c9bae3e0ee3d71929710bef82ca7c929ce31980e75572ea415835b0e;
+  bytes32 internal constant _STORED_SUPPLIED_SLOT = 0x280539da846b4989609abdccfea039bd1453e4f710c670b29b9eeaca0730c1a2;
+  bytes32 internal constant _PENDING_FEE_SLOT = 0x0af7af9f5ccfa82c3497f40c7c382677637aee27293a6243a22216b51481bd97;
+
+  // this would be reset on each upgrade
+  address[] public rewardTokens;
+
+  constructor() BaseUpgradeableStrategy() {
+    assert(_FTOKEN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.fToken")) - 1));
+    assert(_STORED_SUPPLIED_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.storedSupplied")) - 1));
+    assert(_PENDING_FEE_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.pendingFee")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _fToken,
+    address _rewardToken
+  )
+  public initializer {
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _fToken,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    require(IERC4626(_fToken).asset() == _underlying, "Underlying mismatch");
+    _setFToken(_fToken);
+  }
+
+  function currentBalance() public view returns (uint256) {
+    address _fToken = fToken();
+    uint256 underlyingBalance = IERC4626(_fToken).previewRedeem(IERC20(_fToken).balanceOf(address(this)));
+    return underlyingBalance;
+  }
+
+  function storedBalance() public view returns (uint256) {
+    return getUint256(_STORED_SUPPLIED_SLOT);
+  }
+
+  function _updateStoredBalance() internal {
+    uint256 balance = currentBalance();
+    setUint256(_STORED_SUPPLIED_SLOT, balance);
+  }
+
+  function totalFeeNumerator() public view returns (uint256) {
+    return strategistFeeNumerator().add(platformFeeNumerator()).add(profitSharingNumerator());
+  }
+
+  function pendingFee() public view returns (uint256) {
+    return getUint256(_PENDING_FEE_SLOT);
+  }
+
+  function _accrueFee() internal {
+    uint256 fee;
+    if (currentBalance() > storedBalance()) {
+      uint256 balanceIncrease = currentBalance().sub(storedBalance());
+      fee = balanceIncrease.mul(totalFeeNumerator()).div(feeDenominator());
+    }
+    setUint256(_PENDING_FEE_SLOT, pendingFee().add(fee));
+    _updateStoredBalance();
+  }
+
+  function _handleFee() internal {
+    _accrueFee();
+    uint256 fee = pendingFee();
+    if (fee > 0) {
+      uint256 balanceIncrease = fee.mul(feeDenominator()).div(totalFeeNumerator());
+      _redeem(fee);
+      address _underlying = underlying();
+      if (IERC20(_underlying).balanceOf(address(this)) < fee) {
+        balanceIncrease = IERC20(_underlying).balanceOf(address(this)).mul(feeDenominator()).div(totalFeeNumerator());
+      }
+      _notifyProfitInRewardToken(_underlying, balanceIncrease);
+      setUint256(_PENDING_FEE_SLOT, 0);
+    }
+  }
+
+  function depositArbCheck() public pure returns (bool) {
+    // there's no arb here.
+    return true;
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  /**
+  * The strategy invests by supplying the underlying as a collateral.
+  */
+  function _investAllUnderlying() internal onlyNotPausedInvesting {
+    address _underlying = underlying();
+    uint256 underlyingBalance = IERC20(_underlying).balanceOf(address(this));
+    if (underlyingBalance > 1e1) {
+      _supply(underlyingBalance);
+    }
+  }
+
+  function withdrawAllToVault() public restricted {
+    _liquidateRewards();
+    address _underlying = underlying();
+    _redeemAll();
+    if (IERC20(_underlying).balanceOf(address(this)) > 0) {
+      IERC20(_underlying).safeTransfer(vault(), IERC20(_underlying).balanceOf(address(this)));
+    }
+    _updateStoredBalance();
+  }
+
+  function emergencyExit() external onlyGovernance {
+    _accrueFee();
+    _redeemAll();
+    _setPausedInvesting(true);
+    _updateStoredBalance();
+  }
+
+  function continueInvesting() public onlyGovernance {
+    _setPausedInvesting(false);
+  }
+
+  function withdrawToVault(uint256 amountUnderlying) public restricted {
+    _accrueFee();
+    address _underlying = underlying();
+    uint256 balance = IERC20(_underlying).balanceOf(address(this));
+    if (amountUnderlying <= balance) {
+      IERC20(_underlying).safeTransfer(vault(), amountUnderlying);
+      return;
+    }
+    uint256 toRedeem = amountUnderlying.sub(balance);
+    // get some of the underlying
+    _redeem(toRedeem);
+    balance = IERC20(_underlying).balanceOf(address(this));
+    // transfer the amount requested (or the amount we have) back to vault()
+    IERC20(_underlying).safeTransfer(vault(), Math.min(amountUnderlying, balance));
+    balance = IERC20(_underlying).balanceOf(address(this));
+    if (balance > 1e1) {
+      _investAllUnderlying();
+    }
+    _updateStoredBalance();
+  }
+
+  /**
+  * Withdraws all assets, liquidates XVS, and invests again in the required ratio.
+  */
+  function doHardWork() public restricted {
+    _liquidateRewards();
+    _investAllUnderlying();
+    _updateStoredBalance();
+  }
+
+  /**
+  * Salvages a token.
+  */
+  function salvage(address recipient, address token, uint256 amount) public onlyGovernance {
+    // To make sure that governance cannot come in and take away the coins
+    require(!unsalvagableTokens(token), "token is defined as not salvagable");
+    IERC20(token).safeTransfer(recipient, amount);
+  }
+
+  function addRewardToken(address _token) public onlyGovernance {
+    rewardTokens.push(_token);
+  }
+
+  function _liquidateRewards() internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+    _handleFee();
+  }
+
+  /**
+  * Returns the current balance.
+  */
+  function investedUnderlyingBalance() public view returns (uint256) {
+    return IERC20(underlying()).balanceOf(address(this))
+    .add(storedBalance())
+    .sub(pendingFee());
+  }
+
+  function _supply(uint256 amount) internal {
+    address _underlying = underlying();
+    address _fToken = fToken();
+    IERC20(_underlying).safeApprove(_fToken, 0);
+    IERC20(_underlying).safeApprove(_fToken, amount);
+    IERC4626(_fToken).deposit(amount, address(this));
+  }
+
+  function _redeem(uint256 amountUnderlying) internal {
+    address _fToken = fToken();
+    IERC4626(_fToken).withdraw(amountUnderlying, address(this), address(this));
+  }
+
+  function _redeemAll() internal {
+    address _fToken = fToken();
+    if (IERC20(_fToken).balanceOf(address(this)) > 0) {
+      IERC4626(_fToken).redeem(
+        IERC20(_fToken).balanceOf(address(this)),
+        address(this),
+        address(this)
+      );
+    }
+  }
+
+  function _setFToken (address _target) internal {
+    setAddress(_FTOKEN_SLOT, _target);
+  }
+
+  function fToken() public view returns (address) {
+    return getAddress(_FTOKEN_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+
+  receive() external payable {}
+}