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

package/contracts/strategies/balancer/BalancerStrategyV3.sol

@@ -0,0 +1,509 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "@openzeppelin/contracts/math/Math.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "../../base/interface/uniswap/IUniswapV2Router02.sol";
+import "../../base/interface/IVault.sol";
+import "../../base/upgradability/BaseUpgradeableStrategy.sol";
+import "../../base/interface/uniswap/IUniswapV2Pair.sol";
+import "./interface/IBVault.sol";
+import "./interface/IBalanceMinter.sol";
+import "./interface/Gauge.sol";
+
+contract BalancerStrategyV3 is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  address public constant weth = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+  address public constant quickswapRouterV2 = address(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);
+
+  // additional storage slots (on top of BaseUpgradeableStrategy ones) are defined here
+  bytes32 internal constant _POOLID_SLOT = 0x3fd729bfa2e28b7806b03a6e014729f59477b530f995be4d51defc9dad94810b;
+  bytes32 internal constant _BVAULT_SLOT = 0x85cbd475ba105ca98d9a2db62dcf7cf3c0074b36303ef64160d68a3e0fdd3c67;
+  bytes32 internal constant _DEPOSIT_TOKEN_SLOT = 0x219270253dbc530471c88a9e7c321b36afda219583431e7b6c386d2d46e70c86;
+  bytes32 internal constant _BOOSTED_POOL = 0xd816e748a078d825fa9cc9dc9335909f9baa20dc1b5619211972fc7e672bd2fb;
+
+  // this would be reset on each upgrade
+  address[] public WETH2deposit;
+  mapping(address => address[]) public reward2WETH;
+  mapping(address => mapping(address => bytes32)) public poolIds;
+  address[] public rewardTokens;
+  mapping(address => mapping(address => bool)) public deposit;
+
+  constructor() public BaseUpgradeableStrategy() {
+    assert(_POOLID_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.poolId")) - 1));
+    assert(_BVAULT_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.bVault")) - 1));
+    assert(_DEPOSIT_TOKEN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.depositToken")) - 1));
+    assert(_BOOSTED_POOL == bytes32(uint256(keccak256("eip1967.strategyStorage.boostedPool")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _bVault,
+    bytes32 _poolID,
+    address _depositToken,
+    bool _boosted
+  ) public initializer {
+
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _rewardPool,
+      weth,
+      80, // profit sharing numerator
+      1000, // profit sharing denominator
+      true, // sell
+      0, // sell floor
+      12 hours // implementation change delay
+    );
+
+    (address _lpt,) = IBVault(_bVault).getPool(_poolID);
+    require(_lpt == _underlying, "Underlying mismatch");
+
+    _setPoolId(_poolID);
+    _setBVault(_bVault);
+    _setDepositToken(_depositToken);
+    _setBoostedPool(_boosted);
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function _rewardPoolBalance() internal view returns (uint256 balance) {
+      balance = Gauge(rewardPool()).balanceOf(address(this));
+  }
+
+  function _emergencyExitRewardPool() internal {
+    uint256 stakedBalance = _rewardPoolBalance();
+    if (stakedBalance != 0) {
+        _withdrawUnderlyingFromPool(stakedBalance);
+    }
+  }
+
+  function _withdrawUnderlyingFromPool(uint256 amount) internal {
+    address rewardPool_ = rewardPool();
+    Gauge(rewardPool_).withdraw(
+      Math.min(Gauge(rewardPool_).balanceOf(address(this)), amount)
+    );
+  }
+
+  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);
+    Gauge(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 setDepositLiquidationPath(address [] memory _route) public onlyGovernance {
+    require(_route[0] == weth, "Path should start with WETH");
+    require(_route[_route.length-1] == depositToken(), "Path should end with depositToken");
+    WETH2deposit = _route;
+  }
+
+  function setRewardLiquidationPath(address [] memory _route) public onlyGovernance {
+    require(_route[_route.length-1] == weth, "Path should end with WETH");
+    bool isReward = false;
+    for(uint256 i = 0; i < rewardTokens.length; i++){
+      if (_route[0] == rewardTokens[i]) {
+        isReward = true;
+      }
+    }
+    require(isReward, "Path should start with a rewardToken");
+    reward2WETH[_route[0]] = _route;
+  }
+
+  function addRewardToken(address _token, address[] memory _path2WETH) public onlyGovernance {
+    rewardTokens.push(_token);
+    setRewardLiquidationPath(_path2WETH);
+  }
+
+  function changeDepositToken(address _depositToken, address[] memory _liquidationPath) public onlyGovernance {
+    _setDepositToken(_depositToken);
+    setDepositLiquidationPath(_liquidationPath);
+  }
+
+  function setBalancerSwapPoolId(address _sellToken, address _buyToken, bytes32 _poolId) public onlyGovernance {
+    poolIds[_sellToken][_buyToken] = _poolId;
+  }
+
+  function _approveIfNeed(address token, address spender, uint256 amount) internal {
+    uint256 allowance = IERC20(token).allowance(address(this), spender);
+    if (amount > allowance) {
+      IERC20(token).safeApprove(spender, 0);
+      IERC20(token).safeApprove(spender, amount);
+    }
+  }
+
+  function _quickSwap(
+    address sellToken,
+    address buyToken,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    address[] memory path = new address[](2);
+    path[0] = sellToken;
+    path[1] = buyToken;
+    IERC20(sellToken).safeApprove(quickswapRouterV2, 0);
+    IERC20(sellToken).safeApprove(quickswapRouterV2, amountIn);
+    // we can accept 1 as the minimum because this will be called only by a trusted worker
+    IUniswapV2Router02(quickswapRouterV2).swapExactTokensForTokens(
+      amountIn, minAmountOut, path, address(this), block.timestamp
+    );
+  }
+
+  function _balancerSwap(
+    address sellToken,
+    address buyToken,
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    address _bVault = bVault();
+    IBVault.SingleSwap memory singleSwap;
+    IBVault.SwapKind swapKind = IBVault.SwapKind.GIVEN_IN;
+
+    singleSwap.poolId = poolId;
+    singleSwap.kind = swapKind;
+    singleSwap.assetIn = IAsset(sellToken);
+    singleSwap.assetOut = IAsset(buyToken);
+    singleSwap.amount = amountIn;
+    singleSwap.userData = abi.encode(0);
+
+    IBVault.FundManagement memory funds;
+    funds.sender = address(this);
+    funds.fromInternalBalance = false;
+    funds.recipient = payable(address(this));
+    funds.toInternalBalance = false;
+
+    _approveIfNeed(sellToken, _bVault, amountIn);
+    IBVault(_bVault).swap(singleSwap, funds, minAmountOut, block.timestamp);
+  }
+
+  function _balancerDeposit(
+    address tokenIn,
+    bytes32 poolId,
+    uint256 amountIn,
+    uint256 minAmountOut
+  ) internal {
+    address _bVault = bVault();
+    (address[] memory poolTokens,,) = IBVault(_bVault).getPoolTokens(poolId);
+    uint256 _nTokens = poolTokens.length;
+
+    IAsset[] memory assets = new IAsset[](_nTokens);
+    for (uint256 i = 0; i < _nTokens; i++) {
+      assets[i] = IAsset(poolTokens[i]);
+    }
+
+    IBVault.JoinKind joinKind = IBVault.JoinKind.EXACT_TOKENS_IN_FOR_BPT_OUT;
+
+    uint256[] memory amountsIn = new uint256[](_nTokens);
+    for (uint256 j = 0; j < amountsIn.length; j++) {
+      amountsIn[j] = address(assets[j]) == tokenIn ? amountIn : 0;
+    }
+
+    bytes memory userData = abi.encode(joinKind, amountsIn, minAmountOut);
+
+    IBVault.JoinPoolRequest memory request;
+    request.assets = assets;
+    request.maxAmountsIn = amountsIn;
+    request.userData = userData;
+    request.fromInternalBalance = false;
+
+    _approveIfNeed(tokenIn, _bVault, amountIn);
+    IBVault(_bVault).joinPool(
+      poolId,
+      address(this),
+      address(this),
+      request
+    );
+  }
+
+  function _liquidateReward() internal {
+    if (!sell()) {
+      // Profits can be disabled for possible simplified and rapid exit
+      emit ProfitsNotCollected(sell(), false);
+      return;
+    }
+
+    for(uint256 i = 0; i < rewardTokens.length; i++){
+      address token = rewardTokens[i];
+      uint256 rewardBalance = IERC20(token).balanceOf(address(this));
+
+      if (rewardBalance == 0) {
+        continue;
+      }
+      if (reward2WETH[token].length < 2) {
+        continue;
+      }
+      for (uint256 j = 0; j < reward2WETH[token].length - 1; j++) {
+        address sellToken = reward2WETH[token][j];
+        address buyToken = reward2WETH[token][j+1];
+        uint256 sellTokenBalance = IERC20(sellToken).balanceOf(address(this));
+        if (poolIds[sellToken][buyToken] == bytes32(0)) {
+          _quickSwap(sellToken, buyToken, sellTokenBalance, 1);
+        } else {
+          if (deposit[sellToken][buyToken]) {
+            _balancerDeposit(
+              sellToken,
+              poolIds[sellToken][buyToken],
+              sellTokenBalance,
+              1
+            );
+          } else {
+            _balancerSwap(
+              sellToken,
+              buyToken,
+              poolIds[sellToken][buyToken],
+              sellTokenBalance,
+              1
+            );
+          }
+        }
+      }
+    }
+
+    address _rewardToken = rewardToken();
+    uint256 rewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+    notifyProfitInRewardToken(rewardBalance);
+    uint256 remainingRewardBalance = IERC20(_rewardToken).balanceOf(address(this));
+
+    if (remainingRewardBalance == 0) {
+      return;
+    }
+
+    if (WETH2deposit.length > 1) { //else we assume WETH is the deposit token, no need to swap
+      for(uint256 i = 0; i < WETH2deposit.length - 1; i++){
+        address sellToken = WETH2deposit[i];
+        address buyToken = WETH2deposit[i+1];
+        uint256 sellTokenBalance = IERC20(sellToken).balanceOf(address(this));
+        if (poolIds[sellToken][buyToken] == bytes32(0)) {
+          _quickSwap(sellToken, buyToken, sellTokenBalance, 1);
+        } else {
+          if (deposit[sellToken][buyToken]) {
+            _balancerDeposit(
+              sellToken,
+              poolIds[sellToken][buyToken],
+              sellTokenBalance,
+              1
+            );
+          } else {
+            _balancerSwap(
+              sellToken,
+              buyToken,
+              poolIds[sellToken][buyToken],
+              sellTokenBalance,
+              1
+            );
+          }
+        }
+      }
+    }
+
+    address _depositToken = depositToken();
+    uint256 tokenBalance = IERC20(depositToken()).balanceOf(address(this));
+    if (tokenBalance > 0 && !(_depositToken == underlying())) {
+      depositLP();
+    }
+  }
+
+  function depositLP() internal {
+    address _depositToken = depositToken();
+    bytes32 _poolId = poolId();
+    uint256 depositTokenBalance = IERC20(_depositToken).balanceOf(address(this));
+
+    if (boostedPool()) {
+      _balancerSwap(
+        _depositToken,
+        underlying(),
+        _poolId,
+        depositTokenBalance,
+        1
+      );
+    } else {
+      _balancerDeposit(
+        _depositToken,
+        _poolId,
+        depositTokenBalance,
+        1
+      );
+    }
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() public restricted {
+    _withdrawUnderlyingFromPool(_rewardPoolBalance());
+    _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 {
+    address _rewardPool = rewardPool();
+    IBalancerMinter(Gauge(_rewardPool).bal_pseudo_minter()).mint(_rewardPool);
+    Gauge(_rewardPool).claim_rewards();
+    _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);
+  }
+
+  /**
+  * Sets the minimum amount of CRV needed to trigger a sale.
+  */
+  function setSellFloor(uint256 floor) public onlyGovernance {
+    _setSellFloor(floor);
+  }
+
+  // masterchef rewards pool ID
+  function _setPoolId(bytes32 _value) internal {
+    setBytes32(_POOLID_SLOT, _value);
+  }
+
+  function poolId() public view returns (bytes32) {
+    return getBytes32(_POOLID_SLOT);
+  }
+
+  function _setBVault(address _address) internal {
+    setAddress(_BVAULT_SLOT, _address);
+  }
+
+  function bVault() public view returns (address) {
+    return getAddress(_BVAULT_SLOT);
+  }
+
+  function _setDepositToken(address _address) internal {
+    setAddress(_DEPOSIT_TOKEN_SLOT, _address);
+  }
+
+  function depositToken() public view returns (address) {
+    return getAddress(_DEPOSIT_TOKEN_SLOT);
+  }
+
+  function _setBoostedPool(bool _boosted) internal {
+    setBoolean(_BOOSTED_POOL, _boosted);
+  }
+
+  function boostedPool() public view returns (bool) {
+    return getBoolean(_BOOSTED_POOL);
+  }
+
+  function setBytes32(bytes32 slot, bytes32 _value) internal {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _value)
+    }
+  }
+
+  function getBytes32(bytes32 slot) internal view returns (bytes32 str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+
+  receive() external payable {} // this is needed for the receiving Matic
+}

package/contracts/strategies/balancer/BalancerStrategyV3Mainnet_2BRL.sol

@@ -0,0 +1,39 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./BalancerStrategyV3.sol";
+
+contract BalancerStrategyV3Mainnet_2BRL is BalancerStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xE22483774bd8611bE2Ad2F4194078DaC9159F4bA);
+    address bbamusd = address(0x48e6B98ef6329f8f0A30eBB8c7C960330d648085);
+    address bal = address(0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3);
+    address bbamdai = address(0x178E029173417b1F9C8bC16DCeC6f697bC323746);
+    address dai = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+    address gauge = address(0xbDb8DA6156722a3D583ee679988B35cacCd86BC3);
+    BalancerStrategyV3.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      address(0xBA12222222228d8Ba445958a75a0704d566BF2C8), //balancer vault
+      0xe22483774bd8611be2ad2f4194078dac9159f4ba0000000000000000000008f0,  // Pool id
+      underlying,   //depositToken
+      true      //boosted
+    );
+    rewardTokens = [bal];
+    reward2WETH[bal] = [bal, weth];
+    WETH2deposit = [weth, dai, bbamdai, bbamusd, underlying];
+    poolIds[bal][weth] = 0x3d468ab2329f296e1b9d8476bb54dd77d8c2320f000200000000000000000426;
+    poolIds[dai][bbamdai] = 0x178e029173417b1f9c8bc16dcec6f697bc323746000000000000000000000758;
+    poolIds[bbamdai][bbamusd] = 0x48e6b98ef6329f8f0a30ebb8c7c960330d64808500000000000000000000075b;
+    poolIds[bbamusd][underlying] = 0x4a0b73f0d13ff6d43e304a174697e3d5cfd310a400020000000000000000091c;
+  }
+}

package/contracts/strategies/balancer/BalancerStrategyV3Mainnet_2BRLUSD.sol

@@ -0,0 +1,38 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./BalancerStrategyV3.sol";
+
+contract BalancerStrategyV3Mainnet_2BRLUSD is BalancerStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x4A0b73f0D13fF6d43e304a174697e3d5CFd310a4);
+    address bbamusd = address(0x48e6B98ef6329f8f0A30eBB8c7C960330d648085);
+    address bal = address(0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3);
+    address bbamdai = address(0x178E029173417b1F9C8bC16DCeC6f697bC323746);
+    address dai = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+    address gauge = address(0x75108A554A34BB2846ABfb00D889BFD0Bb34E1d6);
+    BalancerStrategyV3.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      address(0xBA12222222228d8Ba445958a75a0704d566BF2C8), //balancer vault
+      0x4a0b73f0d13ff6d43e304a174697e3d5cfd310a400020000000000000000091c,  // Pool id
+      bbamusd,   //depositToken
+      false      //boosted
+    );
+    rewardTokens = [bal];
+    reward2WETH[bal] = [bal, weth];
+    WETH2deposit = [weth, dai, bbamdai, bbamusd];
+    poolIds[bal][weth] = 0x3d468ab2329f296e1b9d8476bb54dd77d8c2320f000200000000000000000426;
+    poolIds[dai][bbamdai] = 0x178e029173417b1f9c8bc16dcec6f697bc323746000000000000000000000758;
+    poolIds[bbamdai][bbamusd] = 0x48e6b98ef6329f8f0a30ebb8c7c960330d64808500000000000000000000075b;
+  }
+}

package/contracts/strategies/balancer/BalancerStrategyV3Mainnet_2EUR_PAR.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./BalancerStrategyV3.sol";
+
+contract BalancerStrategyV3Mainnet_2EUR_PAR is BalancerStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x7d60a4Cb5cA92E2Da965637025122296ea6854f9);
+    address jeur = address(0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c);
+    address bal = address(0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3);
+    address gauge = address(0xD14875e2C65A46d15501C9296A9bCC0E17510978);
+    BalancerStrategyV3.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      address(0xBA12222222228d8Ba445958a75a0704d566BF2C8), //balancer vault
+      0x7d60a4cb5ca92e2da965637025122296ea6854f900000000000000000000085e,  // Pool id
+      jeur,   //depositToken
+      true      //boosted
+    );
+    rewardTokens = [bal];
+    reward2WETH[bal] = [bal, weth];
+    WETH2deposit = [weth, jeur];
+    poolIds[bal][weth] = 0x3d468ab2329f296e1b9d8476bb54dd77d8c2320f000200000000000000000426;
+  }
+}

package/contracts/strategies/balancer/BalancerStrategyV3Mainnet_2EUR_PARv2.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./BalancerStrategyV3.sol";
+
+contract BalancerStrategyV3Mainnet_2EUR_PARv2 is BalancerStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x513CdEE00251F39DE280d9E5f771A6eaFebCc88E);
+    address jeur = address(0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c);
+    address bal = address(0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3);
+    address gauge = address(0x5c13C3b72b031b6405046C319B2D840d3C1403c7);
+    BalancerStrategyV3.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      address(0xBA12222222228d8Ba445958a75a0704d566BF2C8), //balancer vault
+      0x513cdee00251f39de280d9e5f771a6eafebcc88e000000000000000000000a6b,  // Pool id
+      jeur,   //depositToken
+      true      //boosted
+    );
+    rewardTokens = [bal];
+    reward2WETH[bal] = [bal, weth];
+    WETH2deposit = [weth, jeur];
+    poolIds[bal][weth] = 0x3d468ab2329f296e1b9d8476bb54dd77d8c2320f000200000000000000000426;
+  }
+}

package/contracts/strategies/balancer/BalancerStrategyV3Mainnet_2EUR_agEUR.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./BalancerStrategyV3.sol";
+
+contract BalancerStrategyV3Mainnet_2EUR_agEUR is BalancerStrategyV3 {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xa48D164F6eB0EDC68bd03B56fa59E12F24499aD1);
+    address jeur = address(0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c);
+    address bal = address(0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3);
+    address gauge = address(0x8c73C7A998F54e3A936885C752c9955c78A5Febb);
+    BalancerStrategyV3.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      gauge,
+      address(0xBA12222222228d8Ba445958a75a0704d566BF2C8), //balancer vault
+      0xa48d164f6eb0edc68bd03b56fa59e12f24499ad10000000000000000000007c4,  // Pool id
+      jeur,   //depositToken
+      true      //boosted
+    );
+    rewardTokens = [bal];
+    reward2WETH[bal] = [bal, weth];
+    WETH2deposit = [weth, jeur];
+    poolIds[bal][weth] = 0x3d468ab2329f296e1b9d8476bb54dd77d8c2320f000200000000000000000426;
+  }
+}