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

package/contracts/strategies/idle/IdleStrategyDAIMainnet.sol

@@ -0,0 +1,33 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+import "./IdleFinanceStrategy.sol";
+
+/**
+* Adds the mainnet addresses to the PickleStrategy3Pool
+*/
+contract IdleStrategyDAIMainnet is IdleFinanceStrategy {
+
+  // token addresses
+  address constant public __dai = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+  address constant public __idleUnderlying= address(0x8a999F5A3546F8243205b2c0eCb0627cC10003ab);
+  address constant public __wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+
+  constructor(
+    address _storage,
+    address _vault
+  )
+  IdleFinanceStrategy(
+    _storage,
+    __dai,
+    __idleUnderlying,
+    _vault
+  )
+  public {
+    rewardTokens = [__wmatic];
+    reward2WETH[__wmatic] = [__wmatic, weth];
+    WETH2underlying = [weth, __dai];
+    sell[__wmatic] = true;
+    useQuick[__wmatic] = true;
+    useQuick[__dai] = false;
+  }
+}

package/contracts/strategies/idle/IdleStrategyUSDCMainnet.sol

@@ -0,0 +1,33 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+import "./IdleFinanceStrategy.sol";
+
+/**
+* Adds the mainnet addresses to the PickleStrategy3Pool
+*/
+contract IdleStrategyUSDCMainnet is IdleFinanceStrategy {
+
+  // token addresses
+  address constant public __usdc = address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174);
+  address constant public __idleUnderlying= address(0x1ee6470CD75D5686d0b2b90C0305Fa46fb0C89A1);
+  address constant public __wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+
+  constructor(
+    address _storage,
+    address _vault
+  )
+  IdleFinanceStrategy(
+    _storage,
+    __usdc,
+    __idleUnderlying,
+    _vault
+  )
+  public {
+    rewardTokens = [__wmatic];
+    reward2WETH[__wmatic] = [__wmatic, weth];
+    WETH2underlying = [weth, __usdc];
+    sell[__wmatic] = true;
+    useQuick[__wmatic] = true;
+    useQuick[__usdc] = true;
+  }
+}

package/contracts/strategies/idle/IdleStrategyWETHMainnet.sol

@@ -0,0 +1,30 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+import "./IdleFinanceStrategy.sol";
+
+/**
+* Adds the mainnet addresses to the PickleStrategy3Pool
+*/
+contract IdleStrategyWETHMainnet is IdleFinanceStrategy {
+
+  // token addresses
+  address constant public __idleUnderlying= address(0xfdA25D931258Df948ffecb66b5518299Df6527C4);
+  address constant public __wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+
+  constructor(
+    address _storage,
+    address _vault
+  )
+  IdleFinanceStrategy(
+    _storage,
+    weth,
+    __idleUnderlying,
+    _vault
+  )
+  public {
+    rewardTokens = [__wmatic];
+    reward2WETH[__wmatic] = [__wmatic, weth];
+    sell[__wmatic] = true;
+    useQuick[__wmatic] = true;
+  }
+}

package/contracts/strategies/idle/interface/IdleToken.sol

@@ -0,0 +1,58 @@
+/**
+ * @title: Idle Token interface
+ * @author: Idle Labs Inc., idle.finance
+ */
+ //SPDX-License-Identifier: Unlicense
+ pragma solidity 0.6.12;
+
+interface IIdleTokenV3_1 {
+    // view
+    function tokenPrice() external view returns (uint256 price);
+
+    function tokenPriceWithFee(address user) external view returns (uint256 priceWFee);
+
+    function token() external view returns (address);
+
+    function getAPRs() external view returns (address[] memory addresses, uint256[] memory aprs);
+
+    // external
+    // We should save the amount one has deposited to calc interests
+
+    /**
+     * Used to mint IdleTokens, given an underlying amount (eg. DAI).
+     * This method triggers a rebalance of the pools if needed
+     * NOTE: User should 'approve' _amount of tokens before calling mintIdleToken
+     * NOTE 2: this method can be paused
+     *
+     * @param _amount : amount of underlying token to be lended
+     * @param _skipRebalance : flag for skipping rebalance for lower gas price
+     * @param _referral : referral address
+     * @return mintedTokens : amount of IdleTokens minted
+     */
+    function mintIdleToken(uint256 _amount, bool _skipRebalance, address _referral) external returns (uint256 mintedTokens);
+
+    /**
+     * Here we calc the pool share one can withdraw given the amount of IdleToken they want to burn
+     * This method triggers a rebalance of the pools if needed
+     * NOTE: If the contract is paused or iToken price has decreased one can still redeem but no rebalance happens.
+     * NOTE 2: If iToken price has decresed one should not redeem (but can do it) otherwise he would capitalize the loss.
+     *         Ideally one should wait until the black swan event is terminated
+     *
+     * @param _amount : amount of IdleTokens to be burned
+     * @return redeemedTokens : amount of underlying tokens redeemed
+     */
+    function redeemIdleToken(uint256 _amount) external returns (uint256 redeemedTokens);
+    /**
+     * Here we calc the pool share one can withdraw given the amount of IdleToken they want to burn
+     * and send interest-bearing tokens (eg. cDAI/iDAI) directly to the user.
+     * Underlying (eg. DAI) is not redeemed here.
+     *
+     * @param _amount : amount of IdleTokens to be burned
+     */
+    function redeemInterestBearingTokens(uint256 _amount) external;
+
+    /**
+     * @return : whether has rebalanced or not
+     */
+    function rebalance() external returns (bool);
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3.sol

@@ -0,0 +1,351 @@
+//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/IElysianFields.sol";
+
+import "../../base/interface/IVault.sol";
+import "../../base/interface/kyber/IDMMRouter02.sol";
+import "../../base/interface/kyber/IDMMPool.sol";
+import "../../base/interface/kyber/IKyberZap.sol";
+
+import "../../base/upgradability/BaseUpgradeableStrategy.sol";
+
+import "../../base/PotPool.sol";
+
+contract JarvisHodlStrategyV3 is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant kyberRouter = address(0x546C79662E028B661dFB4767664d0273184E4dD1);
+  address public constant kyberZapper = address(0x83D4908c1B4F9Ca423BEE264163BC1d50F251c31);
+  address public constant msig = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+  uint256 internal constant maxUint = uint256(~0);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _POOLID_SLOT = 0x3fd729bfa2e28b7806b03a6e014729f59477b530f995be4d51defc9dad94810b;
+  bytes32 internal constant _HODLVAULT_SLOT = 0xc26d330f887c749cb38ae7c37873ff08ac4bba7aec9113c82d48a0cf6cc145f2;
+  bytes32 internal constant _POTPOOL_SLOT = 0x7f4b50847e7d7a4da6a6ea36bfb188c77e9f093697337eb9a876744f926dd014;
+  bytes32 internal constant _REWARD_LP_SLOT = 0x48141e8830aff32be47daedfc211bdc62d1652246e1c94ca6dfd96128ee259d2;
+  bytes32 internal constant _REWARD_LP_TOKEN1_SLOT = 0x39bbed0fce4dadfae510b0ff92e23dc8458ac86daafb72558e64503559b640ed;
+
+  constructor() public BaseUpgradeableStrategy() {
+    assert(_POOLID_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.poolId")) - 1));
+    assert(_HODLVAULT_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.hodlVault")) - 1));
+    assert(_POTPOOL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.potPool")) - 1));
+    assert(_REWARD_LP_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardLp")) - 1));
+    assert(_REWARD_LP_TOKEN1_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardLpToken1")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address __storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _rewardToken,
+    uint256 _poolId,
+    address _rewardLp,
+    address _hodlVault,
+    address _potPool
+  ) public initializer {
+    require(_rewardPool != address(0), "reward pool is empty");
+
+    BaseUpgradeableStrategy.initialize(
+      __storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      _rewardToken,
+      80, // profit sharing numerator
+      1000, // profit sharing denominator
+      true, // sell
+      1e15, // sell floor
+      12 hours // implementation change delay
+    );
+
+    address _lpt;
+    (_lpt,,,) = IElysianFields(_rewardPool).poolInfo(_poolId);
+    require(_lpt == _underlying, "Pool Info does not match underlying");
+
+    _setPoolId(_poolId);
+    setAddress(_HODLVAULT_SLOT, _hodlVault);
+    setAddress(_POTPOOL_SLOT, _potPool);
+    setRewardLp(_rewardLp);
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  STORAGE SETTER AND GETTER
+  //////////////////////////////////////////////////////////////*/
+
+  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 setRewardLp(address _value) internal {
+    address token0 = IDMMPool(_value).token0();
+    address token1 = IDMMPool(_value).token1();
+    require(token0 == rewardToken() || token1 == rewardToken(), "One of the underlying DMM pool token is not equal to the rewardToken");
+    setAddress(_REWARD_LP_SLOT, _value);
+    // select the token that isn't the rewardToken, s.t.
+    address rewardLpToken1 = (token0 == rewardToken()) ? token1 : token0;
+    setAddress(_REWARD_LP_TOKEN1_SLOT, rewardLpToken1);
+  }
+
+  function rewardLp() public view returns (address) {
+    return getAddress(_REWARD_LP_SLOT);
+  }
+
+  function rewardLpToken1() public view returns (address) {
+    return getAddress(_REWARD_LP_TOKEN1_SLOT);
+  }
+
+    // masterchef rewards pool ID
+  function _setPoolId(uint256 _value) internal {
+    setUint256(_POOLID_SLOT, _value);
+  }
+
+  function poolId() public view returns (uint256) {
+    return getUint256(_POOLID_SLOT);
+  }
+
+  function updateRewardPool(
+    address _newRewardPool,
+    address _newRewardToken,
+    address _newRewardLP,
+    uint256 _newPoolId,
+    address _newHodlVault
+    ) public onlyGovernance {
+    address _lpt;
+    (_lpt,,,) = IElysianFields(_newRewardPool).poolInfo(_newPoolId);
+    require(_lpt == underlying(), "Pool Info does not match underlying");
+
+    _exitRewardPool();
+
+    _setRewardToken(_newRewardToken);
+    _setRewardPool(_newRewardPool);
+    _setPoolId(_newPoolId);
+
+    setRewardLp(_newRewardLP);
+    setAddress(_HODLVAULT_SLOT, _newHodlVault);
+
+    investAllUnderlying();
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  PROXY - FINALIZE UPGRADE
+  //////////////////////////////////////////////////////////////*/
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  INTERNAL HELPER FUNCTIONS
+  //////////////////////////////////////////////////////////////*/
+
+  function _rewardPoolBalance() internal view returns (uint256 bal) {
+      (bal,) = IElysianFields(rewardPool()).userInfo(poolId(), address(this));
+  }
+
+  function _exitRewardPool() internal {
+    uint256 bal = _rewardPoolBalance();
+    if (bal != 0) {
+      IElysianFields(rewardPool()).withdraw(poolId(), bal);
+     }
+  }
+
+  function _emergencyExitRewardPool() internal {
+    uint256 bal = _rewardPoolBalance();
+    if (bal != 0) {
+      IElysianFields(rewardPool()).emergencyWithdraw(poolId());
+    }
+  }
+
+  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);
+
+    IElysianFields(rewardPool_).deposit(poolId(), entireBalance);
+  }
+
+  // We Hodl all the rewards
+  function _hodlAndNotify() internal {
+    address rewardToken_ = rewardToken();
+    uint256 rewardBalance = IERC20(rewardToken_).balanceOf(address(this));
+    if (rewardBalance == 0) {
+      return;
+    }
+    uint256 feeAmount = rewardBalance.mul(profitSharingNumerator()).div(profitSharingDenominator());
+    IERC20(rewardToken_).safeTransfer(msig, feeAmount);
+    uint256 remainingRewardBalance = IERC20(rewardToken_).balanceOf(address(this));
+
+    if (remainingRewardBalance == 0) {
+      return;
+    }
+
+    _rewardToLp();
+
+    address holdVault = hodlVault();
+    address rewardLp_ = rewardLp();
+    uint256 rewardLpBalance = IERC20(rewardLp_).balanceOf(address(this));
+
+    IERC20(rewardLp_).safeApprove(holdVault, 0);
+    IERC20(rewardLp_).safeApprove(holdVault, rewardLpBalance);
+
+    IVault(holdVault).deposit(rewardLpBalance);
+
+    uint256 fRewardBalance = IERC20(holdVault).balanceOf(address(this));
+    IERC20(holdVault).safeTransfer(potPool(), fRewardBalance);
+
+    PotPool(potPool()).notifyTargetRewardAmount(holdVault, fRewardBalance);
+  }
+
+  function _rewardToLp() internal {
+    address rewardToken_ = rewardToken();
+    uint256 rewardBalance = IERC20(rewardToken_).balanceOf(address(this));
+
+    IERC20(rewardToken_).safeApprove(kyberZapper, 0);
+    IERC20(rewardToken_).safeApprove(kyberZapper, rewardBalance);
+
+    IKyberZap(kyberZapper).zapIn({tokenIn: rewardToken_, tokenOut: rewardLpToken1(), userIn: rewardBalance, pool: rewardLp(), to: address(this), minLpQty: 1, deadline: 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();
+    }
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  PUBLIC EMERGENCY FUNCTIONS
+  //////////////////////////////////////////////////////////////*/
+
+    /*
+  *   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);
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  ISTRATEGY FUNCTION IMPLEMENTATIONS
+  //////////////////////////////////////////////////////////////*/
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    _exitRewardPool();
+    _hodlAndNotify();
+    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);
+      IElysianFields(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);
+  }
+
+  function unsalvagableTokens(address _token) public view returns (bool) {
+    return (_token == rewardToken() || _token == underlying());
+  }
+
+  /*
+  *   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 {
+    IElysianFields(rewardPool()).withdraw(poolId(), 0);
+    _hodlAndNotify();
+    investAllUnderlying();
+  }
+
+ function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2CAD.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2CAD is JarvisHodlStrategyV3 {
+
+  address public cad2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xA69b0D5c0C401BBA2d5162138613B5E38584F63F);
+    address rewardLp_ = address(0x32d8513eDDa5AEf930080F15270984A043933A95);
+    address rewardPool_ = address(0x16Ef7a2F8156819bAE95CFcE0CA712D01498b665);
+    address rewardToken_ = address(0xF65fb31ad1ccb2E7A6Ec3B34BEA4c81b68af6695);
+    address hodlVault_ = address(0x7f7136760ce6235b0889704B01bE23E6E8220e7B);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 0,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: address(0x0000000000000000000000000000000000000000) // manually set it later
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2EUR.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2EUR is JarvisHodlStrategyV3 {
+
+  address public eur2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x2fFbCE9099cBed86984286A54e5932414aF4B717);
+    address rewardLp_ = address(0x7d85cCf1B7cbAAB68c580E14fA8C92E32704404f);
+    address rewardPool_ = address(0x834579150Cc521e0afAB15568930e3BEc67B865A);
+    address rewardToken_ = address(0xEEfF5d27e40A5239f6F28d4b0fbE20acf6432717);
+    address hodlVault_ = address(0x48795326FBa34e07076038cC8f03f88a80E71214);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 0,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: address(0x0000000000000000000000000000000000000000) // manually set it later
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2EUR_EURT.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2EUR_EURT is JarvisHodlStrategyV3 {
+
+  address public eur2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x2C3cc8e698890271c8141be9F6fD6243d56B39f1);
+    address rewardLp_ = address(0x2623D9a6cceb732f9e86125e107A18e7832B27e5);
+    address rewardPool_ = address(0x2FAe83B3916e1467C970C113399ee91B31412bCD);
+    address rewardToken_ = address(0xcE0248f30d565555B793f42e46E58879F2cDCCa4);
+    address hodlVault_ = address(0x587155256938F081D6e48829d45849BD856Fd969);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 4,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: address(0x0000000000000000000000000000000000000000) // manually set it later
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2EUR_EURe.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2EUR_EURe is JarvisHodlStrategyV3 {
+
+  address public eur2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x2F3E9CA3bFf85B91D9fe6a9f3e8F9B1A6a4c3cF4);
+    address rewardLp_ = address(0x68Fd822a2Bda3dB31fFfA68089696ea4e55A9D36);
+    address rewardPool_ = address(0xa0044b58b1de085845aeA7BD3256a00EAb4145a2);
+    address rewardToken_ = address(0x5eF12a086B8A61C0f11a72b36b5EF451FA17f1f1);
+    address hodlVault_ = address(0xE17e6EfbD0064992D1E4e9a4641f30e40be208a0);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 3,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: address(0x0000000000000000000000000000000000000000) // manually set it later
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2EUR_PAR.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2EUR_PAR is JarvisHodlStrategyV3 {
+
+  address public eur2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x0f110c55EfE62c16D553A3d3464B77e1853d0e97);
+    address rewardLp_ = address(0x181650dde0A3a457F9e82B00052184AC3FEAAdF3);
+    address rewardPool_ = address(0x2BC39d179FAfC32B7796DDA3b936e491C87D245b);
+    address rewardToken_ = address(0xAFC780bb79E308990c7387AB8338160bA8071B67);
+    address hodlVault_ = address(0x173ce98897F7c846d7282555B52362B4233d2196);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 0,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: address(0x0000000000000000000000000000000000000000) // manually set it later
+    });
+  }
+}