@pendle/core-v2 0.13.1-testnet → 0.14.0-testnet

package/contracts/core/{SuperComposableYield → StandardizedYield}/PYIndex.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 
-import "./SCYUtils.sol";
+import "./SYUtils.sol";
 import "../libraries/math/Math.sol";
 
 type PYIndex is uint256;
@@ -16,64 +16,64 @@ library PYIndexLib {
         return PYIndex.wrap(YT.pyIndexCurrent());
     }
 
-    function scyToAsset(PYIndex index, uint256 scyAmount)
+    function syToAsset(PYIndex index, uint256 syAmount)
         internal
         pure
         returns (uint256)
     {
-        return SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount);
+        return SYUtils.syToAsset(PYIndex.unwrap(index), syAmount);
     }
 
-    function assetToScy(PYIndex index, uint256 assetAmount)
+    function assetToSy(PYIndex index, uint256 assetAmount)
         internal
         pure
         returns (uint256)
     {
-        return SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount);
+        return SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount);
     }
 
-    function assetToScyUp(PYIndex index, uint256 assetAmount)
+    function assetToSyUp(PYIndex index, uint256 assetAmount)
         internal
         pure
         returns (uint256)
     {
-        return SCYUtils.assetToScyUp(PYIndex.unwrap(index), assetAmount);
+        return SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount);
     }
 
-    function scyToAssetUp(PYIndex index, uint256 scyAmount)
+    function syToAssetUp(PYIndex index, uint256 syAmount)
         internal
         pure
         returns (uint256)
     {
         uint256 _index = PYIndex.unwrap(index);
-        return SCYUtils.scyToAssetUp(_index, scyAmount);
+        return SYUtils.syToAssetUp(_index, syAmount);
     }
 
-    function scyToAsset(PYIndex index, int256 scyAmount)
+    function syToAsset(PYIndex index, int256 syAmount)
         internal
         pure
         returns (int256)
     {
-        int256 sign = scyAmount < 0 ? int256(-1) : int256(1);
-        return sign * (SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount.abs())).Int();
+        int256 sign = syAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SYUtils.syToAsset(PYIndex.unwrap(index), syAmount.abs())).Int();
     }
 
-    function assetToScy(PYIndex index, int256 assetAmount)
+    function assetToSy(PYIndex index, int256 assetAmount)
         internal
         pure
         returns (int256)
     {
         int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
-        return sign * (SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount.abs())).Int();
+        return sign * (SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount.abs())).Int();
     }
 
-    function assetToScyUp(PYIndex index, int256 assetAmount)
+    function assetToSyUp(PYIndex index, int256 assetAmount)
         internal
         pure
         returns (int256)
     {
         int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
-        return sign * (SCYUtils.assetToScyUp(PYIndex.unwrap(index), assetAmount.abs())).Int();
+        return sign * (SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount.abs())).Int();
     }
 
 }

package/contracts/core/{SuperComposableYield/SCYBase.sol → StandardizedYield/SYBase.sol}

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 
-import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IStandardizedYield.sol";
 
 import "../erc20/PendleERC20Permit.sol";
 
@@ -11,9 +11,9 @@ import "../RewardManager/RewardManager.sol";
 import "../libraries/math/Math.sol";
 import "../libraries/TokenHelper.sol";
 import "../libraries/Errors.sol";
-import "./SCYUtils.sol";
+import "./SYUtils.sol";
 
-abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelper {
+abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -34,7 +34,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {ISuperComposableYield-deposit}
+     * @dev See {IStandardizedYield-deposit}
      */
     function deposit(
         address receiver,
@@ -42,21 +42,21 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
         uint256 amountTokenToDeposit,
         uint256 minSharesOut
     ) external payable nonReentrant returns (uint256 amountSharesOut) {
-        if (!isValidTokenIn(tokenIn)) revert Errors.SCYInvalidTokenIn(tokenIn);
-        if (amountTokenToDeposit == 0) revert Errors.SCYZeroDeposit();
+        if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
+        if (amountTokenToDeposit == 0) revert Errors.SYZeroDeposit();
 
         _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
         amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
         if (amountSharesOut < minSharesOut)
-            revert Errors.SCYInsufficientSharesOut(amountSharesOut, minSharesOut);
+            revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
 
         _mint(receiver, amountSharesOut);
         emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
     }
 
     /**
-     * @dev See {ISuperComposableYield-redeem}
+     * @dev See {IStandardizedYield-redeem}
      */
     function redeem(
         address receiver,
@@ -65,8 +65,8 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
         uint256 minTokenOut,
         bool burnFromInternalBalance
     ) external nonReentrant returns (uint256 amountTokenOut) {
-        if (!isValidTokenOut(tokenOut)) revert Errors.SCYInvalidTokenOut(tokenOut);
-        if (amountSharesToRedeem == 0) revert Errors.SCYZeroRedeem();
+        if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
+        if (amountSharesToRedeem == 0) revert Errors.SYZeroRedeem();
 
         if (burnFromInternalBalance) {
             _burn(address(this), amountSharesToRedeem);
@@ -76,7 +76,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
 
         amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
         if (amountTokenOut < minTokenOut)
-            revert Errors.SCYInsufficientTokenOut(amountTokenOut, minTokenOut);
+            revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
     }
 
@@ -108,7 +108,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {ISuperComposableYield-exchangeRate}
+     * @dev See {IStandardizedYield-exchangeRate}
      */
     function exchangeRate() external view virtual override returns (uint256 res);
 
@@ -117,7 +117,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {ISuperComposableYield-claimRewards}
+     * @dev See {IStandardizedYield-claimRewards}
      */
     function claimRewards(
         address /*user*/
@@ -126,7 +126,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
     }
 
     /**
-     * @dev See {ISuperComposableYield-getRewardTokens}
+     * @dev See {IStandardizedYield-getRewardTokens}
      */
     function getRewardTokens()
         external
@@ -139,7 +139,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
     }
 
     /**
-     * @dev See {ISuperComposableYield-accruedRewards}
+     * @dev See {IStandardizedYield-accruedRewards}
      */
     function accruedRewards(
         address /*user*/
@@ -171,7 +171,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
         virtual
         returns (uint256 amountSharesOut)
     {
-        if (!isValidTokenIn(tokenIn)) revert Errors.SCYInvalidTokenIn(tokenIn);
+        if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
         return _previewDeposit(tokenIn, amountTokenToDeposit);
     }
 
@@ -181,7 +181,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20Permit, TokenHelp
         virtual
         returns (uint256 amountTokenOut)
     {
-        if (!isValidTokenOut(tokenOut)) revert Errors.SCYInvalidTokenOut(tokenOut);
+        if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 

package/contracts/core/{SuperComposableYield/SCYBaseWithRewards.sol → StandardizedYield/SYBaseWithRewards.sol}

@@ -2,13 +2,13 @@
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IStandardizedYield.sol";
 
 import "../libraries/math/Math.sol";
-import "./SCYBase.sol";
+import "./SYBase.sol";
 
 /// NOTE: yieldToken MUST NEVER BE a rewardToken, else the rewardManager will behave erroneously
-abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
+abstract contract SYBaseWithRewards is SYBase, RewardManager {
     using Math for uint256;
     using ArrayLib for address[];
 
@@ -17,7 +17,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
         string memory _symbol,
         address _yieldToken
     )
-        SCYBase(_name, _symbol, _yieldToken) // solhint-disable-next-line no-empty-blocks
+        SYBase(_name, _symbol, _yieldToken) // solhint-disable-next-line no-empty-blocks
     {}
 
     /*///////////////////////////////////////////////////////////////
@@ -25,7 +25,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {ISuperComposableYield-claimRewards}
+     * @dev See {IStandardizedYield-claimRewards}
      */
     function claimRewards(address user)
         external
@@ -41,7 +41,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     }
 
     /**
-     * @dev See {ISuperComposableYield-getRewardTokens}
+     * @dev See {IStandardizedYield-getRewardTokens}
      */
     function getRewardTokens()
         external
@@ -54,7 +54,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     }
 
     /**
-     * @dev See {ISuperComposableYield-accruedRewards}
+     * @dev See {IStandardizedYield-accruedRewards}
      */
     function accruedRewards(address user)
         external
@@ -102,7 +102,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
 
     /**
      * @notice returns the total number of reward shares
-     * @dev this is simply the total supply of shares, as rewards shares are equivalent to SCY shares
+     * @dev this is simply the total supply of shares, as rewards shares are equivalent to SY shares
      */
     function _rewardSharesTotal() internal view virtual override returns (uint256) {
         return totalSupply();
@@ -110,7 +110,7 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
 
     /**
      * @notice returns the reward shares of (`user`)
-     * @dev this is simply the SCY balance of (`user`), as rewards shares are equivalent to SCY shares
+     * @dev this is simply the SY balance of (`user`), as rewards shares are equivalent to SY shares
      */
     function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
         return balanceOf(user);

package/contracts/core/StandardizedYield/SYUtils.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+library SYUtils {
+    uint256 internal constant ONE = 1e18;
+
+    function syToAsset(uint256 exchangeRate, uint256 syAmount) internal pure returns (uint256) {
+        return (syAmount * exchangeRate) / ONE;
+    }
+
+    function syToAssetUp(uint256 exchangeRate, uint256 syAmount) internal pure returns (uint256) {
+        return (syAmount * exchangeRate + ONE - 1) / ONE;
+    }
+
+    function assetToSy(uint256 exchangeRate, uint256 assetAmount) internal pure returns (uint256) {
+        return (assetAmount * ONE) / exchangeRate;
+    }
+
+    function assetToSyUp(uint256 exchangeRate, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (assetAmount * ONE + exchangeRate - 1) / exchangeRate;
+    }
+}

package/contracts/core/{SuperComposableYield → StandardizedYield}/implementations/BenQi/PendleQiTokenHelper.sol

@@ -35,7 +35,7 @@ contract PendleQiTokenHelper {
         );
 
         if (borrowRateMantissa > borrowRateMaxMantissa)
-            revert Errors.SCYQiTokenBorrowRateTooHigh(borrowRateMantissa, borrowRateMaxMantissa);
+            revert Errors.SYQiTokenBorrowRateTooHigh(borrowRateMantissa, borrowRateMaxMantissa);
 
         uint256 timestampDelta = currentBlockTimestamp - accrualBlockTimestampPrior;
 

package/contracts/core/{SuperComposableYield/implementations/BenQi/PendleQiTokenSCY.sol → StandardizedYield/implementations/BenQi/PendleQiTokenSY.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../../SCYBaseWithRewards.sol";
+import "../../SYBaseWithRewards.sol";
 import "../../../../interfaces/IQiErc20.sol";
 import "../../../../interfaces/IQiAvax.sol";
 import "../../../../interfaces/IBenQiComptroller.sol";
@@ -9,7 +9,7 @@ import "../../../../interfaces/IWETH.sol";
 
 import "./PendleQiTokenHelper.sol";
 
-contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
+contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
     address public immutable underlying;
     address public immutable QI;
     address public immutable WAVAX;
@@ -24,7 +24,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         address _WAVAX,
         uint256 _initialExchangeRateMantissa
     )
-        SCYBaseWithRewards(_name, _symbol, _qiToken)
+        SYBaseWithRewards(_name, _symbol, _qiToken)
         PendleQiTokenHelper(_qiToken, _initialExchangeRateMantissa)
     {
         qiToken = _qiToken;
@@ -45,7 +45,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {SCYBase-_deposit}
+     * @dev See {SYBase-_deposit}
      *
      * The underlying yield token is qiToken. If the base token deposited is underlying asset, the function
      * first convert those deposited into qiToken. Then the corresponding amount of shares is returned.
@@ -67,7 +67,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
                 IQiAvax(qiToken).mint{ value: amount }();
             } else {
                 uint256 errCode = IQiErc20(qiToken).mint(amount);
-                if (errCode != 0) revert Errors.SCYQiTokenMintFailed(errCode);
+                if (errCode != 0) revert Errors.SYQiTokenMintFailed(errCode);
             }
 
             amountSharesOut = _selfBalance(qiToken) - preBalanceQiToken;
@@ -75,7 +75,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
     }
 
     /**
-     * @dev See {SCYBase-_redeem}
+     * @dev See {SYBase-_redeem}
      *
      * The shares are redeemed into the same amount of qiTokens. If `tokenOut` is the underlying asset,
      * the function also redeems said asset from the corresponding amount of qiToken.
@@ -92,10 +92,10 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
 
             if (underlying == NATIVE) {
                 uint256 errCode = IQiAvax(qiToken).redeem(amountSharesToRedeem);
-                if (errCode != 0) revert Errors.SCYQiTokenRedeemFailed(errCode);
+                if (errCode != 0) revert Errors.SYQiTokenRedeemFailed(errCode);
             } else {
                 uint256 errCode = IQiErc20(qiToken).redeem(amountSharesToRedeem);
-                if (errCode != 0) revert Errors.SCYQiTokenRedeemFailed(errCode);
+                if (errCode != 0) revert Errors.SYQiTokenRedeemFailed(errCode);
             }
 
             // underlying is potentially also rewardToken, hence we need to manually track the balance here
@@ -121,7 +121,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @dev See {ISuperComposableYield-getRewardTokens}
+     * @dev See {IStandardizedYield-getRewardTokens}
      */
     function _getRewardTokens() internal view override returns (address[] memory res) {
         res = new address[](2);
@@ -148,7 +148,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         );
 
         if (rewardAccruedType0 > 0 || rewardAccruedType1 > 0)
-            revert Errors.SCYQiTokenRedeemRewardsFailed(rewardAccruedType0, rewardAccruedType1);
+            revert Errors.SYQiTokenRedeemRewardsFailed(rewardAccruedType0, rewardAccruedType1);
 
         if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance }();
     }

package/contracts/core/StandardizedYield/implementations/Convex/ConvexCurveLP/Pendle3CrvAndTokenSY.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendleConvexLPSY.sol";
+import "../Pendle3CrvHelper.sol";
+import "../../../../libraries/ArrayLib.sol";
+
+contract Pendle3CrvAndTokenSY is PendleConvexLPSY {
+    using ArrayLib for address[];
+
+    uint256 public immutable indexOf3Crv;
+    uint256 public immutable indexOfOther;
+    address public immutable otherToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _cvxPid,
+        address _crvLp,
+        address _crvPool
+    ) PendleConvexLPSY(_name, _symbol, _cvxPid, _crvLp, _crvPool) {
+        indexOf3Crv = ICrvPool(_crvPool).coins(0) == Pendle3CrvHelper.LP ? 0 : 1;
+        indexOfOther = 1 - indexOf3Crv;
+        otherToken = ICrvPool(_crvPool).coins(indexOfOther);
+
+        _safeApproveInf(Pendle3CrvHelper.LP, crvPool);
+        _safeApproveInf(otherToken, crvPool);
+
+        _safeApproveInf(Pendle3CrvHelper.DAI, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDC, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDT, Pendle3CrvHelper.POOL);
+    }
+
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        override
+        returns (uint256 amountLpOut)
+    {
+        uint256 preBalanceLp = _selfBalance(crvLp);
+
+        uint256[2] memory amounts;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amount3CrvLp = Pendle3CrvHelper.deposit3Crv(tokenIn, amountTokenToDeposit);
+            amounts[indexOf3Crv] = amount3CrvLp;
+        } else {
+            // one of the 2 LP
+            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        }
+
+        ICrvPool(crvPool).add_liquidity(amounts, 0);
+
+        amountLpOut = _selfBalance(crvLp) - preBalanceLp;
+    }
+
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        address tokenToRemove = (tokenOut == otherToken) ? otherToken : Pendle3CrvHelper.LP;
+
+        uint256 preBalanceToken = _selfBalance(tokenToRemove);
+
+        ICrvPool(crvPool).remove_liquidity_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenToRemove)),
+            0
+        );
+
+        uint256 amountTokenRemoved = _selfBalance(tokenToRemove) - preBalanceToken;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            amountTokenOut = Pendle3CrvHelper.redeem3Crv(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            amountTokenOut = amountTokenRemoved;
+        }
+    }
+
+    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256[2] memory amounts;
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amount3CrvLp = Pendle3CrvHelper.preview3CrvDeposit(
+                tokenIn,
+                amountTokenToDeposit
+            );
+            amounts[indexOf3Crv] = amount3CrvLp;
+        } else {
+            // one of the 2 LP
+            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        }
+
+        return ICrvPool(crvPool).calc_token_amount(amounts, true);
+    }
+
+    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256 amountTokenRemoved = ICrvPool(crvPool).calc_withdraw_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenOut))
+        );
+
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            return Pendle3CrvHelper.preview3CrvRedeem(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            return amountTokenRemoved;
+        }
+    }
+
+    function _getIndex(address token) internal view returns (uint256) {
+        if (token == Pendle3CrvHelper.LP || Pendle3CrvHelper.is3CrvToken(token)) {
+            return indexOf3Crv;
+        } else {
+            return indexOfOther;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = otherToken;
+        res[2] = Pendle3CrvHelper.LP;
+        res[3] = Pendle3CrvHelper.DAI;
+        res[4] = Pendle3CrvHelper.USDC;
+        res[5] = Pendle3CrvHelper.USDT;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = otherToken;
+        res[2] = Pendle3CrvHelper.LP;
+        res[3] = Pendle3CrvHelper.DAI;
+        res[4] = Pendle3CrvHelper.USDC;
+        res[5] = Pendle3CrvHelper.USDT;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool res) {
+        res = (token == crvLp ||
+            token == otherToken ||
+            token == Pendle3CrvHelper.LP ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool res) {
+        res = (token == crvLp ||
+            token == otherToken ||
+            token == Pendle3CrvHelper.LP ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+}