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

package/contracts/base/masterchef-base/MasterChefStrategy.sol

@@ -0,0 +1,364 @@
+//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 "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
+import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
+import "../interface/IVault.sol";
+import "../upgradability/BaseUpgradeableStrategy.sol";
+import "./interfaces/IMasterChef.sol";
+import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
+
+
+contract MasterChefStrategy is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant quickswapRouterV2 = address(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);
+  address public constant sushiswapRouterV2 = address(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _POOLID_SLOT = 0x3fd729bfa2e28b7806b03a6e014729f59477b530f995be4d51defc9dad94810b;
+  bytes32 internal constant _USE_QUICK_SLOT = 0x189f8e6d384b6a451390d61330a1995a733994439125cd881a1bdac25fe65ea2;
+  bytes32 internal constant _IS_LP_ASSET_SLOT = 0xc2f3dabf55b1bdda20d5cf5fcba9ba765dfc7c9dbaf28674ce46d43d60d58768;
+
+  // this would be reset on each upgrade
+  mapping (address => address[]) public swapRoutes;
+
+  constructor() public BaseUpgradeableStrategy() {
+    assert(_POOLID_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.poolId")) - 1));
+    assert(_USE_QUICK_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.useQuick")) - 1));
+    assert(_IS_LP_ASSET_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.isLpAsset")) - 1));
+  }
+
+  function initializeStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _rewardToken,
+    uint256 _poolID,
+    bool _isLpAsset,
+    bool _useQuick
+  ) public initializer {
+
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      _rewardToken,
+      80, // profit sharing numerator
+      1000, // profit sharing denominator
+      true, // sell
+      1e18, // sell floor
+      12 hours // implementation change delay
+    );
+
+    address _lpt;
+    (_lpt,,,) = IMasterChef(rewardPool()).poolInfo(_poolID);
+    require(_lpt == underlying(), "Pool Info does not match underlying");
+    _setPoolId(_poolID);
+
+    if (_isLpAsset) {
+      address LPComponentToken0 = IUniswapV2Pair(underlying()).token0();
+      address LPComponentToken1 = IUniswapV2Pair(underlying()).token1();
+
+      // these would be required to be initialized separately by governance
+      swapRoutes[LPComponentToken0] = new address[](0);
+      swapRoutes[LPComponentToken1] = new address[](0);
+    } else {
+      swapRoutes[underlying()] = new address[](0);
+    }
+
+    setBoolean(_USE_QUICK_SLOT, _useQuick);
+    setBoolean(_IS_LP_ASSET_SLOT, _isLpAsset);
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function rewardPoolBalance() internal view returns (uint256 bal) {
+      (bal,) = IMasterChef(rewardPool()).userInfo(poolId(), address(this));
+  }
+
+  function exitRewardPool() internal {
+      uint256 bal = rewardPoolBalance();
+      if (bal != 0) {
+          IMasterChef(rewardPool()).withdraw(poolId(), bal);
+      }
+  }
+
+  function emergencyExitRewardPool() internal {
+      uint256 bal = rewardPoolBalance();
+      if (bal != 0) {
+          IMasterChef(rewardPool()).emergencyWithdraw(poolId());
+      }
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  function enterRewardPool() internal {
+    uint256 entireBalance = IERC20(underlying()).balanceOf(address(this));
+    IERC20(underlying()).safeApprove(rewardPool(), 0);
+    IERC20(underlying()).safeApprove(rewardPool(), entireBalance);
+    IMasterChef(rewardPool()).deposit(poolId(), entireBalance);
+  }
+
+  /*
+  *   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 {
+    emergencyExitRewardPool();
+    _setPausedInvesting(true);
+  }
+
+  /*
+  *   Resumes the ability to invest into the underlying reward pools
+  */
+
+  function continueInvesting() public onlyGovernance {
+    _setPausedInvesting(false);
+  }
+
+  function setLiquidationPath(address _token, address [] memory _route) public onlyGovernance {
+    swapRoutes[_token] = _route;
+  }
+
+  // We assume that all the tradings can be done on Uniswap
+  function _liquidateReward() internal {
+    uint256 rewardBalance = IERC20(rewardToken()).balanceOf(address(this));
+    if (!sell() || rewardBalance < sellFloor()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), rewardBalance < sellFloor());
+      return;
+    }
+
+    notifyProfitInRewardToken(rewardBalance);
+    uint256 remainingRewardBalance = IERC20(rewardToken()).balanceOf(address(this));
+
+    if (remainingRewardBalance == 0) {
+      return;
+    }
+
+    address routerV2;
+    if(useQuick()) {
+      routerV2 = quickswapRouterV2;
+    } else {
+      routerV2 = sushiswapRouterV2;
+    }
+
+    // allow Uniswap to sell our reward
+    IERC20(rewardToken()).safeApprove(routerV2, 0);
+    IERC20(rewardToken()).safeApprove(routerV2, remainingRewardBalance);
+
+    // we can accept 1 as minimum because this is called only by a trusted role
+    uint256 amountOutMin = 1;
+
+    if (isLpAsset()) {
+      address LPComponentToken0 = IUniswapV2Pair(underlying()).token0();
+      address LPComponentToken1 = IUniswapV2Pair(underlying()).token1();
+
+      uint256 toToken0 = remainingRewardBalance.div(2);
+      uint256 toToken1 = remainingRewardBalance.sub(toToken0);
+
+      uint256 token0Amount;
+
+      if (swapRoutes[LPComponentToken0].length > 1) {
+        // if we need to liquidate the token0
+        IUniswapV2Router02(routerV2).swapExactTokensForTokens(
+          toToken0,
+          amountOutMin,
+          swapRoutes[LPComponentToken0],
+          address(this),
+          block.timestamp
+        );
+        token0Amount = IERC20(LPComponentToken0).balanceOf(address(this));
+      } else {
+        // otherwise we assme token0 is the reward token itself
+        token0Amount = toToken0;
+      }
+
+      uint256 token1Amount;
+
+      if (swapRoutes[LPComponentToken1].length > 1) {
+        // sell reward token to token1
+        IUniswapV2Router02(routerV2).swapExactTokensForTokens(
+          toToken1,
+          amountOutMin,
+          swapRoutes[LPComponentToken1],
+          address(this),
+          block.timestamp
+        );
+        token1Amount = IERC20(LPComponentToken1).balanceOf(address(this));
+      } else {
+        token1Amount = toToken1;
+      }
+
+      // provide token1 and token2 to SUSHI
+      IERC20(LPComponentToken0).safeApprove(routerV2, 0);
+      IERC20(LPComponentToken0).safeApprove(routerV2, token0Amount);
+
+      IERC20(LPComponentToken1).safeApprove(routerV2, 0);
+      IERC20(LPComponentToken1).safeApprove(routerV2, token1Amount);
+
+      // we provide liquidity to sushi
+      uint256 liquidity;
+      (,,liquidity) = IUniswapV2Router02(routerV2).addLiquidity(
+        LPComponentToken0,
+        LPComponentToken1,
+        token0Amount,
+        token1Amount,
+        1,  // we are willing to take whatever the pair gives us
+        1,  // we are willing to take whatever the pair gives us
+        address(this),
+        block.timestamp
+      );
+    } else {
+      IUniswapV2Router02(routerV2).swapExactTokensForTokens(
+        remainingRewardBalance,
+        amountOutMin,
+        swapRoutes[underlying()],
+        address(this),
+        block.timestamp
+      );
+    }
+  }
+
+  /*
+  *   Stakes everything the strategy holds into the reward pool
+  */
+  function investAllUnderlying() internal onlyNotPausedInvesting {
+    // this check is needed, because most of the SNX reward pools will revert if
+    // you try to stake(0).
+    if(IERC20(underlying()).balanceOf(address(this)) > 0) {
+      enterRewardPool();
+    }
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    if (address(rewardPool()) != address(0)) {
+      exitRewardPool();
+    }
+    _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
+    uint256 entireBalance = IERC20(underlying()).balanceOf(address(this));
+
+    if(amount > entireBalance){
+      // While we have the check above, we still using SafeMath below
+      // for the peace of mind (in case something gets changed in between)
+      uint256 needToWithdraw = amount.sub(entireBalance);
+      uint256 toWithdraw = Math.min(rewardPoolBalance(), needToWithdraw);
+      IMasterChef(rewardPool()).withdraw(poolId(), toWithdraw);
+    }
+
+    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) {
+    if (rewardPool() == address(0)) {
+      return IERC20(underlying()).balanceOf(address(this));
+    }
+    // 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 rewardPoolBalance().add(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 {
+    exitRewardPool();
+    _liquidateReward();
+    investAllUnderlying();
+  }
+
+  /**
+  * Can completely disable claiming rewards and selling. Good for emergency withdraw in the
+  * simplest possible way.
+  */
+  function setSell(bool s) public onlyGovernance {
+    _setSell(s);
+  }
+
+  /**
+  * Sets the minimum amount of CRV needed to trigger a sale.
+  */
+  function setSellFloor(uint256 floor) public onlyGovernance {
+    _setSellFloor(floor);
+  }
+
+  // masterchef rewards pool ID
+  function _setPoolId(uint256 _value) internal {
+    setUint256(_POOLID_SLOT, _value);
+  }
+
+  function poolId() public view returns (uint256) {
+    return getUint256(_POOLID_SLOT);
+  }
+
+  function setUseQuick(bool _value) public onlyGovernance {
+    setBoolean(_USE_QUICK_SLOT, _value);
+  }
+
+  function useQuick() public view returns (bool) {
+    return getBoolean(_USE_QUICK_SLOT);
+  }
+
+  function isLpAsset() public view returns (bool) {
+    return getBoolean(_IS_LP_ASSET_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+    // reset the liquidation paths
+    // they need to be re-set manually
+    if (isLpAsset()) {
+      swapRoutes[IUniswapV2Pair(underlying()).token0()] = new address[](0);
+      swapRoutes[IUniswapV2Pair(underlying()).token1()] = new address[](0);
+    } else {
+      swapRoutes[underlying()] = new address[](0);
+    }
+  }
+}

package/contracts/base/masterchef-base/interfaces/IMasterChef.sol

@@ -0,0 +1,12 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IMasterChef {
+    function deposit(uint256 _pid, uint256 _amount) external;
+    function withdraw(uint256 _pid, uint256 _amount) external;
+    function emergencyWithdraw(uint256 _pid) external;
+    function userInfo(uint256 _pid, address _user) external view returns (uint256 amount, uint256 rewardDebt);
+    function poolInfo(uint256 _pid) external view returns (address lpToken, uint256, uint256, uint256);
+    function massUpdatePools() external;
+}

package/contracts/base/migration/vaultMigratable_2JPYv2.sol

@@ -0,0 +1,87 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../Vault.sol";
+import "../interface/curve/ICurveDeposit_2token.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+
+interface IJPYCSwap {
+  function swap() external;
+}
+
+contract VaultMigratable_2JPYv2 is Vault {
+  using SafeERC20 for IERC20;
+
+  address public constant __jjpy = address(0x8343091F2499FD4b6174A46D067A920a3b851FF9);
+  address public constant __jpyc = address(0x6AE7Dfc73E0dDE2aa99ac063DcF7e8A63265108c);
+  address public constant __jpycv2 = address(0x431D5dfF03120AFA4bDf332c61A6e1766eF37BDB);
+  address public constant __2jpy = address(0xE8dCeA7Fb2Baf7a9F4d9af608F06d78a687F8d9A);
+  address public constant __2jpyv2 = address(0xaA91CDD7abb47F821Cf07a2d38Cc8668DEAf1bdc);
+  address public constant __2jpyv2_strategy = address(0x45257F1c56bE3D381f49371b47c3EEb1E8358431);
+  address public constant __governance = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+
+  address public constant __jpyc_swap = address(0x382d78E8BcEa98fA04b63C19Fe97D8138C3bfC5D);
+
+  event Migrated(uint256 v1Liquidity, uint256 v2Liquidity);
+  event LiquidityRemoved(uint256 v1Liquidity, uint256 amountJJPY, uint256 amountJPYC);
+  event LiquidityProvided(uint256 JPYCv2Contributed, uint256 JJPYContributed, uint256 v2Liquidity);
+
+  constructor() public {
+  }
+
+  /**
+  * Migrates the vault from the 2JPY underlying to 2JPYv2 underlying
+  */
+  function migrateUnderlying(
+    uint256 minJJPYOut, uint256 minJPYCOut,
+    uint256 min2JPYv2Mint
+  ) public onlyControllerOrGovernance {
+    require(underlying() == __2jpy, "Can only migrate if the underlying is 2JPY");
+    withdrawAll();
+
+    uint256 v1Liquidity = IERC20(__2jpy).balanceOf(address(this));
+
+    ICurveDeposit_2token(__2jpy).remove_liquidity(v1Liquidity, [minJJPYOut, minJPYCOut]);
+    uint256 amountJJPY = IERC20(__jjpy).balanceOf(address(this));
+    uint256 amountJPYC = IERC20(__jpyc).balanceOf(address(this));
+
+    emit LiquidityRemoved(v1Liquidity, amountJJPY, amountJPYC);
+
+    require(IERC20(__2jpy).balanceOf(address(this)) == 0, "Not all underlying was converted");
+
+    IERC20(__jpyc).safeApprove(__jpyc_swap, 0);
+    IERC20(__jpyc).safeApprove(__jpyc_swap, uint256(-1));
+    IJPYCSwap(__jpyc_swap).swap();
+    uint256 jpycv2Balance = IERC20(__jpycv2).balanceOf(address(this));
+
+    IERC20(__jpycv2).safeApprove(__2jpyv2, 0);
+    IERC20(__jpycv2).safeApprove(__2jpyv2, jpycv2Balance);
+    IERC20(__jjpy).safeApprove(__2jpyv2, 0);
+    IERC20(__jjpy).safeApprove(__2jpyv2, amountJJPY);
+
+    ICurveDeposit_2token(__2jpyv2).add_liquidity([amountJJPY, jpycv2Balance], min2JPYv2Mint);
+    uint256 v2Liquidity = IERC20(__2jpyv2).balanceOf(address(this));
+
+    emit LiquidityProvided(jpycv2Balance, amountJJPY, v2Liquidity);
+
+    _setUnderlying(__2jpyv2);
+    require(underlying() == __2jpyv2, "underlying switch failed");
+    _setStrategy(__2jpyv2_strategy);
+    require(strategy() == __2jpyv2_strategy, "strategy switch failed");
+
+    // some steps that regular setStrategy does
+    IERC20(underlying()).safeApprove(address(strategy()), 0);
+    IERC20(underlying()).safeApprove(address(strategy()), uint256(~0));
+
+    uint256 jjpyLeft = IERC20(__jjpy).balanceOf(address(this));
+    if (jjpyLeft > 0) {
+      IERC20(__jjpy).transfer(__governance, jjpyLeft);
+    }
+    uint256 jpycv2Left = IERC20(__jpycv2).balanceOf(address(this));
+    if (jpycv2Left > 0) {
+      IERC20(__jpycv2).transfer(strategy(), jpycv2Left);
+    }
+
+    emit Migrated(v1Liquidity, v2Liquidity);
+  }
+}

package/contracts/base/migration/vaultMigratable_bal2EUR_PAR.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_PAR is Vault {
+  using SafeERC20 for IERC20;
+
+  address public constant __token0 = address(0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c);
+  address public constant __token1 = address(0xE2Aa7db6dA1dAE97C5f5C6914d285fBfCC32A128);
+  address public constant __lpOld = address(0x0f110c55EfE62c16D553A3d3464B77e1853d0e97);
+  address public constant __lpNew = address(0x7d60a4Cb5cA92E2Da965637025122296ea6854f9);
+  address public constant __governance = address(0xf00dD244228F51547f0563e60bCa65a30FBF5f7f);
+  address public constant __bVault = address(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
+  address public constant __newStrategy = address(0x222E14Dc2f82d1d903e539C39B0C578B7353be7E);
+
+  bytes32 public constant __poolIdNew = 0x7d60a4cb5ca92e2da965637025122296ea6854f900000000000000000000085e;
+
+  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);
+  }
+}