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

package/contracts/strategies/compound/CompoundStrategy.sol

@@ -0,0 +1,296 @@
+//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/interface/IUniversalLiquidator.sol";
+import "../../base/interface/IVault.sol";
+import "../../base/upgradability/BaseUpgradeableStrategyV2.sol";
+import "../../base/interface/compound/IComet.sol";
+import "../../base/interface/compound/ICometRewards.sol";
+
+contract CompoundStrategy is BaseUpgradeableStrategyV2 {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant harvestMSIG = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _MARKET_SLOT = 0x7e894854bb2aa938fcac0eb9954ddb51bd061fc228fb4e5b8e859d96c06bfaa0;
+  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() public BaseUpgradeableStrategyV2() {
+    assert(_MARKET_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.market")) - 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 _market,
+    address _rewardPool,
+    address _rewardToken
+  ) public initializer {
+
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    address _lpt = IComet(_market).baseToken();
+    require(_lpt == _underlying, "Underlying mismatch");
+
+    _setMarket(_market);
+  }
+
+  function currentSupplied() public view returns (uint256) {
+    return IComet(market()).balanceOf(address(this));
+  }
+
+  function storedSupplied() public view returns (uint256) {
+    return getUint256(_STORED_SUPPLIED_SLOT);
+  }
+
+  function _updateStoredSupplied() internal {
+    uint256 balance = currentSupplied();
+    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 (currentSupplied() > storedSupplied()) {
+      uint256 balanceIncrease = currentSupplied().sub(storedSupplied());
+      fee = balanceIncrease.mul(totalFeeNumerator()).div(feeDenominator());
+    }
+    setUint256(_PENDING_FEE_SLOT, pendingFee().add(fee));
+    _updateStoredSupplied();
+  }
+
+  function _handleFee() internal {
+    _accrueFee();
+    uint256 fee = pendingFee();
+    if (fee > 100) {
+      uint256 balanceIncrease = fee.mul(feeDenominator()).div(totalFeeNumerator());
+      _withdrawUnderlyingFromPool(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) {
+    return true;
+  }
+
+  function _emergencyExitRewardPool() internal {
+    _accrueFee();
+    uint256 stakedBalance = currentSupplied();
+    if (stakedBalance != 0) {
+      _withdrawUnderlyingFromPool(stakedBalance);
+    }
+    _updateStoredSupplied();
+  }
+
+  function _withdrawUnderlyingFromPool(uint256 amount) internal {
+    IComet(market()).withdraw(underlying(), Math.min(currentSupplied(), amount));
+  }
+
+  function _enterRewardPool() internal {
+    address underlying_ = underlying();
+    address market_ = market();
+    uint256 entireBalance = IERC20(underlying_).balanceOf(address(this));
+    IERC20(underlying_).safeApprove(market_, 0);
+    IERC20(underlying_).safeApprove(market_, entireBalance);
+    IComet(market_).supply(underlying_, entireBalance);
+  }
+
+  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();
+    }
+  }
+
+  /*
+  *   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 unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying() || token == market());
+  }
+
+  function _claimReward() internal {
+    ICometRewards(rewardPool()).claim(market(), address(this), true);
+  }
+
+  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];
+      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 == 0) {
+      return;
+    }
+
+    address _underlying = underlying();
+    if (_underlying != _rewardToken) {
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, 0);
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, remainingRewardBalance);
+      IUniversalLiquidator(_universalLiquidator).swap(_rewardToken, _underlying, remainingRewardBalance, 1, address(this));
+    }
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    _handleFee();
+    _claimReward();
+    _liquidateReward();
+    _withdrawUnderlyingFromPool(currentSupplied().sub(pendingFee().add(1)));
+    address underlying_ = underlying();
+    IERC20(underlying_).safeTransfer(vault(), IERC20(underlying_).balanceOf(address(this)));
+    _updateStoredSupplied();
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawToVault(uint256 _amount) public restricted {
+    _accrueFee();
+    // Typically there wouldn't be any amount here
+    // however, it is possible because of the emergencyExit
+    address underlying_ = underlying();
+    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(currentSupplied(), needToWithdraw);
+      _withdrawUnderlyingFromPool(toWithdraw);
+    }
+    IERC20(underlying_).safeTransfer(vault(), _amount);
+    _updateStoredSupplied();
+  }
+
+  /*
+  *   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 IERC20(underlying()).balanceOf(address(this))
+    .add(storedSupplied())
+    .sub(pendingFee());
+  }
+
+  /*
+  *   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 {
+    _handleFee();
+    _claimReward();
+    _liquidateReward();
+    _investAllUnderlying();
+    _updateStoredSupplied();
+  }
+
+  /**
+  * Can completely disable claiming UNI rewards and selling. Good for emergency withdraw in the
+  * simplest possible way.
+  */
+  function setSell(bool s) public onlyGovernance {
+    _setSell(s);
+  }
+
+  function _setMarket(address _address) internal {
+    setAddress(_MARKET_SLOT, _address);
+  }
+
+  function market() public view returns (address) {
+    return getAddress(_MARKET_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+    _updateStoredSupplied();
+  }
+}

package/contracts/strategies/compound/CompoundStrategyMainnet_USDC.sol

@@ -0,0 +1,28 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./CompoundStrategy.sol";
+
+contract CompoundStrategyMainnet_USDC is CompoundStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174);
+    address market = address(0xF25212E676D1F7F89Cd72fFEe66158f541246445);
+    address rewards = address(0x45939657d1CA34A8FA39A924B71D28Fe8431e581);
+    address comp = address(0x8505b9d2254A7Ae468c0E9dd10Ccea3A837aef5c);
+    CompoundStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      market,
+      rewards,
+      comp
+    );
+    rewardTokens = [comp];
+  }
+}

package/contracts/strategies/compound/CompoundStrategyMainnet_USDT.sol

@@ -0,0 +1,28 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./CompoundStrategy.sol";
+
+contract CompoundStrategyMainnet_USDT is CompoundStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xc2132D05D31c914a87C6611C10748AEb04B58e8F);
+    address market = address(0xaeB318360f27748Acb200CE616E389A6C9409a07);
+    address rewards = address(0x45939657d1CA34A8FA39A924B71D28Fe8431e581);
+    address comp = address(0x8505b9d2254A7Ae468c0E9dd10Ccea3A837aef5c);
+    CompoundStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      market,
+      rewards,
+      comp
+    );
+    rewardTokens = [comp];
+  }
+}

package/contracts/strategies/compound-blue/CompoundBlueStrategy.sol

@@ -0,0 +1,292 @@
+//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/interface/IUniversalLiquidator.sol";
+import "../../base/interface/IVault.sol";
+import "../../base/upgradability/BaseUpgradeableStrategyV2.sol";
+import "../../base/interface/morpho/IMetaMorpho.sol";
+
+contract CompoundBlueStrategy is BaseUpgradeableStrategyV2 {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant harvestMSIG = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _MARKET_SLOT = 0x7e894854bb2aa938fcac0eb9954ddb51bd061fc228fb4e5b8e859d96c06bfaa0;
+  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() public BaseUpgradeableStrategyV2() {
+    assert(_MARKET_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.market")) - 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 _market,
+    address _rewardToken
+  ) public initializer {
+
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _market,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    address _lpt = IMetaMorpho(_market).asset();
+    require(_lpt == _underlying, "Underlying mismatch");
+
+    _setMarket(_market);
+  }
+
+  function currentSupplied() public view returns (uint256) {
+    address _market = market();
+    return IMetaMorpho(_market).previewRedeem(IERC20(_market).balanceOf(address(this)));
+  }
+
+  function storedSupplied() public view returns (uint256) {
+    return getUint256(_STORED_SUPPLIED_SLOT);
+  }
+
+  function _updateStoredSupplied() internal {
+    uint256 balance = currentSupplied();
+    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 (currentSupplied() > storedSupplied()) {
+      uint256 balanceIncrease = currentSupplied().sub(storedSupplied());
+      fee = balanceIncrease.mul(totalFeeNumerator()).div(feeDenominator());
+    }
+    setUint256(_PENDING_FEE_SLOT, pendingFee().add(fee));
+    _updateStoredSupplied();
+  }
+
+  function _handleFee() internal {
+    _accrueFee();
+    uint256 fee = pendingFee();
+    if (fee > 100) {
+      _withdrawUnderlyingFromPool(fee);
+      address _underlying = underlying();
+      fee = Math.min(fee, IERC20(_underlying).balanceOf(address(this)));
+      uint256 balanceIncrease = fee.mul(feeDenominator()).div(totalFeeNumerator());
+      _notifyProfitInRewardToken(_underlying, balanceIncrease);
+      setUint256(_PENDING_FEE_SLOT, pendingFee().sub(fee));
+    }
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function _emergencyExitRewardPool() internal {
+    _accrueFee();
+    uint256 stakedBalance = currentSupplied();
+    if (stakedBalance != 0) {
+      _withdrawAllUnderlying();
+    }
+    _updateStoredSupplied();
+  }
+
+  function _withdrawUnderlyingFromPool(uint256 amountUnderlying) internal {
+    IMetaMorpho(market()).withdraw(amountUnderlying, address(this), address(this));
+  }
+
+  function _withdrawAllUnderlying() internal {
+    address _market = market();
+    IMetaMorpho(_market).redeem(IERC20(_market).balanceOf(address(this)), address(this), address(this));
+  }
+
+  function _enterRewardPool() internal {
+    address underlying_ = underlying();
+    address market_ = market();
+    uint256 entireBalance = IERC20(underlying_).balanceOf(address(this));
+    IERC20(underlying_).safeApprove(market_, 0);
+    IERC20(underlying_).safeApprove(market_, entireBalance);
+    IMetaMorpho(market_).deposit(entireBalance, address(this));
+  }
+
+  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();
+    }
+  }
+
+  /*
+  *   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 unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying() || token == market());
+  }
+
+  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];
+      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 == 0) {
+      return;
+    }
+
+    address _underlying = underlying();
+    if (_underlying != _rewardToken) {
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, 0);
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, remainingRewardBalance);
+      IUniversalLiquidator(_universalLiquidator).swap(_rewardToken, _underlying, remainingRewardBalance, 1, address(this));
+    }
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    _handleFee();
+    _liquidateReward();
+    _withdrawAllUnderlying();
+    address underlying_ = underlying();
+    IERC20(underlying_).safeTransfer(vault(), IERC20(underlying_).balanceOf(address(this)).sub(pendingFee()));
+    _updateStoredSupplied();
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawToVault(uint256 _amount) public restricted {
+    _accrueFee();
+    // Typically there wouldn't be any amount here
+    // however, it is possible because of the emergencyExit
+    address underlying_ = underlying();
+    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(currentSupplied(), needToWithdraw);
+      _withdrawUnderlyingFromPool(toWithdraw);
+    }
+    IERC20(underlying_).safeTransfer(vault(), _amount);
+    _updateStoredSupplied();
+  }
+
+  /*
+  *   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 IERC20(underlying()).balanceOf(address(this))
+    .add(storedSupplied())
+    .sub(pendingFee());
+  }
+
+  /*
+  *   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 {
+    _handleFee();
+    _liquidateReward();
+    _investAllUnderlying();
+    _updateStoredSupplied();
+  }
+
+  /**
+  * Can completely disable claiming UNI rewards and selling. Good for emergency withdraw in the
+  * simplest possible way.
+  */
+  function setSell(bool s) public onlyGovernance {
+    _setSell(s);
+  }
+
+  function _setMarket(address _address) internal {
+    setAddress(_MARKET_SLOT, _address);
+  }
+
+  function market() public view returns (address) {
+    return getAddress(_MARKET_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+    _updateStoredSupplied();
+  }
+}

package/contracts/strategies/compound-blue/CompoundBlueStrategyMainnet_ETH.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./CompoundBlueStrategy.sol";
+
+contract CompoundBlueStrategyMainnet_ETH is CompoundBlueStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+    address market = address(0xF5C81d25ee174d83f1FD202cA94AE6070d073cCF);
+    address comp = address(0x8505b9d2254A7Ae468c0E9dd10Ccea3A837aef5c);
+    address wpol = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+    CompoundBlueStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      market,
+      wpol
+    );
+    rewardTokens = [wpol, comp];
+  }
+}

package/contracts/strategies/compound-blue/CompoundBlueStrategyMainnet_USDC.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./CompoundBlueStrategy.sol";
+
+contract CompoundBlueStrategyMainnet_USDC is CompoundBlueStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359);
+    address market = address(0x781FB7F6d845E3bE129289833b04d43Aa8558c42);
+    address comp = address(0x8505b9d2254A7Ae468c0E9dd10Ccea3A837aef5c);
+    address wpol = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+    CompoundBlueStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      market,
+      wpol
+    );
+    rewardTokens = [wpol, comp];
+  }
+}