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

package/contracts/strategies/gamma-merkl/GammaMerklStrategy.sol

@@ -0,0 +1,272 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/math/Math.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "../../base/upgradability/BaseUpgradeableStrategyV2.sol";
+import "../../base/interface/IUniversalLiquidator.sol";
+import "../../base/interface/gamma/IHypervisor.sol";
+import "../../base/interface/gamma/IUniProxy.sol";
+import "../../base/interface/quickswap/IDragonLair.sol";
+import "../../base/interface/gamma/IClearing.sol";
+
+contract GammaMerklStrategy is BaseUpgradeableStrategyV2 {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant dQuick = address(0x958d208Cdf087843e9AD98d23823d32E17d723A1);
+  address public constant quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+  address public constant harvestMSIG = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _UNIPROXY_SLOT = 0x09ff9720152edb4fad4ed05a0b77258f0fce17715f9397342eb08c8d7f965234;
+
+  // this would be reset on each upgrade
+  address[] public rewardTokens;
+
+  constructor() public BaseUpgradeableStrategyV2() {
+    assert(_UNIPROXY_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.uniProxy")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardToken,
+    address _uniProxy
+  ) public initializer {
+
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      address(0),
+      _rewardToken,
+      harvestMSIG
+    );
+
+    setAddress(_UNIPROXY_SLOT, _uniProxy);
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  /*
+  *   In case there are some issues discovered about the pool or underlying asset
+  *   Governance can exit the pool properly
+  *   The function is only used for emergency to exit the pool
+  */
+  function emergencyExit() public onlyGovernance {
+    _setPausedInvesting(true);
+  }
+
+  /*
+  *   Resumes the ability to invest into the underlying reward pools
+  */
+  function continueInvesting() public onlyGovernance {
+    _setPausedInvesting(false);
+  }
+
+  function addRewardToken(address _token) public onlyGovernance {
+    rewardTokens.push(_token);
+  }
+
+  /**
+   * if the pool gets dQuick as reward token it has to first be converted to QUICK
+   * by leaving the dragonLair
+   */
+  function convertDQuickToQuick() internal {
+    uint256 dQuickBalance = IERC20(dQuick).balanceOf(address(this));
+    if (dQuickBalance > 0){
+      IDragonLair(dQuick).leave(dQuickBalance);
+    }
+  }
+
+  // We assume that all the tradings can be done on Uniswap
+  function _liquidateReward() internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+
+    address _rewardToken = rewardToken();
+    address _universalLiquidator = universalLiquidator();
+    for(uint256 i = 0; i < rewardTokens.length; i++){
+      address token = rewardTokens[i];
+      if (token == quick){
+        convertDQuickToQuick();
+      }
+      uint256 rewardBalance = IERC20(token).balanceOf(address(this));
+      if (rewardBalance == 0) {
+        continue;
+      }
+      if (token != _rewardToken){
+          IERC20(token).safeApprove(_universalLiquidator, 0);
+          IERC20(token).safeApprove(_universalLiquidator, rewardBalance);
+          IUniversalLiquidator(_universalLiquidator).swap(token, _rewardToken, rewardBalance, 1, address(this));
+      }
+    }
+    uint256 rewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+    _notifyProfitInRewardToken(_rewardToken, rewardBalance);
+    uint256 remainingRewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+
+    if (remainingRewardBalance < 1e15) {
+      return;
+    }
+
+    _depositToGamma();
+  }
+
+  function _depositToGamma() internal {
+    address _underlying = underlying();
+    address _clearing = IUniProxy(uniProxy()).clearance();
+    address _token0 = IHypervisor(_underlying).token0();
+    address _token1 = IHypervisor(_underlying).token1();
+    (uint256 toToken0, uint256 toToken1) = _calculateToTokenAmounts();
+    (uint256 amount0, uint256 amount1) = _swapToTokens(_token0, _token1, toToken0, toToken1);
+    (uint256 min1, uint256 max1) = IClearing(_clearing).getDepositAmount(_underlying, _token0, amount0);
+    if (amount1 < min1) {
+      (,uint256 max0) = IClearing(_clearing).getDepositAmount(_underlying, _token1, amount1);
+      if (amount0 > max0) {
+        amount0 = max0;
+      }
+    } else if (amount1 > max1) {
+      amount1 = max1;
+    }
+    uint256[4] memory minIn = [uint(0), uint(0), uint(0), uint(0)];
+
+    IERC20(_token0).safeApprove(_underlying, 0);
+    IERC20(_token0).safeApprove(_underlying, amount0);
+    IERC20(_token1).safeApprove(_underlying, 0);
+    IERC20(_token1).safeApprove(_underlying, amount1);
+    IUniProxy(uniProxy()).deposit(amount0, amount1, address(this), _underlying, minIn);
+  }
+
+  function _calculateToTokenAmounts() internal view returns(uint256, uint256){
+    address pool = underlying();
+    (uint256 poolBalance0, uint256 poolBalance1) = IHypervisor(pool).getTotalAmounts();
+    address clearing = IUniProxy(uniProxy()).clearance();
+    uint256 sqrtPrice0In1 = uint256(IClearing(clearing).getSqrtTwapX96(pool, 1));
+    uint256 price0In1 = sqrtPrice0In1.mul(sqrtPrice0In1).div(uint(2**(96 * 2)).div(1e18));
+    uint256 totalPoolBalanceIn1 = poolBalance0.mul(price0In1).div(1e18).add(poolBalance1);
+    uint256 poolWeight0 = poolBalance0.mul(price0In1).div(totalPoolBalanceIn1);
+
+    uint256 rewardBalance = IERC20(rewardToken()).balanceOf(address(this));
+    uint256 toToken0 = rewardBalance.mul(poolWeight0).div(1e18);
+    uint256 toToken1 = rewardBalance.sub(toToken0);
+    return (toToken0, toToken1);
+  }
+
+  function _swapToTokens(
+    address tokenOut0,
+    address tokenOut1,
+    uint256 toToken0,
+    uint256 toToken1
+  ) internal returns(uint256, uint256){
+    address tokenIn = rewardToken();
+    address _universalLiquidator = universalLiquidator();
+    uint256 token0Amount;
+    if (tokenIn != tokenOut0){
+      IERC20(tokenIn).safeApprove(_universalLiquidator, 0);
+      IERC20(tokenIn).safeApprove(_universalLiquidator, toToken0);
+      IUniversalLiquidator(_universalLiquidator).swap(tokenIn, tokenOut0, toToken0, 1, address(this));
+      token0Amount = IERC20(tokenOut0).balanceOf(address(this));
+    } else {
+      // otherwise we assme token0 is the reward token itself
+      token0Amount = toToken0;
+    }
+
+    uint256 token1Amount;
+    if (tokenIn != tokenOut1){
+      IERC20(tokenIn).safeApprove(_universalLiquidator, 0);
+      IERC20(tokenIn).safeApprove(_universalLiquidator, toToken1);
+      IUniversalLiquidator(_universalLiquidator).swap(tokenIn, tokenOut1, toToken1, 1, address(this));
+      token1Amount = IERC20(tokenOut1).balanceOf(address(this));
+    } else {
+      // otherwise we assme token0 is the reward token itself
+      token1Amount = toToken1;
+    }
+    return (token0Amount, token1Amount);
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    address _underlying = underlying();
+    _liquidateReward();
+    IERC20(_underlying).safeTransfer(vault(), IERC20(_underlying).balanceOf(address(this)));
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawToVault(uint256 amount) public restricted {
+    // Typically there wouldn't be any amount here
+    // however, it is possible because of the emergencyExit
+    IERC20(underlying()).safeTransfer(vault(), amount);
+  }
+
+  /*
+  *   Note that we currently do not have a mechanism here to include the
+  *   amount of reward that is accrued.
+  */
+  function investedUnderlyingBalance() external view returns (uint256) {
+    // Adding the amount locked in the reward pool and the amount that is somehow in this contract
+    // both are in the units of "underlying"
+    // The second part is needed because there is the emergency exit mechanism
+    // which would break the assumption that all the funds are always inside of the reward pool
+    return IERC20(underlying()).balanceOf(address(this));
+  }
+
+  /*
+  *   Governance or Controller can claim coins that are somehow transferred into the contract
+  *   Note that they cannot come in take away coins that are used and defined in the strategy itself
+  */
+  function salvage(address recipient, address token, uint256 amount) external onlyControllerOrGovernance {
+     // 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);
+  }
+
+  /*
+  *   Get the reward, sell it in exchange for underlying, invest what you got.
+  *   It's not much, but it's honest work.
+  *
+  *   Note that although `onlyNotPausedInvesting` is not added here,
+  *   calling `investAllUnderlying()` affectively blocks the usage of `doHardWork`
+  *   when the investing is being paused by governance.
+  */
+  function doHardWork() external onlyNotPausedInvesting restricted {
+    _liquidateReward();
+  }
+
+  /**
+  * Can completely disable claiming rewards and selling. Good for emergency withdraw in the
+  * simplest possible way.
+  */
+  function setSell(bool s) public onlyGovernance {
+    _setSell(s);
+  }
+
+  function _setUniProxy(address _value) public onlyGovernance {
+    setAddress(_UNIPROXY_SLOT, _value);
+  }
+
+  function uniProxy() public view returns (address) {
+    return getAddress(_UNIPROXY_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+}

package/contracts/strategies/gamma-merkl/GammaMerklStrategyMainnet_QS_ETH_USDC.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./GammaMerklStrategy.sol";
+
+contract GammaMerklStrategyMainnet_QS_ETH_USDC is GammaMerklStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x3974FbDC22741A1632E024192111107b202F214f);
+    address quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+    GammaMerklStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      quick,
+      address(0xA42d55074869491D60Ac05490376B74cF19B00e6) //UniProxy
+    );
+    rewardTokens = [quick];
+  }
+}

package/contracts/strategies/gamma-merkl/GammaMerklStrategyMainnet_QS_ETH_USDT.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./GammaMerklStrategy.sol";
+
+contract GammaMerklStrategyMainnet_QS_ETH_USDT is GammaMerklStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x5928f9f61902b139e1c40cBa59077516734ff09f);
+    address quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+    GammaMerklStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      quick,
+      address(0xA42d55074869491D60Ac05490376B74cF19B00e6) //UniProxy
+    );
+    rewardTokens = [quick];
+  }
+}

package/contracts/strategies/gamma-merkl/GammaMerklStrategyMainnet_QS_MATIC_USDT.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./GammaMerklStrategy.sol";
+
+contract GammaMerklStrategyMainnet_QS_MATIC_USDT is GammaMerklStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x598cA33b7F5FAB560ddC8E76D94A4b4AA52566d7);
+    address quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+    GammaMerklStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      quick,
+      address(0xA42d55074869491D60Ac05490376B74cF19B00e6) //UniProxy
+    );
+    rewardTokens = [quick];
+  }
+}

package/contracts/strategies/gamma-merkl/GammaMerklStrategyMainnet_QS_TBTC_ETH.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./GammaMerklStrategy.sol";
+
+contract GammaMerklStrategyMainnet_QS_TBTC_ETH is GammaMerklStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xadFC52D48d68B235B6b9453eF5130fc6dFD2513E);
+    address quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+    GammaMerklStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      quick,
+      address(0xA42d55074869491D60Ac05490376B74cF19B00e6) //UniProxy
+    );
+    rewardTokens = [quick];
+  }
+}

package/contracts/strategies/gamma-merkl/GammaMerklStrategyMainnet_QS_WBTC_ETH_w.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./GammaMerklStrategy.sol";
+
+contract GammaMerklStrategyMainnet_QS_WBTC_ETH_w is GammaMerklStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xadc7B4096C3059Ec578585Df36E6E1286d345367);
+    address quick = address(0xB5C064F955D8e7F38fE0460C556a72987494eE17);
+    GammaMerklStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      quick,
+      address(0xA42d55074869491D60Ac05490376B74cF19B00e6) //UniProxy
+    );
+    rewardTokens = [quick];
+  }
+}

package/contracts/strategies/genomes/NoopStrategy_GENE_ETH.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/noop/NoopStrategyUpgradeable.sol";
+
+contract NoopStrategy_GENE_ETH is NoopStrategyUpgradeable {
+
+  address public gene_eth_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x3d4219987fBb25C3DcF73FbD9AA85FbE3C7411D9);
+    NoopStrategyUpgradeable.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault
+    );
+  }
+}

package/contracts/strategies/genomes/NoopStrategy_GNOME_ETH.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/noop/NoopStrategyUpgradeable.sol";
+
+contract NoopStrategy_GNOME_ETH is NoopStrategyUpgradeable {
+
+  address public gnome_eth_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xc1214b61965594b3e08Ea4950747d5A077Cd1886);
+    NoopStrategyUpgradeable.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault
+    );
+  }
+}

package/contracts/strategies/idle/IdleFinanceStrategy.sol

@@ -0,0 +1,240 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/math/Math.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "../../base/inheritance/RewardTokenProfitNotifier.sol";
+import "../../base/interface/IStrategy.sol";
+import "../../base/interface/IVault.sol";
+import "../../base/interface/uniswap/IUniswapV2Router02.sol";
+import "./interface/IdleToken.sol";
+
+contract IdleFinanceStrategy is RewardTokenProfitNotifier {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  event ProfitsNotCollected(address);
+  event Liquidating(address, uint256);
+
+  address public referral;
+  IERC20 public underlying;
+  address public idleUnderlying;
+  uint256 public virtualPrice;
+
+  address public vault;
+
+  address[] public rewardTokens;
+  mapping(address => address[]) public reward2WETH;
+  address[] public WETH2underlying;
+  mapping(address => bool) public sell;
+  mapping(address => bool) public useQuick;
+
+  address public constant quickswapRouterV2 = address(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);
+  address public constant sushiswapRouterV2 = address(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
+  address public constant weth = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+
+  bool public claimAllowed;
+  bool public protected;
+
+  // These tokens cannot be claimed by the controller
+  mapping (address => bool) public unsalvagableTokens;
+
+  modifier restricted() {
+    require(msg.sender == vault || msg.sender == address(controller()) || msg.sender == address(governance()),
+      "The sender has to be the controller or vault or governance");
+    _;
+  }
+
+  modifier updateVirtualPrice() {
+    if (protected) {
+      require(virtualPrice <= IIdleTokenV3_1(idleUnderlying).tokenPriceWithFee(address(this)), "virtual price is higher than needed");
+    }
+    _;
+    virtualPrice = IIdleTokenV3_1(idleUnderlying).tokenPriceWithFee(address(this));
+  }
+
+  constructor(
+    address _storage,
+    address _underlying,
+    address _idleUnderlying,
+    address _vault
+  ) RewardTokenProfitNotifier(_storage, weth) public {
+    underlying = IERC20(_underlying);
+    idleUnderlying = _idleUnderlying;
+    vault = _vault;
+    protected = true;
+
+    // set these tokens to be not salvagable
+    unsalvagableTokens[_underlying] = true;
+    unsalvagableTokens[_idleUnderlying] = true;
+    for (uint256 i = 0; i < rewardTokens.length; i++) {
+      address token = rewardTokens[i];
+      unsalvagableTokens[token] = true;
+    }
+    referral = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+    claimAllowed = true;
+
+    virtualPrice = IIdleTokenV3_1(idleUnderlying).tokenPriceWithFee(address(this));
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function setReferral(address _newRef) public onlyGovernance {
+    referral = _newRef;
+  }
+
+  /**
+  * The strategy invests by supplying the underlying token into IDLE.
+  */
+  function investAllUnderlying() public restricted updateVirtualPrice {
+    uint256 balance = underlying.balanceOf(address(this));
+    underlying.safeApprove(address(idleUnderlying), 0);
+    underlying.safeApprove(address(idleUnderlying), balance);
+    IIdleTokenV3_1(idleUnderlying).mintIdleToken(balance, true, referral);
+  }
+
+  /**
+  * Exits IDLE and transfers everything to the vault.
+  */
+  function withdrawAllToVault() external restricted updateVirtualPrice {
+    withdrawAll();
+    IERC20(address(underlying)).safeTransfer(vault, underlying.balanceOf(address(this)));
+  }
+
+  /**
+  * Withdraws all from IDLE
+  */
+  function withdrawAll() internal {
+    uint256 balance = IERC20(idleUnderlying).balanceOf(address(this));
+    uint256 underlyingBalanceInvested = balance.mul(virtualPrice).div(1e18);
+    uint256 underlyingBalanceBefore = underlying.balanceOf(address(this));
+    // this automatically claims the crops
+    IIdleTokenV3_1(idleUnderlying).redeemIdleToken(balance);
+    uint256 underlyingBalanceAfter = underlying.balanceOf(address(this));
+    require(underlyingBalanceAfter >= (underlyingBalanceBefore + underlyingBalanceInvested), "withdrawal output too low");
+
+    liquidateRewards();
+  }
+
+  function withdrawToVault(uint256 amountUnderlying) public restricted {
+    // this method is called when the vault is missing funds
+    // we will calculate the proportion of idle LP tokens that matches
+    // the underlying amount requested
+    uint256 balanceBefore = underlying.balanceOf(address(this));
+    uint256 totalIdleLpTokens = IERC20(idleUnderlying).balanceOf(address(this));
+    uint256 totalUnderlyingBalance = totalIdleLpTokens.mul(virtualPrice).div(1e18);
+    uint256 ratio = amountUnderlying.mul(1e18).div(totalUnderlyingBalance);
+    uint256 toRedeem = totalIdleLpTokens.mul(ratio).div(1e18);
+    IIdleTokenV3_1(idleUnderlying).redeemIdleToken(toRedeem);
+    uint256 balanceAfter = underlying.balanceOf(address(this));
+    require(balanceAfter >= (balanceBefore + amountUnderlying), "withdrawal output too low");
+    underlying.safeTransfer(vault, balanceAfter.sub(balanceBefore));
+  }
+
+  /**
+  * Withdraws all assets, liquidates COMP, and invests again in the required ratio.
+  */
+  function doHardWork() public restricted updateVirtualPrice {
+    if (claimAllowed) {
+      claim();
+    }
+    liquidateRewards();
+
+    // this updates the virtual price
+    investAllUnderlying();
+
+    // state of supply/loan will be updated by the modifier
+  }
+
+  /**
+  * 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 claim() internal {
+    IIdleTokenV3_1(idleUnderlying).redeemIdleToken(0);
+  }
+
+  function liquidateRewards() internal {
+    uint256 wethBalanceBeforeClaim = IERC20(weth).balanceOf(address(this));
+    for (uint256 i=0;i<rewardTokens.length;i++) {
+      address token = rewardTokens[i];
+      if (!sell[token]) {
+        // Profits can be disabled for possible simplified and rapid exit
+        emit ProfitsNotCollected(token);
+        continue;
+      }
+      uint256 balance = IERC20(token).balanceOf(address(this));
+      if (balance > 0) {
+        emit Liquidating(token, balance);
+        address routerV2;
+        if(useQuick[token]) {
+          routerV2 = quickswapRouterV2;
+        } else {
+          routerV2 = sushiswapRouterV2;
+        }
+        IERC20(token).safeApprove(routerV2, 0);
+        IERC20(token).safeApprove(routerV2, balance);
+        // we can accept 1 as the minimum because this will be called only by a trusted worker
+        IUniswapV2Router02(routerV2).swapExactTokensForTokens(
+          balance, 1, reward2WETH[token], address(this), block.timestamp
+        );
+      }
+    }
+
+    uint256 wethBalanceAfterClaim = IERC20(weth).balanceOf(address(this));
+    notifyProfitInRewardToken(wethBalanceAfterClaim.sub(wethBalanceBeforeClaim));
+
+    uint256 remainingWethBalance = IERC20(weth).balanceOf(address(this));
+
+    if (remainingWethBalance > 0 && WETH2underlying.length > 1) {
+      emit Liquidating(weth, remainingWethBalance);
+      address routerV2;
+      if(useQuick[address(underlying)]) {
+        routerV2 = quickswapRouterV2;
+      } else {
+        routerV2 = sushiswapRouterV2;
+      }
+      IERC20(weth).safeApprove(routerV2, 0);
+      IERC20(weth).safeApprove(routerV2, remainingWethBalance);
+      // we can accept 1 as the minimum because this will be called only by a trusted worker
+      IUniswapV2Router02(routerV2).swapExactTokensForTokens(
+        remainingWethBalance, 1, WETH2underlying, address(this), block.timestamp
+      );
+    }
+  }
+
+  /**
+  * Returns the current balance. Ignores COMP that was not liquidated and invested.
+  */
+  function investedUnderlyingBalance() public view returns (uint256) {
+    // NOTE: The use of virtual price is okay for appreciating assets inside IDLE,
+    // but would be wrong and exploitable if funds were lost by IDLE, indicated by
+    // the virtualPrice being greater than the token price.
+    if (protected) {
+      require(virtualPrice <= IIdleTokenV3_1(idleUnderlying).tokenPriceWithFee(address(this)), "virtual price is higher than needed");
+    }
+    uint256 invested = IERC20(idleUnderlying).balanceOf(address(this)).mul(virtualPrice).div(1e18);
+    return invested.add(IERC20(underlying).balanceOf(address(this)));
+  }
+
+  function setLiquidation(address _token, bool _sell) public onlyGovernance {
+     sell[_token] = _sell;
+  }
+
+  function setClaimAllowed(bool _claimAllowed) public onlyGovernance {
+    claimAllowed = _claimAllowed;
+  }
+
+  function setProtected(bool _protected) public onlyGovernance {
+    protected = _protected;
+  }
+}