@pendle/core-v2 0.8.1-beta → 0.8.1-gamma

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleQiSAvaxSCY.sol

@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../base-implementations/SCYBaseWithRewards.sol";
+import "../../../interfaces/IQiErc20.sol";
+import "../../../interfaces/IQiAvax.sol";
+import "../../../interfaces/IBenQiComptroller.sol";
+import "../../../interfaces/IWAvax.sol";
+import "../../../interfaces/ISAvax.sol";
+
+import "./PendleQiTokenHelper.sol";
+
+contract PendleQiSAvaxSCY is SCYBaseWithRewards, PendleQiTokenHelper {
+    address public immutable QI;
+    address public immutable WAVAX;
+    address public immutable comptroller;
+
+    address public immutable SAVAX;
+    address public immutable QI_SAVAX;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _qiSAvax,
+        address _WAVAX,
+        uint256 _initialExchangeRateMantissa
+    )
+        SCYBaseWithRewards(_name, _symbol, _qiSAvax)
+        PendleQiTokenHelper(_qiSAvax, _initialExchangeRateMantissa)
+    {
+        require(_qiSAvax != address(0), "zero address");
+        require(_WAVAX != address(0), "zero address");
+
+        QI_SAVAX = _qiSAvax;
+        WAVAX = _WAVAX;
+
+        SAVAX = IQiErc20(QI_SAVAX).underlying();
+        comptroller = IQiToken(_qiSAvax).comptroller();
+
+        QI = IBenQiComptroller(comptroller).qiAddress();
+
+        _safeApprove(SAVAX, QI_SAVAX, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is qiToken (qiSAvax). Tokens allowed for deposit are sAvax, qiSAvax, AVAX, WAVAX.
+     *
+     *If  the base token deposited is underlying asset, the function first convert those deposited SAvax into qiSAvax. Then the corresponding amount of shares is returned.
+     *
+     * If the base token is AVAX, it will swap to SAvax which will then be deposited to QiSAvax.
+     *
+     * If the base token is WAVAX, it will unwrap to AVAX, then swap to SAvax which will be deposited to mint QiSAvax.
+     *
+     * The exchange rate of qiToken (qiSAvax) to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == QI_SAVAX) {
+            amountSharesOut = amountDeposited;
+        } else if (tokenIn == WAVAX || tokenIn == NATIVE) {
+            // If 'tokenIn' is WAVAX or NATIVE
+            if (tokenIn == WAVAX) {
+                // Unwrap WAVAX into Native Avax token first
+                IWAvax(WAVAX).withdraw(amountDeposited);
+            }
+
+            // Swap AVAX for SAVAX (regardless from AVAX directly or unwrapped from WAVAX), note since exchange rate of AVAX to SAVAX is NOT 1:1, retrieve amount of SAvax received after depositing NATIVE.
+            uint256 sAvaxToMintQiSAvaxAmount = ISAvax(tokenIn).submit{ value: amountDeposited }();
+
+            // Deposit (WAVAX or NATIVE) converted sAvax into BenQi.
+            amountSharesOut = _depositUnderlyingIntoBenQi(sAvaxToMintQiSAvaxAmount);
+        } else {
+            // If token deposited is sAvax, it will directly mint qiSAvax from BenQi using amountDeposited
+            amountSharesOut = _depositUnderlyingIntoBenQi(amountDeposited);
+        }
+    }
+
+    /**
+     * @dev Deposits underlying token (sAvax) into BenQi and returns the amount of qiSAvax or shares (since qiSAvax : shares == 1:1).
+     */
+    function _depositUnderlyingIntoBenQi(uint256 amountDeposited)
+        internal
+        returns (uint256 amountSharesDeposited)
+    {
+        IQiErc20 QiSAvax = IQiErc20(QI_SAVAX);
+
+        uint256 preBalanceQiSAvax = QiSAvax.balanceOf(address(this));
+
+        uint256 errCode = QiSAvax.mint(amountDeposited);
+        require(errCode == 0, "mint failed");
+
+        amountSharesDeposited = QiSAvax.balanceOf(address(this)) - preBalanceQiSAvax;
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of qiTokens (qiSAvax). If `tokenOut` is the underlying asset sAvax.
+     *
+     * Only SAvax or QiSAvax can be withdrawn.
+     *
+     * the function also redeems said asset from the corresponding amount of qiToken (qiSAvax).
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == QI_SAVAX) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 preBalanceUnderlying = _selfBalance(SAVAX);
+
+            uint256 errCode = IQiErc20(QI_SAVAX).redeem(amountSharesToRedeem);
+            require(errCode == 0, "redeem failed");
+
+            // Even though underlying is not rewardToken, we still manually check balance for accounting purposes.
+            amountTokenOut = _selfBalance(SAVAX) - preBalanceUnderlying;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of qiSAvax to native Avax token, this is calculated from sAvax to QiSAvax Exchange rate and then followed by converting that exchange rate relative to native Avax exchange rate.
+     */
+    function exchangeRate() public view override returns (uint256) {
+        uint256 qiSAvaxToSAvaxExchangeRate = _exchangeRateCurrentView();
+        return ISAvax(SAVAX).getPooledAvaxByShares(qiSAvaxToSAvaxExchangeRate);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = QI;
+        res[1] = WAVAX;
+    }
+
+    function _redeemExternalReward() internal override {
+        address[] memory holders = new address[](1);
+        address[] memory qiTokens = new address[](1);
+        holders[0] = address(this);
+        qiTokens[0] = QI_SAVAX;
+
+        IBenQiComptroller(comptroller).claimReward(0, holders, qiTokens, false, true);
+        IBenQiComptroller(comptroller).claimReward(1, holders, qiTokens, false, true);
+
+        if (address(this).balance != 0) IWAvax(WAVAX).deposit{ value: address(this).balance };
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    /*
+     * @dev 'tokenIn' accepted for deposit are NATIVE, WAVAX, SAVAX and QiSAVAX.
+     */
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == QI_SAVAX) {
+            amountSharesOut = amountTokenToDeposit;
+        } else if (tokenIn == SAVAX) {
+            amountSharesOut = (amountTokenToDeposit * 1e18) / _exchangeRateCurrentView();
+        } else {
+            // NATIVE or WAVAX - use exchange rate from qiSAvax to underlying asset.
+            amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        }
+    }
+
+    /*
+     * @dev 'tokenOut' accepted for deposit are SAVAX and QiSAVAX.
+     */
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == QI_SAVAX) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            // if 'tokenOut' == SAVAX
+            amountTokenOut = (amountSharesToRedeem * _exchangeRateCurrentView()) / 1e18;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = QI_SAVAX;
+        res[1] = SAVAX;
+        res[2] = WAVAX;
+        res[4] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = QI_SAVAX;
+        res[1] = SAVAX;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == QI_SAVAX || token == SAVAX || token == WAVAX || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == QI_SAVAX || token == SAVAX;
+    }
+
+    function assetInfo()
+        external
+        pure
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleQiTokenSCY.sol

@@ -139,7 +139,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         IBenQiComptroller(comptroller).claimReward(0, holders, qiTokens, false, true);
         IBenQiComptroller(comptroller).claimReward(1, holders, qiTokens, false, true);
 
-        if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance };
+        if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance }();
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleSAvaxSCY.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../base-implementations/SCYBase.sol";
+import "../../../interfaces/ISAvax.sol";
+import "../../../interfaces/IWAvax.sol";
+
+// BENQI Stake AVAX (sAVAX) -> 0x2b2C81e08f1Af8835a78Bb2A90AE924ACE0eA4bE
+
+// Exchange rate of sAVAX -> AVAX increases over time, no additional rewards but has a 15day lock-up period with 2 day redemption period.
+// Yield Token -> sAVAX (Interest Bearing)
+
+contract PendleSAvaxSCY is SCYBase {
+    address public immutable SAVAX;
+    address public immutable WAVAX;
+
+    uint256 private constant BASE = 1e18;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sAvax,
+        address _wAvax
+    ) SCYBase(_name, _symbol, _sAvax) {
+        require(_sAvax != address(0), "zero address");
+        require(_wAvax != address(0), "zero address");
+        SAVAX = _sAvax;
+        WAVAX = _wAvax;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is sAvax. Tokens accepted for deposit are NATIVE, WVAX, and sAVAX.
+     *
+     *If the base token deposited is native AVAX, the function converts it into sAVAX first. Then the corresponding amount of shares is returned.
+     *
+     * If WAVAX is deposited, it will first unwrap to native AVAX and then convert into sAVAX.
+     *
+     * The exchange rate of sAVAX to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // Comments: No check for address token IN (need to be implemented in higher level function)
+        if (tokenIn == SAVAX) {
+            amountSharesOut = amountDeposited;
+        } else {
+            // Handle WAVAX or NATIVE Avax - If WAVAX need to unwrap to NATIVE Avax first then deposit.
+            if (tokenIn == WAVAX) {
+                IWAvax(WAVAX).withdraw(amountDeposited);
+            }
+
+            amountSharesOut = ISAvax(tokenIn).submit{ value: amountDeposited }();
+        }
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of sAVAX. `tokenOut` will only be in sAVAX where exchange rate will be 1:1 to SCY.
+     */
+    function _redeem(address, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of sAVAX to AVAX.
+     */
+    function exchangeRate() public view virtual override returns (uint256 currentRate) {
+        return ISAvax(SAVAX).getPooledAvaxByShares(BASE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == SAVAX) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        // Since only SAvax can be redeemed
+        amountTokenOut = amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = NATIVE;
+        res[1] = SAVAX;
+        res[2] = WAVAX;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = SAVAX;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == NATIVE || token == SAVAX || token == WAVAX);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SAVAX;
+    }
+
+    function assetInfo()
+        external
+        pure
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/Euler/PendleEulerSCY.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../../base-implementations/SCYBase.sol";
+import "../../../interfaces/IEulerEToken.sol";
+import "../../../interfaces/IEulerMarkets.sol";
+
+/*
+Euler Finance (Money Markets) - Permissionless Lending/Borrowing Protocol for any ERC20 tokens (Built on top of Uniswap v3 oracle protocol which faciliates people to active their own markets and manage their own lending and borrowing facilities)
+
+External Rewards (EUL distribution) are only applicable for borrowers, hence no external rewards for SCY to deal with since only only lending feature is used.
+*/
+
+contract PendleEulerSCY is SCYBase {
+    address public immutable underlying;
+    address public immutable eToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _eToken,
+        address _eulerMarkets // pass eulerMarkets to double check both eToken & underlying
+    ) SCYBase(_name, _symbol, _eToken) {
+        require(_eToken != address(0), "zero address");
+        require(_eulerMarkets != address(0), "zero address");
+
+        eToken = _eToken;
+
+        underlying = IEulerMarkets(_eulerMarkets).eTokenToUnderlying(eToken);
+
+        _safeApprove(underlying, eToken, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is underlying ETokens. Tokens accepted are EToken or the underlying base token.
+     *
+     *If underlying ETokens are deposited directly, they are swapped to shares 1:1
+     *
+     * If underlying base tokens are deposited, SCY contract will deposit into the lending pool and swap shares based on amount of eTokens minted.
+     *
+     * The exchange rate of EToken to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == eToken) {
+            amountSharesOut = amountDeposited;
+        } else {
+            uint256 preBalanceEToken = _selfBalance(eToken);
+
+            // Deposit underlying tokens to convert into eTokens
+            IEulerEToken(eToken).deposit(0, amountDeposited);
+
+            // Since 'deposit' function doesn't return the amount of eTokens minted, calculate change in EToken balance to find the amount of shares out
+            amountSharesOut = _selfBalance(eToken) - preBalanceEToken;
+        }
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of underlying eTokens.
+     *
+     If `tokenOut` is underlying base Token, the function also swaps back eTokens to underlying base tokens from the lending Pool based on the prevailing exchange rate.
+     *
+     * The exchange rate of shares to EToken is 1:1
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == eToken) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            // 'tokenOut' is underlying base token
+            uint256 preBalanceUnderlying = _selfBalance(underlying);
+
+            // Swap EToken for underlying base tokens
+            IEulerEToken(eToken).withdraw(0, amountSharesToRedeem);
+
+            // Since 'withdraw' function doesn't return the amount of underlying tokens swapped from eTokens, calculate change in underlying balance to find the amount of shares out
+            amountTokenOut = _selfBalance(underlying) - preBalanceUnderlying;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying base token
+     * @dev It is the exchange rate of underlying EToken (since EToken to shares is 1:1) to underlying Base Token.
+     */
+    function exchangeRate() public view virtual override returns (uint256 currentRate) {
+        return IEulerEToken(eToken).convertBalanceToUnderlying(1e18);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == eToken) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == eToken) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = eToken;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = eToken;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == underlying || token == eToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == underlying || token == eToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        // All underlying asset tokens are of ERC20 standard
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/PendleWstEthSCY.sol

@@ -2,16 +2,21 @@
 pragma solidity 0.8.15;
 import "../base-implementations/SCYBase.sol";
 import "../../interfaces/IWstETH.sol";
+import "../../interfaces/IWETH.sol";
+import "../../interfaces/IStETH.sol";
 
 contract PendleWstEthSCY is SCYBase {
+    address public immutable wETH;
     address public immutable stETH;
     address public immutable wstETH;
 
     constructor(
         string memory _name,
         string memory _symbol,
+        address _wETH,
         address _wstETH
     ) SCYBase(_name, _symbol, _wstETH) {
+        wETH = _wETH;
         wstETH = _wstETH;
         stETH = IWstETH(wstETH).stETH();
         _safeApprove(stETH, wstETH, type(uint256).max);
@@ -38,7 +43,18 @@ contract PendleWstEthSCY is SCYBase {
         if (tokenIn == wstETH) {
             amountSharesOut = amountDeposited;
         } else {
-            amountSharesOut = IWstETH(wstETH).wrap(amountDeposited); // .wrap returns amount of wstETH out
+            uint256 amountStETH;
+            if (tokenIn == stETH) {
+                amountStETH = amountDeposited;
+            } else {
+                uint256 stETHBalanceBefore = _selfBalance(stETH);
+                if (tokenIn == wETH) {
+                    IWETH(wETH).withdraw(amountDeposited);
+                }
+                IStETH(stETH).submit{ value: amountDeposited }(address(0));
+                amountStETH = _selfBalance(stETH) - stETHBalanceBefore;
+            }
+            amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
     }
 
@@ -84,7 +100,15 @@ contract PendleWstEthSCY is SCYBase {
         returns (uint256 amountSharesOut)
     {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
-        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        else {
+            uint256 amountStETH;
+            if (tokenIn == stETH) {
+                amountStETH = amountTokenToDeposit; 
+            } else {
+                amountStETH = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
+            }
+            amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+        }
     }
 
     function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
@@ -98,9 +122,12 @@ contract PendleWstEthSCY is SCYBase {
     }
 
     function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = stETH;
-        res[1] = wstETH;
+        res = new address[](4);
+        res[0] = NATIVE;
+        res[1] = wETH;        
+        res[2] = stETH;
+        res[3] = wstETH;
+
     }
 
     function getTokensOut() public view virtual override returns (address[] memory res) {
@@ -110,7 +137,7 @@ contract PendleWstEthSCY is SCYBase {
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == stETH || token == wstETH;
+        return token == stETH || token == wstETH || token == NATIVE || token == wETH;
     }
 
     function isValidTokenOut(address token) public view virtual override returns (bool) {