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

package/contracts/strategies/pearl/CaviarStrategy.sol

@@ -0,0 +1,244 @@
+//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/caviar/ICaviarChef.sol";
+
+contract CaviarStrategy is BaseUpgradeableStrategyV2 {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant harvestMSIG = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+
+  // this would be reset on each upgrade
+  address[] public rewardTokens;
+
+  constructor() public BaseUpgradeableStrategyV2() {
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _rewardToken
+  ) public initializer {
+
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    address _lpt = ICaviarChef(_rewardPool).underlying();
+    require(_lpt == _underlying, "Underlying mismatch");
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function _rewardPoolBalance() internal view returns (uint256 balance) {
+    (balance,) = ICaviarChef(rewardPool()).userInfo(address(this));
+  }
+
+  function _emergencyExitRewardPool() internal {
+    uint256 stakedBalance = _rewardPoolBalance();
+    if (stakedBalance != 0) {
+        _withdrawUnderlyingFromPool(stakedBalance);
+    }
+  }
+
+  function _withdrawUnderlyingFromPool(uint256 amount) internal {
+    uint256 toWithdraw = Math.min(_rewardPoolBalance(), amount);
+    if (toWithdraw > 0) {
+      ICaviarChef(rewardPool()).withdraw(toWithdraw, address(this));
+    }
+  }
+
+  function _enterRewardPool() internal {
+    address underlying_ = underlying();
+    address rewardPool_ = rewardPool();
+    uint256 entireBalance = IERC20(underlying_).balanceOf(address(this));
+    IERC20(underlying_).safeApprove(rewardPool_, 0);
+    IERC20(underlying_).safeApprove(rewardPool_, entireBalance);
+    ICaviarChef(rewardPool_).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());
+  }
+
+  function addRewardToken(address _token) public onlyGovernance {
+    rewardTokens.push(_token);
+  }
+
+  function _claimReward() internal {
+    ICaviarChef(rewardPool()).harvest(address(this));
+  }
+
+  function _liquidateReward(uint256 amountUnderlying) internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+    address _rewardToken = rewardToken();
+    address _underlying = underlying();
+    address _universalLiquidator = universalLiquidator();
+    for(uint256 i = 0; i < rewardTokens.length; i++){
+      address token = rewardTokens[i];
+      uint256 rewardBalance;
+      if (token == _underlying) {
+        rewardBalance = amountUnderlying;
+      } else {
+        rewardBalance = IERC20(token).balanceOf(address(this));
+      }
+      if (rewardBalance <= 1e10) {
+        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;
+    }
+
+    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 {
+    address _underlying = underlying();
+    uint256 balanceBefore = IERC20(_underlying).balanceOf(address(this));
+    _claimReward();
+    uint256 balanceAfter = IERC20(_underlying).balanceOf(address(this));
+    uint256 claimedUnderlying = balanceAfter.sub(balanceBefore);
+    _withdrawUnderlyingFromPool(_rewardPoolBalance());
+    _liquidateReward(claimedUnderlying);
+    address underlying_ = underlying();
+    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
+    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(_rewardPoolBalance(), needToWithdraw);
+      _withdrawUnderlyingFromPool(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 {
+    address _underlying = underlying();
+    uint256 balanceBefore = IERC20(_underlying).balanceOf(address(this));
+    _claimReward();
+    uint256 balanceAfter = IERC20(_underlying).balanceOf(address(this));
+    uint256 claimedUnderlying = balanceAfter.sub(balanceBefore);
+    _liquidateReward(claimedUnderlying);
+    _investAllUnderlying();
+  }
+
+  /**
+  * 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 finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+}

package/contracts/strategies/pearl/CaviarStrategyMainnet_CVR.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./CaviarStrategy.sol";
+
+contract CaviarStrategyMainnet_CVR is CaviarStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x6AE96Cc93331c19148541D4D2f31363684917092);
+    address rewards = address(0x83C5022745B2511Bd199687a42D27BEFd025A9A9);
+    address usdr = address(0x40379a439D4F6795B6fc9aa5687dB461677A2dBa);
+    CaviarStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      rewards,
+      usdr
+    );
+    rewardTokens = [underlying, usdr];
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategy.sol

@@ -0,0 +1,254 @@
+//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/PotPool.sol";
+import "../../base/upgradability/BaseUpgradeableStrategyV2.sol";
+import "../../base/interface/pearl/IGauge.sol";
+
+contract PearlHodlStrategy 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 _HODLVAULT_SLOT = 0xc26d330f887c749cb38ae7c37873ff08ac4bba7aec9113c82d48a0cf6cc145f2;
+  bytes32 internal constant _POTPOOL_SLOT = 0x7f4b50847e7d7a4da6a6ea36bfb188c77e9f093697337eb9a876744f926dd014;
+
+  constructor() public BaseUpgradeableStrategyV2() {
+    assert(_HODLVAULT_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.hodlVault")) - 1));
+    assert(_POTPOOL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.potPool")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _rewardToken,
+    address _hodlVault,
+    address _potPool
+  ) public initializer {
+
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      _rewardToken,
+      harvestMSIG
+    );
+
+    address _lpt = IGauge(_rewardPool).TOKEN();
+    require(_lpt == _underlying, "Underlying mismatch");
+
+    setAddress(_HODLVAULT_SLOT, _hodlVault);
+    setAddress(_POTPOOL_SLOT, _potPool);
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function _rewardPoolBalance() internal view returns (uint256 balance) {
+    balance = IGauge(rewardPool()).balanceOf(address(this));
+  }
+
+  function _emergencyExitRewardPool() internal {
+    uint256 stakedBalance = _rewardPoolBalance();
+    if (stakedBalance != 0) {
+        _withdrawUnderlyingFromPool(stakedBalance);
+    }
+  }
+
+  function _withdrawUnderlyingFromPool(uint256 amount) internal {
+    uint256 toWithdraw = Math.min(_rewardPoolBalance(), amount);
+    if (toWithdraw > 0) {
+      IGauge(rewardPool()).withdraw(toWithdraw);
+    }
+  }
+
+  function _enterRewardPool() internal {
+    address underlying_ = underlying();
+    address rewardPool_ = rewardPool();
+    uint256 entireBalance = IERC20(underlying_).balanceOf(address(this));
+    IERC20(underlying_).safeApprove(rewardPool_, 0);
+    IERC20(underlying_).safeApprove(rewardPool_, entireBalance);
+    IGauge(rewardPool_).deposit(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());
+  }
+
+  function _claimReward() internal {
+    IGauge(rewardPool()).getReward();
+  }
+
+  function _liquidateReward() internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+    address _rewardToken = rewardToken();
+
+    uint256 rewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+    _notifyProfitInRewardToken(_rewardToken, rewardBalance);
+    uint256 remainingRewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+
+    if (remainingRewardBalance == 0) {
+      return;
+    }
+
+    address _hodlVault = hodlVault();
+    address _target = IVault(_hodlVault).underlying();
+    if (_target != _rewardToken) {
+      address _universalLiquidator = universalLiquidator();
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, 0);
+      IERC20(_rewardToken).safeApprove(_universalLiquidator, remainingRewardBalance);
+      IUniversalLiquidator(_universalLiquidator).swap(_rewardToken, _target, remainingRewardBalance, 1, address(this));
+    }
+
+    uint256 targetBalance = IERC20(_target).balanceOf(address(this));
+    IERC20(_target).safeApprove(_hodlVault, 0);
+    IERC20(_target).safeApprove(_hodlVault, targetBalance);
+
+    IVault(_hodlVault).deposit(targetBalance);
+
+    uint256 fRewardBalance = IERC20(_hodlVault).balanceOf(address(this));
+    IERC20(_hodlVault).safeTransfer(potPool(), fRewardBalance);
+
+    PotPool(potPool()).notifyTargetRewardAmount(_hodlVault, fRewardBalance);
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    _withdrawUnderlyingFromPool(_rewardPoolBalance());
+    _claimReward();
+    _liquidateReward();
+    address underlying_ = underlying();
+    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
+    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(_rewardPoolBalance(), needToWithdraw);
+      _withdrawUnderlyingFromPool(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 {
+    _claimReward();
+    _liquidateReward();
+    _investAllUnderlying();
+  }
+
+  /**
+  * 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 setHodlVault(address _value) public onlyGovernance {
+    require(hodlVault() == address(0), "Hodl vault already set");
+    setAddress(_HODLVAULT_SLOT, _value);
+  }
+
+  function hodlVault() public view returns (address) {
+    return getAddress(_HODLVAULT_SLOT);
+  }
+
+  function setPotPool(address _value) public onlyGovernance {
+    require(potPool() == address(0), "PotPool already set");
+    setAddress(_POTPOOL_SLOT, _value);
+  }
+
+  function potPool() public view returns (address) {
+    return getAddress(_POTPOOL_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_CVR_PEARL.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_CVR_PEARL is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x700D6E1167472bDc312D9cBBdc7c58C7f4F45120);
+    address gauge = address(0xe4A9ABD56c4c42807e70909Df5853347d20274cE);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_DAI_USDR.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_DAI_USDR is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xBD02973b441Aa83c8EecEA158b98B5984bb1036E);
+    address gauge = address(0x85Fa2331040933A02b154579fAbE6A6a5A765279);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_ETH_USDR.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_ETH_USDR is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x74c64d1976157E7Aaeeed46EF04705F4424b27eC);
+    address gauge = address(0x7D02A8b758791A03319102f81bF61E220F73e43D);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_MATIC_USDR.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_MATIC_USDR is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xB4d852b92148eAA16467295975167e640E1FE57A);
+    address gauge = address(0xdA0AfBeEEBef6dA2F060237D35cab759b99B13B6);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_PEARL_USDR.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_PEARL_USDR is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xf68c20d6C50706f6C6bd8eE184382518C93B368c);
+    address gauge = address(0x79d5Ae0DF5C3A31941c3Afe0021F25e2929E205d);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}

package/contracts/strategies/pearl/PearlHodlStrategyMainnet_STAR_USDR.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./PearlHodlStrategy.sol";
+
+contract PearlHodlStrategyMainnet_STAR_USDR is PearlHodlStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x366dc82D3BFFd482cc405E58bAb3288F2dd32C94);
+    address gauge = address(0xD466c643BF2df284E4E3eF08103bE9DFe3112dfE);
+    address pearl = address(0x7238390d5f6F64e67c3211C343A410E2A3DEc142);
+    PearlHodlStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      pearl,
+      address(0xCB2f2895208c36F38c9B13aB0C9e49Ad69B14e9d), //hodlVault
+      address(0)  //potPool
+    );
+  }
+}