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

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_2JPY.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2JPY is JarvisHodlStrategyV3 {
+
+  address public jpy2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xE8dCeA7Fb2Baf7a9F4d9af608F06d78a687F8d9A);
+    address rewardLp_ = address(0x3b76F90A8ab3EA7f0EA717F34ec65d194E5e9737);
+    address rewardPool_ = address(0xeb4a4Ba3EF5e3A286Dc49408C27F9BDaA286db84);
+    address rewardToken_ = address(0x9120ECada8dc70Dc62cBD49f58e861a09bf83788);
+    address hodlVault_ = address(0x483d1e18E67bF69ef555c798807DaDbE7757311D);
+
+    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_2JPYv2.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2JPYv2 is JarvisHodlStrategyV3 {
+
+  address public jpy2v2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xaA91CDD7abb47F821Cf07a2d38Cc8668DEAf1bdc);
+    address rewardLp_ = address(0x707C7f22d5E3C0234bCc53aeE51420d6cdD988f9);
+    address rewardPool_ = address(0xaB5053e1f6f7fb242f62091BEE8f15c81265EE05);
+    address rewardToken_ = address(0xD7f13BeE20D6848D9Ca2F26d9A244AB7bd6CDDc0);
+    address hodlVault_ = address(0xcFD80B11fefD581Fc45868ABD0d61e8437C050b1);
+
+    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_2NZD.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_2NZD is JarvisHodlStrategyV3 {
+
+  address public nzd2_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x976A750168801F58E8AEdbCfF9328138D544cc09);
+    address rewardLp_ = address(0x707C7f22d5E3C0234bCc53aeE51420d6cdD988f9);
+    address rewardPool_ = address(0xaB5053e1f6f7fb242f62091BEE8f15c81265EE05);
+    address rewardToken_ = address(0xD7f13BeE20D6848D9Ca2F26d9A244AB7bd6CDDc0);
+    address hodlVault_ = address(0xcFD80B11fefD581Fc45868ABD0d61e8437C050b1);
+
+    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_2SGD.sol

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

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_jCHF_USDC.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_jCHF_USDC is JarvisHodlStrategyV3 {
+
+  address public jchf_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x439E6A13a5ce7FdCA2CC03bF31Fb631b3f5EF157);
+    address rewardLp_ = address(0xF40E249737c510CCE832286e54cB30E60D4e4656);
+    address rewardPool_ = address(0xFAA0f413E67A56cbbE181024279bA5504Ce487EF);
+    address rewardToken_ = address(0xBF06D9b11126B140788D842a6ed8dC7885C722B3);
+    address hodlVault_ = address(0x102Df50dB22407B64a8A6b11734c8743B6AeF953);
+    address potPool_ = address(0x24Aa3547962872351c30F1127430172317C05FEC);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 1,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: potPool_
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_jCHF_WETH.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_jCHF_WETH is JarvisHodlStrategyV3 {
+
+  address public jchf_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x95697B1b83E0F28017158BF2a2Adc6bA991088EC);
+    address rewardLp_ = address(0xF9Ce68A9E41f1e7cee5FDCbef99669653Aa61390);
+    address rewardPool_ = address(0x8b4D15670CaA3772a29AaC386AB924a0F54Abe48);
+    address rewardToken_ = address(0x8C56600D7D8f9239f124c7C52D3fa018fC801A76);
+    address hodlVault_ = address(0x3BB93BdEaF0906819e5D2Eccdc2E9Ce408296dD1);
+    address potPool_ = address(0x0000000000000000000000000000000000000000);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 1,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: potPool_
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_jEUR_USDC.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_jEUR_USDC is JarvisHodlStrategyV3 {
+
+  address public jeur_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xa1219DBE76eEcBf7571Fed6b020Dd9154396B70e);
+    address rewardLp_ = address(0xF40E249737c510CCE832286e54cB30E60D4e4656);
+    address rewardPool_ = address(0xFAA0f413E67A56cbbE181024279bA5504Ce487EF);
+    address rewardToken_ = address(0xBF06D9b11126B140788D842a6ed8dC7885C722B3);
+    address hodlVault_ = address(0x102Df50dB22407B64a8A6b11734c8743B6AeF953);
+    address potPool_ = address(0xf25474FBf9812bE2ef76abf4297A27411C156403);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 0,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: potPool_
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_jEUR_WETH.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_jEUR_WETH is JarvisHodlStrategyV3 {
+
+  address public jeur_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0x7090f6f42EA9b07C85E46aD796f8C4A50E0f76fA);
+    address rewardLp_ = address(0xF9Ce68A9E41f1e7cee5FDCbef99669653Aa61390);
+    address rewardPool_ = address(0x8b4D15670CaA3772a29AaC386AB924a0F54Abe48);
+    address rewardToken_ = address(0x8C56600D7D8f9239f124c7C52D3fa018fC801A76);
+    address hodlVault_ = address(0x3BB93BdEaF0906819e5D2Eccdc2E9Ce408296dD1);
+    address potPool_ = address(0x0000000000000000000000000000000000000000);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 0,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: potPool_
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisHodlStrategyV3Mainnet_jGBP_USDC.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisHodlStrategyV3.sol";
+
+contract JarvisHodlStrategyV3Mainnet_jGBP_USDC is JarvisHodlStrategyV3 {
+
+  address public jgbp_unused; // just a differentiator for the bytecode
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xbb2d00675B775E0F8acd590e08DA081B2a36D3a6);
+    address rewardLp_ = address(0xF40E249737c510CCE832286e54cB30E60D4e4656);
+    address rewardPool_ = address(0xFAA0f413E67A56cbbE181024279bA5504Ce487EF);
+    address rewardToken_ = address(0xBF06D9b11126B140788D842a6ed8dC7885C722B3);
+    address hodlVault_ = address(0x102Df50dB22407B64a8A6b11734c8743B6AeF953);
+    address potPool_ = address(0x877635e68C1E943D6d6B777C0e847Cd7aE5A01BE);
+
+    JarvisHodlStrategyV3.initializeBaseStrategy({
+    __storage: __storage,
+    _underlying: underlying_,
+    _vault: _vault,
+    _rewardPool: rewardPool_,
+    _rewardToken: rewardToken_,
+    _poolId: 2,
+    _rewardLp: rewardLp_,
+    _hodlVault: hodlVault_,
+    _potPool: potPool_
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisStrategyV3.sol

@@ -0,0 +1,281 @@
+//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/upgradability/BaseUpgradeableStrategy.sol";
+
+import "./interface/IElysianFields.sol";
+
+import "../../base/interface/IVault.sol";
+import "../../base/interface/IStrategy.sol";
+import "../../base/interface/kyber/IDMMRouter02.sol";
+import "../../base/interface/kyber/IDMMPool.sol";
+import "../../base/interface/kyber/IKyberZap.sol";
+
+contract JarvisStrategyV3 is  BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant kyberZapper = address(0x83D4908c1B4F9Ca423BEE264163BC1d50F251c31);
+  address public constant msig = address(0x39cC360806b385C96969ce9ff26c23476017F652);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _POOLID_SLOT = 0x3fd729bfa2e28b7806b03a6e014729f59477b530f995be4d51defc9dad94810b;
+  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(_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
+  ) public initializer {
+    require(_rewardPool != address(0), "reward pool is empty");
+
+    BaseUpgradeableStrategy.initialize({
+      _storage: __storage,
+      _underlying: _underlying,
+      _vault: _vault,
+      _rewardPool: _rewardPool,
+      _rewardToken: _rewardToken,
+      _profitSharingNumerator: 80,
+      _profitSharingDenominator: 1000,
+      _sell: true,
+      _sellFloor: 1e18,
+      _implementationChangeDelay: 12 hours}
+    );
+
+    address _lpt;
+    (_lpt,,,) = IElysianFields(_rewardPool).poolInfo(_poolId);
+
+    require(_lpt == _underlying, "Pool Info does not match underlying");
+
+    _setPoolId(_poolId);
+
+    address token0 = IDMMPool(_underlying).token0();
+    address token1 = IDMMPool(_underlying).token1();
+    require(token0 == _rewardToken || token1 == _rewardToken, "One of the underlying DMM pool token is not equal to the rewardToken");
+
+    // select the token that isn't the rewardToken, s.t.
+    address rewardLpToken1 = (token0 == _rewardToken) ? token1 : token0;
+    setRewardLpToken1(rewardLpToken1);
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  STORAGE SETTER AND GETTER
+  //////////////////////////////////////////////////////////////*/
+
+  function setRewardLpToken1(address _value) internal {
+    setAddress(_REWARD_LP_TOKEN1_SLOT, _value);
+  }
+
+  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);
+  }
+
+  /*///////////////////////////////////////////////////////////////
+                  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);
+  }
+
+  function _liquidateReward() 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();
+  }
+
+  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: underlying(), 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();
+    _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);
+      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);
+    _liquidateReward();
+    _investAllUnderlying();
+  }
+
+ function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+}

package/contracts/strategies/jarvis/JarvisStrategyV3Mainnet_AUR3_USDC.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisStrategyV3.sol";
+
+contract JarvisStrategyV3Mainnet_AUR3_USDC is JarvisStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xF40E249737c510CCE832286e54cB30E60D4e4656);
+    address rewardPool_ = address(0xFAA0f413E67A56cbbE181024279bA5504Ce487EF);
+    address rewardToken_ = address(0xBF06D9b11126B140788D842a6ed8dC7885C722B3);
+
+    JarvisStrategyV3.initializeBaseStrategy({
+      __storage: __storage,
+      _underlying: underlying_,
+      _vault: _vault,
+      _rewardPool: rewardPool_,
+      _rewardToken: rewardToken_,
+      _poolId: 3
+    });
+  }
+}

package/contracts/strategies/jarvis/JarvisStrategyV3Mainnet_AURJUL22_WETH.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./JarvisStrategyV3.sol";
+
+contract JarvisStrategyV3Mainnet_AURJUL22_WETH is JarvisStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address __storage,
+    address _vault
+  ) public initializer {
+    address underlying_ = address(0xF9Ce68A9E41f1e7cee5FDCbef99669653Aa61390);
+    address rewardPool_ = address(0x8b4D15670CaA3772a29AaC386AB924a0F54Abe48);
+    address rewardToken_ = address(0x8C56600D7D8f9239f124c7C52D3fa018fC801A76);
+
+    JarvisStrategyV3.initializeBaseStrategy({
+      __storage: __storage,
+      _underlying: underlying_,
+      _vault: _vault,
+      _rewardPool: rewardPool_,
+      _rewardToken: rewardToken_,
+      _poolId: 2
+    });
+  }
+}