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

package/contracts/base/migration/vaultMigratable_bal2EUR_agEUR.sol

@@ -0,0 +1,121 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "../Vault.sol";
+import "../interface/curve/ICurveDeposit_2token.sol";
+import "../../strategies/balancer/interface/IBVault.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+
+import "hardhat/console.sol";
+
+contract VaultMigratable_bal2EUR_agEUR is Vault {
+  using SafeERC20 for IERC20;
+
+  address public constant __token0 = address(0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c);
+  address public constant __token1 = address(0xE0B52e49357Fd4DAf2c15e02058DCE6BC0057db4);
+  address public constant __lpOld = address(0x2fFbCE9099cBed86984286A54e5932414aF4B717);
+  address public constant __lpNew = address(0xa48D164F6eB0EDC68bd03B56fa59E12F24499aD1);
+  address public constant __governance = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+  address public constant __bVault = address(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
+  address public constant __newStrategy = address(0x044b1CfaDa044f9389DA761af520574E197dCCA4);
+
+  bytes32 public constant __poolIdNew = 0xa48d164f6eb0edc68bd03b56fa59e12f24499ad10000000000000000000007c4;
+
+  event Migrated(uint256 v1Liquidity, uint256 v2Liquidity);
+  event LiquidityRemoved(uint256 v1Liquidity, uint256 amountToken0, uint256 amountToken1);
+  event LiquidityProvided(uint256 amountToken0, uint256 amountToken1, uint256 v2Liquidity);
+
+  constructor() public {
+  }
+
+  function _approveIfNeed(address token, address spender, uint256 amount) internal {
+    uint256 allowance = IERC20(token).allowance(address(this), spender);
+    if (amount > allowance) {
+      IERC20(token).safeApprove(spender, 0);
+      IERC20(token).safeApprove(spender, amount);
+    }
+  }
+
+  function _balancerSwap(
+    address sellToken,
+    address buyToken,
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    IBVault.SingleSwap memory singleSwap;
+    IBVault.SwapKind swapKind = IBVault.SwapKind.GIVEN_IN;
+
+    singleSwap.poolId = poolId;
+    singleSwap.kind = swapKind;
+    singleSwap.assetIn = IAsset(sellToken);
+    singleSwap.assetOut = IAsset(buyToken);
+    singleSwap.amount = amountIn;
+    singleSwap.userData = abi.encode(0);
+
+    IBVault.FundManagement memory funds;
+    funds.sender = address(this);
+    funds.fromInternalBalance = false;
+    funds.recipient = payable(address(this));
+    funds.toInternalBalance = false;
+
+    _approveIfNeed(sellToken, __bVault, amountIn);
+    IBVault(__bVault).swap(singleSwap, funds, minAmountOut, block.timestamp);
+  }
+
+  /**
+  * Migrates the vault from the old Curve LP underlying to new Balancer LP underlying
+  */
+  function migrateUnderlying(
+    uint256 minToken0Out,
+    uint256 minToken1Out,
+    uint256 minLPNewOut
+  ) public onlyControllerOrGovernance {
+    require(underlying() == __lpOld, "Can only migrate if the underlying is lpOld");
+    withdrawAll();
+
+    uint256 v1Liquidity = IERC20(__lpOld).balanceOf(address(this));
+    console.log("V1Liquidity:     ", v1Liquidity);
+
+    ICurveDeposit_2token(__lpOld).remove_liquidity(v1Liquidity, [minToken0Out, minToken1Out]);
+    uint256 amount0 = IERC20(__token0).balanceOf(address(this));
+    uint256 amount1 = IERC20(__token1).balanceOf(address(this));
+    console.log("token0 out:      ", amount0);
+    console.log("token1 out:      ", amount1);
+
+    emit LiquidityRemoved(v1Liquidity, amount0, amount1);
+
+    require(IERC20(__lpOld).balanceOf(address(this)) == 0, "Not all underlying was converted");
+
+    _balancerSwap(__token0, __lpNew, __poolIdNew, amount0, 1);
+    _balancerSwap(__token1, __lpNew, __poolIdNew, amount1, 1);
+    uint256 v2Liquidity = IERC20(__lpNew).balanceOf(address(this));
+    require(v2Liquidity >= minLPNewOut, "Output amount too low");
+    console.log("V2Liquidity:     ", v2Liquidity);
+
+    emit LiquidityProvided(amount0, amount1, v2Liquidity);
+
+    _setUnderlying(__lpNew);
+    require(underlying() == __lpNew, "underlying switch failed");
+    console.log("New underlying:  ", underlying());
+    _setStrategy(__newStrategy);
+    require(strategy() == __newStrategy, "strategy switch failed");
+    console.log("New strategy:    ", strategy());
+
+    // some steps that regular setStrategy does
+    IERC20(underlying()).safeApprove(address(strategy()), 0);
+    IERC20(underlying()).safeApprove(address(strategy()), uint256(~0));
+
+    uint256 token0Left = IERC20(__token0).balanceOf(address(this));
+    if (token0Left > 0) {
+      IERC20(__token0).transfer(strategy(), token0Left);
+    }
+    uint256 token1Left = IERC20(__token1).balanceOf(address(this));
+    if (token1Left > 0) {
+      IERC20(__token1).transfer(__governance, token1Left);
+    }
+
+    emit Migrated(v1Liquidity, v2Liquidity);
+  }
+}

package/contracts/base/migration/vaultMigratable_balMaticX.sol

@@ -0,0 +1,153 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "../Vault.sol";
+import "../../strategies/balancer/interface/IBVault.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+
+import "hardhat/console.sol";
+
+contract VaultMigratable_balMaticX is Vault {
+  using SafeERC20 for IERC20;
+
+  address public constant __wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address public constant __maticx = address(0xfa68FB4628DFF1028CFEc22b4162FCcd0d45efb6);
+  address public constant __lpOld = address(0xC17636e36398602dd37Bb5d1B3a9008c7629005f);
+  address public constant __lpNew = address(0xb20fC01D21A50d2C734C4a1262B4404d41fA7BF0);
+  address public constant __governance = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+  address public constant __bVault = address(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
+  address public constant __newStrategy = address(0x5A42FEDdD5e330AD857A17724543C5ef7FC7C9Cd);
+
+  bytes32 public constant __poolIdOld = 0xc17636e36398602dd37bb5d1b3a9008c7629005f0002000000000000000004c4;
+  bytes32 public constant __poolIdNew = 0xb20fc01d21a50d2c734c4a1262b4404d41fa7bf000000000000000000000075c;
+
+  event Migrated(uint256 v1Liquidity, uint256 v2Liquidity);
+  event LiquidityRemoved(uint256 v1Liquidity, uint256 amountToken0, uint256 amountToken1);
+  event LiquidityProvided(uint256 amountToken0, uint256 amountToken1, uint256 v2Liquidity);
+
+  constructor() public {
+  }
+
+  function _approveIfNeed(address token, address spender, uint256 amount) internal {
+    uint256 allowance = IERC20(token).allowance(address(this), spender);
+    if (amount > allowance) {
+      IERC20(token).safeApprove(spender, 0);
+      IERC20(token).safeApprove(spender, amount);
+    }
+  }
+
+  function _balancerWithdraw(
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256[] memory minAmountsOut
+  ) internal {
+    (address[] memory poolTokens,,) = IBVault(__bVault).getPoolTokens(poolId);
+    uint256 _nTokens = poolTokens.length;
+
+    IAsset[] memory assets = new IAsset[](_nTokens);
+    for (uint256 i = 0; i < _nTokens; i++) {
+      assets[i] = IAsset(poolTokens[i]);
+    }
+
+    IBVault.ExitKind exitKind = IBVault.ExitKind.EXACT_BPT_IN_FOR_TOKENS_OUT;
+    bytes memory userData = abi.encode(exitKind, amountIn);
+
+    IBVault.ExitPoolRequest memory request;
+    request.assets = assets;
+    request.minAmountsOut = minAmountsOut;
+    request.userData = userData;
+
+    IBVault(__bVault).exitPool(
+      poolId,
+      address(this),
+      payable(address(this)),
+      request
+    );
+  }
+
+  function _balancerSwap(
+    address sellToken,
+    address buyToken,
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    IBVault.SingleSwap memory singleSwap;
+    IBVault.SwapKind swapKind = IBVault.SwapKind.GIVEN_IN;
+
+    singleSwap.poolId = poolId;
+    singleSwap.kind = swapKind;
+    singleSwap.assetIn = IAsset(sellToken);
+    singleSwap.assetOut = IAsset(buyToken);
+    singleSwap.amount = amountIn;
+    singleSwap.userData = abi.encode(0);
+
+    IBVault.FundManagement memory funds;
+    funds.sender = address(this);
+    funds.fromInternalBalance = false;
+    funds.recipient = payable(address(this));
+    funds.toInternalBalance = false;
+
+    _approveIfNeed(sellToken, __bVault, amountIn);
+    IBVault(__bVault).swap(singleSwap, funds, minAmountOut, block.timestamp);
+  }
+
+  /**
+  * Migrates the vault from the old MaticX BPT underlying to new MaticX BPT underlying
+  */
+  function migrateUnderlying(
+    uint256 minWMaticOut,
+    uint256 minMaticXOut,
+    uint256 minLPNewOut
+  ) public onlyControllerOrGovernance {
+    require(underlying() == __lpOld, "Can only migrate if the underlying is 2JPY");
+    withdrawAll();
+
+    uint256 v1Liquidity = IERC20(__lpOld).balanceOf(address(this));
+    console.log("V1Liquidity:     ", v1Liquidity);
+    uint256[] memory minOutput = new uint256[](2);
+    minOutput[0] = minWMaticOut;
+    minOutput[1] = minMaticXOut;
+
+    _balancerWithdraw(__poolIdOld, v1Liquidity, minOutput);
+    uint256 amountWMatic = IERC20(__wmatic).balanceOf(address(this));
+    uint256 amountMaticX = IERC20(__maticx).balanceOf(address(this));
+    console.log("WMatic out:      ", amountWMatic);
+    console.log("MaticX out:      ", amountMaticX);
+
+    emit LiquidityRemoved(v1Liquidity, amountWMatic, amountMaticX);
+
+    require(IERC20(__lpOld).balanceOf(address(this)) == 0, "Not all underlying was converted");
+
+    _balancerSwap(__wmatic, __lpNew, __poolIdNew, amountWMatic, 1);
+    _balancerSwap(__maticx, __lpNew, __poolIdNew, amountMaticX, 1);
+    uint256 v2Liquidity = IERC20(__lpNew).balanceOf(address(this));
+    require(v2Liquidity >= minLPNewOut, "Output amount too low");
+    console.log("V2Liquidity:     ", v2Liquidity);
+
+    emit LiquidityProvided(amountWMatic, amountMaticX, v2Liquidity);
+
+    _setUnderlying(__lpNew);
+    require(underlying() == __lpNew, "underlying switch failed");
+    console.log("New underlying:  ", underlying());
+    _setStrategy(__newStrategy);
+    require(strategy() == __newStrategy, "strategy switch failed");
+    console.log("New strategy:    ", strategy());
+
+    // some steps that regular setStrategy does
+    IERC20(underlying()).safeApprove(address(strategy()), 0);
+    IERC20(underlying()).safeApprove(address(strategy()), uint256(~0));
+
+    uint256 wMaticLeft = IERC20(__wmatic).balanceOf(address(this));
+    if (wMaticLeft > 0) {
+      IERC20(__wmatic).transfer(strategy(), wMaticLeft);
+    }
+    uint256 maticXLeft = IERC20(__maticx).balanceOf(address(this));
+    if (maticXLeft > 0) {
+      IERC20(__maticx).transfer(__governance, maticXLeft);
+    }
+
+    emit Migrated(v1Liquidity, v2Liquidity);
+  }
+}

package/contracts/base/migration/vaultMigratable_balStMatic.sol

@@ -0,0 +1,153 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "../Vault.sol";
+import "../../strategies/balancer/interface/IBVault.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+
+import "hardhat/console.sol";
+
+contract VaultMigratable_balStMatic is Vault {
+  using SafeERC20 for IERC20;
+
+  address public constant __wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address public constant __stmatic = address(0x3A58a54C066FdC0f2D55FC9C89F0415C92eBf3C4);
+  address public constant __lpOld = address(0xaF5E0B5425dE1F5a630A8cB5AA9D97B8141C908D);
+  address public constant __lpNew = address(0x8159462d255C1D24915CB51ec361F700174cD994);
+  address public constant __governance = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+  address public constant __bVault = address(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
+  address public constant __newStrategy = address(0x9674AdE8257BEeC0f8c6fbdEAE279EA92543D989);
+
+  bytes32 public constant __poolIdOld = 0xaf5e0b5425de1f5a630a8cb5aa9d97b8141c908d000200000000000000000366;
+  bytes32 public constant __poolIdNew = 0x8159462d255c1d24915cb51ec361f700174cd99400000000000000000000075d;
+
+  event Migrated(uint256 v1Liquidity, uint256 v2Liquidity);
+  event LiquidityRemoved(uint256 v1Liquidity, uint256 amountToken0, uint256 amountToken1);
+  event LiquidityProvided(uint256 amountToken0, uint256 amountToken1, uint256 v2Liquidity);
+
+  constructor() public {
+  }
+
+  function _approveIfNeed(address token, address spender, uint256 amount) internal {
+    uint256 allowance = IERC20(token).allowance(address(this), spender);
+    if (amount > allowance) {
+      IERC20(token).safeApprove(spender, 0);
+      IERC20(token).safeApprove(spender, amount);
+    }
+  }
+
+  function _balancerWithdraw(
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256[] memory minAmountsOut
+  ) internal {
+    (address[] memory poolTokens,,) = IBVault(__bVault).getPoolTokens(poolId);
+    uint256 _nTokens = poolTokens.length;
+
+    IAsset[] memory assets = new IAsset[](_nTokens);
+    for (uint256 i = 0; i < _nTokens; i++) {
+      assets[i] = IAsset(poolTokens[i]);
+    }
+
+    IBVault.ExitKind exitKind = IBVault.ExitKind.EXACT_BPT_IN_FOR_TOKENS_OUT;
+    bytes memory userData = abi.encode(exitKind, amountIn);
+
+    IBVault.ExitPoolRequest memory request;
+    request.assets = assets;
+    request.minAmountsOut = minAmountsOut;
+    request.userData = userData;
+
+    IBVault(__bVault).exitPool(
+      poolId,
+      address(this),
+      payable(address(this)),
+      request
+    );
+  }
+
+  function _balancerSwap(
+    address sellToken,
+    address buyToken,
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    IBVault.SingleSwap memory singleSwap;
+    IBVault.SwapKind swapKind = IBVault.SwapKind.GIVEN_IN;
+
+    singleSwap.poolId = poolId;
+    singleSwap.kind = swapKind;
+    singleSwap.assetIn = IAsset(sellToken);
+    singleSwap.assetOut = IAsset(buyToken);
+    singleSwap.amount = amountIn;
+    singleSwap.userData = abi.encode(0);
+
+    IBVault.FundManagement memory funds;
+    funds.sender = address(this);
+    funds.fromInternalBalance = false;
+    funds.recipient = payable(address(this));
+    funds.toInternalBalance = false;
+
+    _approveIfNeed(sellToken, __bVault, amountIn);
+    IBVault(__bVault).swap(singleSwap, funds, minAmountOut, block.timestamp);
+  }
+
+  /**
+  * Migrates the vault from the old MaticX BPT underlying to new MaticX BPT underlying
+  */
+  function migrateUnderlying(
+    uint256 minWMaticOut,
+    uint256 minStMaticOut,
+    uint256 minLPNewOut
+  ) public onlyControllerOrGovernance {
+    require(underlying() == __lpOld, "Can only migrate if the underlying is 2JPY");
+    withdrawAll();
+
+    uint256 v1Liquidity = IERC20(__lpOld).balanceOf(address(this));
+    console.log("V1Liquidity:     ", v1Liquidity);
+    uint256[] memory minOutput = new uint256[](2);
+    minOutput[0] = minWMaticOut;
+    minOutput[1] = minStMaticOut;
+
+    _balancerWithdraw(__poolIdOld, v1Liquidity, minOutput);
+    uint256 amountWMatic = IERC20(__wmatic).balanceOf(address(this));
+    uint256 amountStMatic = IERC20(__stmatic).balanceOf(address(this));
+    console.log("WMatic out:      ", amountWMatic);
+    console.log("stMatic out:     ", amountStMatic);
+
+    emit LiquidityRemoved(v1Liquidity, amountWMatic, amountStMatic);
+
+    require(IERC20(__lpOld).balanceOf(address(this)) == 0, "Not all underlying was converted");
+
+    _balancerSwap(__wmatic, __lpNew, __poolIdNew, amountWMatic, 1);
+    _balancerSwap(__stmatic, __lpNew, __poolIdNew, amountStMatic, 1);
+    uint256 v2Liquidity = IERC20(__lpNew).balanceOf(address(this));
+    require(v2Liquidity >= minLPNewOut, "Output amount too low");
+    console.log("V2Liquidity:     ", v2Liquidity);
+
+    emit LiquidityProvided(amountWMatic, amountStMatic, v2Liquidity);
+
+    _setUnderlying(__lpNew);
+    require(underlying() == __lpNew, "underlying switch failed");
+    console.log("New underlying:  ", underlying());
+    _setStrategy(__newStrategy);
+    require(strategy() == __newStrategy, "strategy switch failed");
+    console.log("New strategy:    ", strategy());
+
+    // some steps that regular setStrategy does
+    IERC20(underlying()).safeApprove(address(strategy()), 0);
+    IERC20(underlying()).safeApprove(address(strategy()), uint256(~0));
+
+    uint256 wMaticLeft = IERC20(__wmatic).balanceOf(address(this));
+    if (wMaticLeft > 0) {
+      IERC20(__wmatic).transfer(strategy(), wMaticLeft);
+    }
+    uint256 stMaticLeft = IERC20(__stmatic).balanceOf(address(this));
+    if (stMaticLeft > 0) {
+      IERC20(__stmatic).transfer(__governance, stMaticLeft);
+    }
+
+    emit Migrated(v1Liquidity, v2Liquidity);
+  }
+}

package/contracts/base/noop/NoopStrategy.sol

@@ -0,0 +1,89 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "../inheritance/Controllable.sol";
+import "../interface/IVault.sol";
+
+
+contract NoopStrategy is Controllable {
+  using SafeERC20 for IERC20;
+  using Address for address;
+  using SafeMath for uint256;
+
+  IERC20 public underlying;
+  IVault public vault;
+
+  // These tokens cannot be claimed by the controller
+  mapping(address => bool) public unsalvagableTokens;
+
+  modifier restricted() {
+    require(msg.sender == address(vault) || msg.sender == address(controller()) || msg.sender == address(governance()),
+      "The sender has to be the controller or vault or governance");
+    _;
+  }
+
+  constructor(address _storage, address _vault) public
+  Controllable(_storage) {
+    address _underlying = IVault(_vault).underlying();
+    require(_underlying != address(0), "_underlying cannot be empty");
+    require(_vault != address(0), "_vault cannot be empty");
+    underlying = IERC20(_underlying);
+    vault = IVault(_vault);
+    unsalvagableTokens[_underlying] = true;
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  /*
+  * Returns the total invested amount.
+  */
+  function investedUnderlyingBalance() view public returns (uint256) {
+    // for real strategies, need to calculate the invested balance
+    return underlying.balanceOf(address(this));
+  }
+
+  /*
+  * Invests all tokens that were accumulated so far
+  */
+  function investAllUnderlying() external restricted {
+    // no-op
+  }
+
+  /*
+  * Cashes everything out and withdraws to the vault
+  */
+  function withdrawAllToVault() external restricted {
+    if (underlying.balanceOf(address(this)) > 0) {
+      underlying.safeTransfer(address(vault), underlying.balanceOf(address(this)));
+    }
+  }
+
+  /*
+  * Cashes some amount out and withdraws to the vault
+  */
+  function withdrawToVault(uint256 underlyingAmount) external restricted {
+    require(underlying.balanceOf(address(this)) >= underlyingAmount,
+      "insufficient balance for the withdrawal");
+    if (underlyingAmount > 0) {
+      underlying.safeTransfer(address(vault), underlyingAmount);
+    }
+  }
+
+  /*
+  * Honest harvesting. It's not much, but it pays off
+  */
+  function doHardWork() external restricted {
+    // a no-op
+  }
+
+  // should only be called by controller
+  function salvage(address destination, address token, uint256 amount) external onlyController {
+    IERC20(token).safeTransfer(destination, amount);
+  }
+}

package/contracts/base/noop/NoopStrategyUpgradeable.sol

@@ -0,0 +1,92 @@
+//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 "../interface/IVault.sol";
+import "../upgradability/BaseUpgradeableStrategy.sol";
+
+contract NoopStrategyUpgradeable is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  constructor() public BaseUpgradeableStrategy() {}
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault
+  ) public initializer {
+
+    require(_vault != address(0), "_vault cannot be empty");
+    require(_underlying == IVault(_vault).underlying(), "underlying mismatch");
+
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      address(0),
+      address(0),
+      80, // profit sharing numerator
+      1000, // profit sharing denominator
+      true, // sell
+      1e18, // sell floor
+      12 hours // implementation change delay
+    );
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function investedUnderlyingBalance() external view returns (uint256 balance) {
+      balance = IERC20(underlying()).balanceOf(address(this));
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() external restricted {
+    if (IERC20(underlying()).balanceOf(address(this)) > 0) {
+      IERC20(underlying()).safeTransfer(address(vault()), IERC20(underlying()).balanceOf(address(this)));
+    }
+  }
+
+  /*
+  * Cashes some amount out and withdraws to the vault
+  */
+  function withdrawToVault(uint256 amount) external restricted {
+    require(IERC20(underlying()).balanceOf(address(this)) >= amount,
+      "insufficient balance for the withdrawal");
+    if (amount > 0) {
+      IERC20(underlying()).safeTransfer(address(vault()), amount);
+    }
+  }
+
+  /*
+  *   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);
+  }
+
+  /*
+  * Honest harvesting. It's not much, but it pays off
+  */
+  function doHardWork() external restricted {
+    // a no-op
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+}