Yak strategy v3

contracts/helpers/PairHelper.sol

@@ -1,32 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.13;
-pragma experimental ABIEncoderV2;
 
-interface IPair {
-    function symbol() external view returns (string memory);
-
-    function decimals() external view returns (uint8);
-
-    function totalSupply() external view returns (uint256);
-
-    function token0() external view returns (address);
-
-    function token1() external view returns (address);
-
-    function getReserves()
-        external
-        view
-        returns (
-            uint112 reserve0,
-            uint112 reserve1,
-            uint32 blockTimestampLast
-        );
-}
+import "./interfaces/IPair.sol";
+import "./interfaces/IOracleVault.sol";
 
 contract PairHelper {
     struct PairInfo {
         string symbol;
         uint256 totalSupply;
+        uint8 decimals;
         address token0;
         address token1;
         string token0Symbol;
@@ -44,6 +26,7 @@ contract PairHelper {
         PairInfo memory info;
         info.symbol = pair.symbol();
         info.totalSupply = pair.totalSupply();
+        info.decimals = pair.decimals();
         info.token0 = pair.token0();
         info.token1 = pair.token1();
 
@@ -58,4 +41,25 @@ contract PairHelper {
         info.reserve1 = reserve1;
         return info;
     }
+
+    function oracleVaultInfo(address pairAddress) public view returns (PairInfo memory) {
+        IOracleVault pair = IOracleVault(pairAddress);
+        PairInfo memory info;
+        info.symbol = pair.symbol();
+        info.totalSupply = pair.totalSupply();
+        info.decimals = pair.decimals();
+        info.token0 = pair.getTokenX();
+        info.token1 = pair.getTokenY();
+
+        info.token0Symbol = IPair(info.token0).symbol();
+        info.token1Symbol = IPair(info.token1).symbol();
+
+        info.token0Decimals = IPair(info.token0).decimals();
+        info.token1Decimals = IPair(info.token1).decimals();
+
+        (uint256 amountX, uint256 amountY) = pair.getBalances();
+        info.reserve0 = amountX;
+        info.reserve1 = amountY;
+        return info;
+    }
 }

contracts/helpers/ZapForSimpleRouter.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.13;
+
+import "../lib/Ownable.sol";
+import "../lib/SafeERC20.sol";
+import "./../interfaces/ISimpleRouter.sol";
+import "./../interfaces/IYakStrategy.sol";
+
+contract ZapForSimpleRouter is Ownable {
+    using SafeERC20 for IERC20;
+
+    address public immutable simpleRouter;
+
+    event Recovered(address token, uint256 amount);
+
+    constructor(
+        address _simpleRouter
+    ) {
+        simpleRouter = _simpleRouter;
+    }
+
+    function _swap(address _tokenIn, uint256 _amountIn, address _tokenOut, uint256 _minAmountOut) internal returns (uint256) {
+        IERC20(_tokenIn).approve(simpleRouter, _amountIn);
+        FormattedOffer memory trade = ISimpleRouter(simpleRouter).query(_amountIn, _tokenIn, _tokenOut);
+        uint256 amountOut = ISimpleRouter(simpleRouter).swap(trade);
+        require(amountOut > _minAmountOut, "ZapForSimpleRouter::amountOut too low");
+        return amountOut;
+    }
+
+    function swap(address _tokenIn, uint256 _amountIn, address _tokenOut, uint256 _minAmountOut) external returns (uint256) {
+        return _swap(_tokenIn, _amountIn, _tokenOut, _minAmountOut);
+    }
+
+    function zapIn(address _strategy, address _tokenIn, uint256 _amountIn, uint256 _minAmountOut) external {
+        // Swap
+        address depositToken = IYakStrategy(_strategy).depositToken();
+        uint256 amountOut = _swap(_tokenIn, _amountIn, depositToken, _minAmountOut);
+
+        // Deposit
+        IERC20(depositToken).approve(_strategy, amountOut);
+        IYakStrategy(_strategy).depositFor(msg.sender, amountOut);
+    }
+
+    function zapOut(address _strategy, address _tokenOut, uint256 _sharesOut, uint256 _minAmountOut) external {
+        // Transfer shares
+        require(IERC20(_strategy).transferFrom(msg.sender, address(this), _sharesOut), "ZapForSimpleRouter::transferFrom failed");
+
+        // Withdraw
+        address depositToken = IYakStrategy(_strategy).depositToken();
+        uint256 balanceBefore = IERC20(depositToken).balanceOf(address(this));
+        IYakStrategy(_strategy).withdraw(_sharesOut);
+        uint256 balanceAfter = IERC20(depositToken).balanceOf(address(this));
+        uint256 amountIn = balanceAfter - balanceBefore;
+        require(amountIn > 0, "ZapForSimpleRouter::amountIn too low");
+
+        // Swap
+        uint256 amountOut = _swap(depositToken, amountIn, _tokenOut, _minAmountOut);
+
+        // Transfer
+        require(IERC20(_tokenOut).transfer(msg.sender, amountOut), "ZapForSimpleRouter::transfer failed");
+
+    }
+
+    /**
+     * @notice Recover ERC20 from contract
+     * @param tokenAddress token address
+     * @param tokenAmount amount to recover
+     */
+    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
+        require(tokenAmount > 0);
+        IERC20(tokenAddress).safeTransfer(msg.sender, tokenAmount);
+        emit Recovered(tokenAddress, tokenAmount);
+    }
+
+    /**
+     * @notice Recover GAS from contract
+     * @param amount amount
+     */
+    function recoverGas(uint256 amount) external onlyOwner {
+        require(amount > 0);
+        payable(msg.sender).transfer(amount);
+        emit Recovered(address(0), amount);
+    }
+}

contracts/helpers/interfaces/IGAvax.sol

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity 0.8.13;
 
 interface IGAvax {

contracts/helpers/interfaces/IOracleVault.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.13;
+
+interface IOracleVault {
+    function symbol() external view returns (string memory);
+
+    function decimals() external view returns (uint8);
+
+    function totalSupply() external view returns (uint256);
+
+    function getTokenX() external view returns (address);
+
+    function getTokenY() external view returns (address);
+
+    function getBalances()
+        external
+        view
+        returns (
+            uint256 amountX,
+            uint256 amountY
+        );
+}

contracts/helpers/interfaces/IPair.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.13;
+
+interface IPair {
+    function symbol() external view returns (string memory);
+
+    function decimals() external view returns (uint8);
+
+    function totalSupply() external view returns (uint256);
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function getReserves()
+        external
+        view
+        returns (
+            uint112 reserve0,
+            uint112 reserve1,
+            uint32 blockTimestampLast
+        );
+}

contracts/helpers/interfaces/IRateProvider.sol

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity 0.8.13;
 
 interface IRateProvider {

contracts/interfaces/IYakStrategy.sol

@@ -5,4 +5,6 @@ interface IYakStrategy {
     function depositToken() external view returns (address);
 
     function depositFor(address account, uint256 amount) external;
+
+    function withdraw(uint256 _amount) external;
 }

contracts/strategies/BaseStrategy.sol

@@ -41,8 +41,6 @@ abstract contract BaseStrategy is YakStrategyV3 {
 
         simpleRouter = ISimpleRouter(_settings.simpleRouter);
 
-        require(_strategySettings.minTokensToReinvest > 0, "BaseStrategy::Invalid configuration");
-
         emit Reinvest(0, 0);
     }
 

contracts/strategies/avalanche/baymax/BayDepositor.sol

@@ -9,7 +9,7 @@ contract BayDepositor is IBayDepositor, Ownable {
     address public proxy;
 
     modifier onlyGmxProxy() {
-        require(msg.sender == proxy, "GmxDepositor::onlyGmxProxy");
+        require(msg.sender == proxy, "BayDepositor::onlyGmxProxy");
         _;
     }
 

contracts/strategies/avalanche/kassandra/KassandraIndexStrategyK3C.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import "../../MasterChefStrategy.sol";
+
+import "./interfaces/IKassandraPool.sol";
+import "./interfaces/IKassandraStaking.sol";
+
+contract KassandraIndexStrategyK3C is MasterChefStrategy {
+    using SafeMath for uint256;
+
+    IKassandraStaking public stakingContract;
+    IKassandraPool public kassandraPool;
+
+    constructor(
+        string memory _name,
+        address _depositToken,
+        address _poolRewardToken,
+        address _swapPairPoolReward,
+        address _stakingContract,
+        uint256 _pid,
+        address _timelock,
+        StrategySettings memory _strategySettings
+    )
+        MasterChefStrategy(
+            _name,
+            _poolRewardToken,
+            _swapPairPoolReward,
+            address(0),
+            _timelock,
+            _pid,
+            _strategySettings
+        )
+    {
+        stakingContract = IKassandraStaking(_stakingContract);
+        kassandraPool = IKassandraPool(_depositToken);
+    }
+
+    function _getDepositFeeBips(
+        uint256 /* pid */
+    ) internal pure override returns (uint256) {
+        return 0;
+    }
+
+    function _getWithdrawFeeBips(
+        uint256 /* pid */
+    ) internal pure override returns (uint256) {
+        return 0;
+    }
+
+    function _depositMasterchef(uint256 _pid, uint256 _amount) internal override {
+        depositToken.approve(address(stakingContract), _amount);
+        stakingContract.stake(_pid, _amount, address(this), address(this));
+    }
+
+    function _withdrawMasterchef(uint256 _pid, uint256 _amount) internal override {
+        stakingContract.withdraw(_pid, _amount);
+    }
+
+    function _pendingRewards(uint256 _pid, address _user)
+        internal
+        view
+        override
+        returns (
+            uint256,
+            uint256,
+            address
+        )
+    {
+        uint256 pendingReward = stakingContract.earned(_pid, address(_user));
+        return (pendingReward, 0, address(0));
+    }
+
+    function _getRewards(uint256 _pid) internal override {
+        stakingContract.getReward(_pid);
+    }
+
+    function _getDepositBalance(uint256 pid, address user) internal view override returns (uint256 amount) {
+        return stakingContract.balanceOf(pid, user);
+    }
+
+    function _bip() internal pure override returns (uint256) {
+        return 10000;
+    }
+
+    function _convertRewardTokenToDepositToken(uint256 fromAmount) internal override returns (uint256 toAmount) {
+        rewardToken.approve(address(kassandraPool), fromAmount);
+        return kassandraPool.joinswapExternAmountIn(address(rewardToken), fromAmount, 0);
+    }
+
+    function _emergencyWithdraw(uint256 _pid) internal override {
+        depositToken.approve(address(stakingContract), 0);
+        stakingContract.exit(_pid);
+    }
+}