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

package/contracts/base/upgradability/ReentrancyGuard.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.12;
+
+/**
+ * @dev Contract module that helps prevent reentrant calls to a function.
+ *
+ * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
+ * available, which can be applied to functions to make sure there are no nested
+ * (reentrant) calls to them.
+ *
+ * Note that because there is a single `nonReentrant` guard, functions marked as
+ * `nonReentrant` may not call one another. This can be worked around by making
+ * those functions `private`, and then adding `external` `nonReentrant` entry
+ * points to them.
+ *
+ * TIP: If you would like to learn more about reentrancy and alternative ways
+ * to protect against it, check out our blog post
+ * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
+ *
+ * _Since v2.5.0:_ this module is now much more gas efficient, given net gas
+ * metering changes introduced in the Istanbul hardfork.
+ */
+contract ReentrancyGuard {
+    bool private _notEntered;
+
+    constructor () internal {
+        // Storing an initial non-zero value makes deployment a bit more
+        // expensive, but in exchange the refund on every call to nonReentrant
+        // will be lower in amount. Since refunds are capped to a percetange of
+        // the total transaction's gas, it is best to keep them low in cases
+        // like this one, to increase the likelihood of the full refund coming
+        // into effect.
+        _notEntered = true;
+    }
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and make it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_notEntered, "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        _notEntered = false;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _notEntered = true;
+    }
+}

package/contracts/base/upgradability/ReentrancyGuardUpgradeable.sol

@@ -0,0 +1,51 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+
+/**
+ * Same old `ReentrancyGuard`, but can be used by upgradable contracts
+ */
+contract ReentrancyGuardUpgradeable is Initializable {
+
+    bytes32 internal constant _NOT_ENTERED_SLOT = 0x62ae7bf2df4e95c187ea09c8c47c3fc3d9abc36298f5b5b6c5e2e7b4b291fe25;
+
+    modifier nonReentrant() {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_getNotEntered(_NOT_ENTERED_SLOT), "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        _setNotEntered(_NOT_ENTERED_SLOT, false);
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _setNotEntered(_NOT_ENTERED_SLOT, true);
+    }
+
+    constructor() public {
+        assert(_NOT_ENTERED_SLOT == bytes32(uint256(keccak256("eip1967.reentrancyGuard.notEntered")) - 1));
+    }
+
+    function initialize() public initializer {
+        _setNotEntered(_NOT_ENTERED_SLOT, true);
+    }
+
+    function _getNotEntered(bytes32 slot) internal view returns (bool) {
+        uint str;
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            str := sload(slot)
+        }
+        return str == 1;
+    }
+
+    function _setNotEntered(bytes32 slot, bool _value) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, _value)
+        }
+    }
+
+}

package/contracts/base/upgradability/StrategyProxy.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "../inheritance/IUpgradeSource.sol";
+import "./BaseUpgradeabilityProxy.sol";
+
+contract StrategyProxy is BaseUpgradeabilityProxy {
+
+  constructor(address _implementation) public {
+    _setImplementation(_implementation);
+  }
+
+  /**
+  * The main logic. If the timer has elapsed and there is a schedule upgrade,
+  * the governance can upgrade the strategy
+  */
+  function upgrade() external {
+    (bool should, address newImplementation) = IUpgradeSource(address(this)).shouldUpgrade();
+    require(should, "Upgrade not scheduled");
+    _upgradeTo(newImplementation);
+
+    // the finalization needs to be executed on itself to update the storage of this proxy
+    // it also needs to be invoked by the governance, not by address(this), so delegatecall is needed
+    (bool success,) = address(this).delegatecall(
+      abi.encodeWithSignature("finalizeUpgrade()")
+    );
+
+    require(success, "Issue when finalizing the upgrade");
+  }
+
+  function implementation() external view returns (address) {
+    return _implementation();
+  }
+}

package/contracts/base/wmatic/WMATIC.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface WMATIC {
+    function deposit() external payable;
+    function withdraw(uint wad) external;
+    function transfer(address dts, uint wad) external payable;
+}

package/contracts/strategies/aave/AaveSupplyStrategy.sol

@@ -0,0 +1,213 @@
+// 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/aave/IAToken.sol";
+import "../../base/interface/aave/IPool.sol";
+
+contract AaveSupplyStrategy 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 _ATOKEN_SLOT = 0x8cdee58637b787efaa2d78bb1da1e053a2c91e61640b32339bfbba65c00abd68;
+  bytes32 internal constant _STORED_SUPPLIED_SLOT = 0x280539da846b4989609abdccfea039bd1453e4f710c670b29b9eeaca0730c1a2;
+  bytes32 internal constant _PENDING_FEE_SLOT = 0x0af7af9f5ccfa82c3497f40c7c382677637aee27293a6243a22216b51481bd97;
+
+  constructor() public BaseUpgradeableStrategyV2() {
+    assert(_ATOKEN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.aToken")) - 1));
+    assert(_STORED_SUPPLIED_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.storedSupplied")) - 1));
+    assert(_PENDING_FEE_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.pendingFee")) - 1));
+  }
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _aToken
+  )
+  public initializer {
+    BaseUpgradeableStrategyV2.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      _aToken,
+      _underlying,
+      harvestMSIG
+    );
+
+    require(IAToken(_aToken).UNDERLYING_ASSET_ADDRESS() == _underlying, "Underlying mismatch");
+    _setAToken(_aToken);
+  }
+
+  function currentSupplied() public view returns (uint256) {
+    return IAToken(aToken()).balanceOf(address(this));
+  }
+
+  function storedSupplied() public view returns (uint256) {
+    return getUint256(_STORED_SUPPLIED_SLOT);
+  }
+
+  function _updateStoredSupplied() internal {
+    setUint256(_STORED_SUPPLIED_SLOT, currentSupplied());
+  }
+
+  function totalFeeNumerator() public view returns (uint256) {
+    return strategistFeeNumerator().add(platformFeeNumerator()).add(profitSharingNumerator());
+  }
+
+  function pendingFee() public view returns (uint256) {
+    return getUint256(_PENDING_FEE_SLOT);
+  }
+
+  function _accrueFee() internal {
+    uint256 fee;
+    if (currentSupplied() > storedSupplied()) {
+      uint256 balanceIncrease = currentSupplied().sub(storedSupplied());
+      fee = balanceIncrease.mul(totalFeeNumerator()).div(feeDenominator());
+    }
+    setUint256(_PENDING_FEE_SLOT, pendingFee().add(fee));
+    _updateStoredSupplied();
+  }
+
+  function _handleFee() internal {
+    _accrueFee();
+    uint256 fee = pendingFee();
+    if (fee > 100) {
+      uint256 balanceIncrease = fee.mul(feeDenominator()).div(totalFeeNumerator());
+      _redeem(fee);
+      address _underlying = underlying();
+      if (IERC20(_underlying).balanceOf(address(this)) < fee) {
+        balanceIncrease = IERC20(_underlying).balanceOf(address(this)).mul(feeDenominator()).div(totalFeeNumerator());
+      }
+      _notifyProfitInRewardToken(_underlying, balanceIncrease);
+      setUint256(_PENDING_FEE_SLOT, 0);
+    }
+  }
+  
+  function depositArbCheck() public pure returns (bool) {
+    // there's no arb here.
+    return true;
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == underlying() || token == aToken());
+  }
+
+  /**
+  * Exits Moonwell and transfers everything to the vault.
+  */
+  function withdrawAllToVault() public restricted {
+    address _underlying = underlying();
+    _handleFee();
+    _redeemMaximum();
+    if (IERC20(_underlying).balanceOf(address(this)) > 0) {
+      IERC20(_underlying).safeTransfer(vault(), IERC20(_underlying).balanceOf(address(this)));
+    }
+    _updateStoredSupplied();
+  }
+
+  function emergencyExit() external onlyGovernance {
+    _accrueFee();
+    _redeemMaximum();
+    _updateStoredSupplied();
+  }
+
+  function withdrawToVault(uint256 amountUnderlying) public restricted {
+    _accrueFee();
+    address _underlying = underlying();
+    uint256 balance = IERC20(_underlying).balanceOf(address(this));
+    if (amountUnderlying <= balance) {
+      IERC20(_underlying).safeTransfer(vault(), amountUnderlying);
+      return;
+    }
+    uint256 toRedeem = amountUnderlying.sub(balance);
+    // get some of the underlying
+    _redeem(toRedeem);
+    // transfer the amount requested (or the amount we have) back to vault()
+    IERC20(_underlying).safeTransfer(vault(), amountUnderlying);
+    balance = IERC20(_underlying).balanceOf(address(this));
+    if (balance > 0) {
+      _supply(balance);
+    }
+    _updateStoredSupplied();
+  }
+
+  /**
+  * Withdraws all assets, liquidates XVS, and invests again in the required ratio.
+  */
+  function doHardWork() public restricted {
+    _handleFee();
+    _supply(IERC20(underlying()).balanceOf(address(this)));
+    _updateStoredSupplied();
+  }
+
+  /**
+  * Salvages a token.
+  */
+  function salvage(address recipient, address token, uint256 amount) public onlyGovernance {
+    // 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);
+  }
+
+  /**
+  * Returns the current balance.
+  */
+  function investedUnderlyingBalance() public view returns (uint256) {
+    // underlying in this strategy + underlying redeemable from Radiant - debt
+    return IERC20(underlying()).balanceOf(address(this))
+    .add(storedSupplied())
+    .sub(pendingFee());
+  }
+
+  /**
+  * Supplies to Moonwel
+  */
+  function _supply(uint256 amount) internal {
+    if (amount == 0){
+      return;
+    }
+    address _underlying = underlying();
+    address _pool = IAToken(aToken()).POOL();
+    IERC20(_underlying).safeApprove(_pool, 0);
+    IERC20(_underlying).safeApprove(_pool, amount);
+    IPool(_pool).supply(_underlying, amount, address(this), 0);
+  }
+
+  function _redeem(uint256 amountUnderlying) internal {
+    if (amountUnderlying == 0){
+      return;
+    }
+    address _pool = IAToken(aToken()).POOL();
+    IPool(_pool).withdraw(underlying(), amountUnderlying, address(this));
+  }
+
+  function _redeemMaximum() internal {
+    if (currentSupplied() > 0) {
+      _redeem(currentSupplied().sub(pendingFee().add(1)));
+    }
+  }
+
+  function _setAToken (address _target) internal {
+    setAddress(_ATOKEN_SLOT, _target);
+  }
+
+  function aToken() public view returns (address) {
+    return getAddress(_ATOKEN_SLOT);
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+
+  receive() external payable {}
+}

package/contracts/strategies/aave/AaveSupplyStrategyMainnet_DAI.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./AaveSupplyStrategy.sol";
+
+contract AaveSupplyStrategyMainnet_DAI is AaveSupplyStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+    address aToken = address(0x82E64f49Ed5EC1bC6e43DAD4FC8Af9bb3A2312EE);
+    AaveSupplyStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      aToken
+    );
+  }
+}

package/contracts/strategies/aave/AaveSupplyStrategyMainnet_EURS.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./AaveSupplyStrategy.sol";
+
+contract AaveSupplyStrategyMainnet_EURS is AaveSupplyStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xE111178A87A3BFf0c8d18DECBa5798827539Ae99);
+    address aToken = address(0x38d693cE1dF5AaDF7bC62595A37D667aD57922e5);
+    AaveSupplyStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      aToken
+    );
+  }
+}

package/contracts/strategies/aave/AaveSupplyStrategyMainnet_USDC.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./AaveSupplyStrategy.sol";
+
+contract AaveSupplyStrategyMainnet_USDC is AaveSupplyStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359);
+    address aToken = address(0xA4D94019934D8333Ef880ABFFbF2FDd611C762BD);
+    AaveSupplyStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      aToken
+    );
+  }
+}

package/contracts/strategies/aave/AaveSupplyStrategyMainnet_USDCe.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./AaveSupplyStrategy.sol";
+
+contract AaveSupplyStrategyMainnet_USDCe is AaveSupplyStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174);
+    address aToken = address(0x625E7708f30cA75bfd92586e17077590C60eb4cD);
+    AaveSupplyStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      aToken
+    );
+  }
+}

package/contracts/strategies/aave/AaveSupplyStrategyMainnet_USDT.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./AaveSupplyStrategy.sol";
+
+contract AaveSupplyStrategyMainnet_USDT is AaveSupplyStrategy {
+
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+    address underlying = address(0xc2132D05D31c914a87C6611C10748AEb04B58e8F);
+    address aToken = address(0x6ab707Aca953eDAeFBc4fD23bA73294241490620);
+    AaveSupplyStrategy.initializeBaseStrategy(
+      _storage,
+      underlying,
+      _vault,
+      aToken
+    );
+  }
+}

package/contracts/strategies/ape/ApeStrategyMainnet_BANANA_MATIC.sol

@@ -0,0 +1,36 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/interface/IVault.sol";
+import "../../base/ape-base/MiniApeV2Strategy.sol";
+
+contract ApeStrategyMainnet_BANANA_MATIC is MiniApeV2Strategy {
+
+  address constant public weth = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+  address constant public banana = address(0x5d47bAbA0d66083C52009271faF3F50DCc01023C);
+  address constant public banana_matic = address(0x034293F21F1cCE5908BC605CE5850dF2b1059aC0);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public miniApe = address(0x54aff400858Dcac39797a81894D9920f16972D1D);
+  
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+
+    MiniApeV2Strategy.initializeBaseStrategy(
+      _storage, 
+      banana_matic, 
+      _vault, 
+      miniApe, 
+      banana, 
+      0
+    );
+
+    require(IVault(_vault).underlying() == banana_matic, "Underlying mismatch");
+    
+    uniswapRoutes[wmatic] = [banana, wmatic];
+    uniswapRoutes[weth] = [banana, wmatic, weth];
+  }
+}

package/contracts/strategies/ape/ApeStrategyMainnet_BNB_MATIC.sol

@@ -0,0 +1,36 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/interface/IVault.sol";
+import "../../base/ape-base/MiniApeV2Strategy.sol";
+
+contract ApeStrategyMainnet_BNB_MATIC is MiniApeV2Strategy {
+
+  address constant public bnb = address(0xA649325Aa7C5093d12D6F98EB4378deAe68CE23F);
+  address constant public banana = address(0x5d47bAbA0d66083C52009271faF3F50DCc01023C);
+  address constant public bnb_matic = address(0x0359001070cF696D5993E0697335157a6f7dB289);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public miniApe = address(0x54aff400858Dcac39797a81894D9920f16972D1D);
+  
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+
+    MiniApeV2Strategy.initializeBaseStrategy(
+      _storage, 
+      bnb_matic, 
+      _vault, 
+      miniApe, 
+      banana, 
+      6
+    );
+
+    require(IVault(_vault).underlying() == bnb_matic, "Underlying mismatch");
+    
+    uniswapRoutes[bnb] = [banana, wmatic, bnb];
+    uniswapRoutes[wmatic] = [banana, wmatic];
+  }
+}

package/contracts/strategies/ape/ApeStrategyMainnet_BTC_MATIC.sol

@@ -0,0 +1,36 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/interface/IVault.sol";
+import "../../base/ape-base/MiniApeV2Strategy.sol";
+
+contract ApeStrategyMainnet_BTC_MATIC is MiniApeV2Strategy {
+
+  address constant public wbtc = address(0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6);
+  address constant public banana = address(0x5d47bAbA0d66083C52009271faF3F50DCc01023C);
+  address constant public btc_matic = address(0xe82635a105c520fd58e597181cBf754961d51E3e);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public miniApe = address(0x54aff400858Dcac39797a81894D9920f16972D1D);
+  
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+
+    MiniApeV2Strategy.initializeBaseStrategy(
+      _storage, 
+      btc_matic, 
+      _vault, 
+      miniApe, 
+      banana, 
+      4
+    );
+
+    require(IVault(_vault).underlying() == btc_matic, "Underlying mismatch");
+    
+    uniswapRoutes[wmatic] = [banana, wmatic];
+    uniswapRoutes[wbtc] = [banana, wmatic, wbtc];
+  }
+}

package/contracts/strategies/ape/ApeStrategyMainnet_DAI_MATIC.sol

@@ -0,0 +1,36 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/interface/IVault.sol";
+import "../../base/ape-base/MiniApeV2Strategy.sol";
+
+contract ApeStrategyMainnet_DAI_MATIC is MiniApeV2Strategy {
+
+  address constant public dai = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+  address constant public banana = address(0x5d47bAbA0d66083C52009271faF3F50DCc01023C);
+  address constant public dai_matic = address(0xd32f3139A214034A0f9777c87eE0a064c1FF6AE2);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public miniApe = address(0x54aff400858Dcac39797a81894D9920f16972D1D);
+  
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+
+    MiniApeV2Strategy.initializeBaseStrategy(
+      _storage, 
+      dai_matic, 
+      _vault, 
+      miniApe, 
+      banana, 
+      2
+    );
+
+    require(IVault(_vault).underlying() == dai_matic, "Underlying mismatch");
+    
+    uniswapRoutes[wmatic] = [banana, wmatic];
+    uniswapRoutes[dai] = [banana, wmatic, dai];
+  }
+}

package/contracts/strategies/ape/ApeStrategyMainnet_DAI_USDC.sol

@@ -0,0 +1,37 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../../base/interface/IVault.sol";
+import "../../base/ape-base/MiniApeV2Strategy.sol";
+
+contract ApeStrategyMainnet_DAI_USDC is MiniApeV2Strategy {
+
+  address constant public dai = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
+  address constant public usdc = address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174);
+  address constant public banana = address(0x5d47bAbA0d66083C52009271faF3F50DCc01023C);
+  address constant public dai_usdc = address(0x5b13B583D4317aB15186Ed660A1E4C65C10da659);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public miniApe = address(0x54aff400858Dcac39797a81894D9920f16972D1D);
+  
+  constructor() public {}
+
+  function initializeStrategy(
+    address _storage,
+    address _vault
+  ) public initializer {
+
+    MiniApeV2Strategy.initializeBaseStrategy(
+      _storage, 
+      dai_usdc, 
+      _vault, 
+      miniApe, 
+      banana, 
+      5
+    );
+
+    require(IVault(_vault).underlying() == dai_usdc, "Underlying mismatch");
+    
+    uniswapRoutes[dai] = [banana, wmatic, dai];
+    uniswapRoutes[usdc] = [banana, wmatic, dai, usdc];
+  }
+}