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

package/contracts/strategies/complifi/ComplifiStrategy.sol

@@ -0,0 +1,362 @@
+//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 "../../base/interface/IVault.sol";
+import "../../base/upgradability/BaseUpgradeableStrategy.sol";
+import "./interfaces/ILiquidityMining.sol";
+
+contract ComplifiStrategy 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,,,) = ILiquidityMining(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,) = ILiquidityMining(rewardPool()).userPoolInfo(poolId(), address(this));
+  }
+
+  function exitRewardPool() internal {
+      uint256 bal = rewardPoolBalance();
+      if (bal != 0) {
+          ILiquidityMining(rewardPool()).withdraw(poolId(), bal);
+      }
+  }
+
+  function emergencyExitRewardPool() internal {
+      uint256 bal = rewardPoolBalance();
+      if (bal != 0) {
+          ILiquidityMining(rewardPool()).withdrawEmergency(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);
+    ILiquidityMining(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();
+    }
+    ILiquidityMining(rewardPool()).claim();
+    _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);
+      ILiquidityMining(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 {
+    ILiquidityMining(rewardPool()).claim();
+    _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/strategies/complifi/ComplifiStrategyMainnet_COMFI_WETH.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./ComplifiStrategy.sol";
+
+//TO BE UPDATED WITH ADDRESSES WHEN THEY ARE KNOWN
+
+contract ComplifiStrategyMainnet_COMFI_WETH is ComplifiStrategy {
+
+  address public comfi_weth_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0);
+    address comfi = address(0x72bba3Aa59a1cCB1591D7CDDB714d8e4D5597E96);
+    address weth = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+    ComplifiStrategy.initializeStrategy(
+      _storage,
+      underlying,
+      _vault,
+      address(0), // master chef contract
+      comfi,
+      0,  // Pool id
+      true, // is LP asset
+      true // true = use Quickswap for liquidating
+    );
+    // comfi is token0, weth is token1
+    swapRoutes[weth] = [comfi, weth];
+  }
+}

package/contracts/strategies/complifi/interfaces/ILiquidityMining.sol

@@ -0,0 +1,13 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ILiquidityMining {
+    function deposit(uint256 _pid, uint256 _amount) external;
+    function withdraw(uint256 _pid, uint256 _amount) external;
+    function withdrawEmergency(uint256 _pid) external;
+    function userPoolInfo(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;
+    function claim() external;
+    function poolPidByAddress(address _address) external view returns (uint256 pid);
+}

package/contracts/strategies/complifi/interfaces/ILiquidityPool.sol

@@ -0,0 +1,63 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ILiquidityPool {
+
+    function repricingBlock() external view returns(uint);
+
+    function baseFee() external view returns(uint);
+    function feeAmp() external view returns(uint);
+    function maxFee() external view returns(uint);
+
+    function pMin() external view returns(uint);
+    function qMin() external view returns(uint);
+    function exposureLimit() external view returns(uint);
+    function volatility() external view returns(uint);
+
+    function derivativeVault() external view returns(address);
+    function dynamicFee() external view returns(address);
+    function repricer() external view returns(address);
+
+    function isFinalized()
+    external view
+    returns (bool);
+
+    function getNumTokens()
+    external view
+    returns (uint);
+
+    function getTokens()
+    external view
+    returns (address[] memory tokens);
+
+    function getLeverage(address token)
+    external view
+    returns (uint);
+
+    function getBalance(address token)
+    external view
+    returns (uint);
+
+    function getController()
+    external view
+    returns (address);
+
+    function setController(address manager)
+    external;
+
+
+    function joinPool(uint poolAmountOut, uint[2] calldata maxAmountsIn)
+    external;
+
+    function exitPool(uint poolAmountIn, uint[2] calldata minAmountsOut)
+    external;
+
+    function swapExactAmountIn(
+        address tokenIn,
+        uint tokenAmountIn,
+        address tokenOut,
+        uint minAmountOut
+    )
+    external
+    returns (uint tokenAmountOut, uint spotPriceAfter);
+}

package/contracts/strategies/complifi/interfaces/IProxyActions.sol

@@ -0,0 +1,10 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface IProxyActions {
+    function mintAndJoinPool(address _pool, uint256 _collateralAmount, address, uint256, address, uint256, uint256) external;
+    function extractChange(address _pool) external;
+    function redeem(address _vault, uint256 _primaryTokenAmount, uint256 _complementTokenAmount, uint256[] calldata) external;
+    function removeLiquidityOnLiveOrMintingState(address _pool, uint256 _poolAmountIn, address, uint256, uint256, uint256[2] calldata) external;
+    function removeLiquidityOnSettledState(address _pool, uint256 _poolAmountIn, uint256, uint256[2] calldata, uint256[] calldata) external;
+}

package/contracts/strategies/complifi/interfaces/IUSDCVault.sol

@@ -0,0 +1,55 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface IUSDCVault {
+    /// @notice vault initialization time
+    function initializationTime() external view returns(uint256);
+    /// @notice start of live period
+    function liveTime() external view returns(uint256);
+    /// @notice end of live period
+    function settleTime() external view returns(uint256);
+
+    /// @notice underlying value at the start of live period
+    function underlyingStarts(uint index) external view returns(int256);
+    /// @notice underlying value at the end of live period
+    function underlyingEnds(uint index) external view returns(int256);
+
+    /// @notice primary token conversion rate multiplied by 10 ^ 12
+    function primaryConversion() external view returns(uint256);
+    /// @notice complement token conversion rate multiplied by 10 ^ 12
+    function complementConversion() external view returns(uint256);
+
+    // @notice derivative specification address
+    function derivativeSpecification() external view returns(address);
+    // @notice collateral token address
+    function collateralToken() external view returns(address);
+    // @notice oracle address
+    function oracles(uint index) external view returns(address);
+    function oracleIterators(uint index) external view returns(address);
+
+    // @notice primary token address
+    function primaryToken() external view returns(address);
+    // @notice complement token address
+    function complementToken() external view returns(address);
+
+    function mint(uint256 _collateralAmount) external;
+
+    function mintTo(address _recipient, uint256 _collateralAmount) external;
+
+    function refund(uint256 _tokenAmount) external;
+
+    function refundTo(address _recipient, uint256 _tokenAmount) external;
+
+    function redeem(
+        uint256 _primaryTokenAmount,
+        uint256 _complementTokenAmount,
+        uint256[] calldata _underlyingEndRoundHints
+    ) external;
+
+    function redeemTo(
+        address _recipient,
+        uint256 _primaryTokenAmount,
+        uint256 _complementTokenAmount,
+        uint256[] calldata _underlyingEndRoundHints
+    ) external;
+}