@pendle/core-v2 0.11.10-testnet → 0.12.0-testnet

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

@@ -2,6 +2,7 @@
 pragma solidity 0.8.15;
 
 import "../../../interfaces/IQiToken.sol";
+import "../../../libraries/Errors.sol";
 
 contract PendleQiTokenHelper {
     IQiToken private immutable qiToken;
@@ -33,7 +34,8 @@ contract PendleQiTokenHelper {
             reservesPrior
         );
 
-        require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
+        if (borrowRateMantissa > borrowRateMaxMantissa)
+            revert Errors.SCYQiTokenBorrowRateTooHigh(borrowRateMantissa, borrowRateMaxMantissa);
 
         uint256 timestampDelta = currentBlockTimestamp - accrualBlockTimestampPrior;
 

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

@@ -27,8 +27,6 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         SCYBaseWithRewards(_name, _symbol, _qiToken)
         PendleQiTokenHelper(_qiToken, _initialExchangeRateMantissa)
     {
-        require(_WAVAX != address(0), "zero address");
-
         qiToken = _qiToken;
 
         underlying = isUnderlyingNative ? NATIVE : IQiErc20(qiToken).underlying();
@@ -69,7 +67,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
                 IQiAvax(qiToken).mint{ value: amount }();
             } else {
                 uint256 errCode = IQiErc20(qiToken).mint(amount);
-                require(errCode == 0, "mint failed");
+                if (errCode != 0) revert Errors.SCYQiTokenMintFailed(errCode);
             }
 
             amountSharesOut = _selfBalance(qiToken) - preBalanceQiToken;
@@ -82,11 +80,11 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
      * 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.
      */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
         if (tokenOut == qiToken) {
             amountTokenOut = amountSharesToRedeem;
         } else {
@@ -94,15 +92,16 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
 
             if (underlying == NATIVE) {
                 uint256 errCode = IQiAvax(qiToken).redeem(amountSharesToRedeem);
-                require(errCode == 0, "redeem failed");
+                if (errCode != 0) revert Errors.SCYQiTokenRedeemFailed(errCode);
             } else {
                 uint256 errCode = IQiErc20(qiToken).redeem(amountSharesToRedeem);
-                require(errCode == 0, "redeem failed");
+                if (errCode != 0) revert Errors.SCYQiTokenRedeemFailed(errCode);
             }
 
             // underlying is potentially also rewardToken, hence we need to manually track the balance here
             amountTokenOut = _selfBalance(underlying) - preBalanceUnderlying;
         }
+        _transferOut(tokenOut, receiver, amountTokenOut);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -139,14 +138,18 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         IBenQiComptroller(comptroller).claimReward(0, holders, qiTokens, false, true);
         IBenQiComptroller(comptroller).claimReward(1, holders, qiTokens, false, true);
 
-        require(
-            Math.max(
-                IBenQiComptroller(comptroller).rewardAccrued(0, address(this)),
-                IBenQiComptroller(comptroller).rewardAccrued(1, address(this))
-            ) == 0,
-            "BENQI: redeem reward failed"
+        uint256 rewardAccruedType0 = IBenQiComptroller(comptroller).rewardAccrued(
+            0,
+            address(this)
+        );
+        uint256 rewardAccruedType1 = IBenQiComptroller(comptroller).rewardAccrued(
+            1,
+            address(this)
         );
 
+        if (rewardAccruedType0 > 0 || rewardAccruedType1 > 0)
+            revert Errors.SCYQiTokenRedeemRewardsFailed(rewardAccruedType0, rewardAccruedType1);
+
         if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance }();
     }
 

package/contracts/SuperComposableYield/SCY-implementations/Convex/ConvexCurveLP/Pendle3CrvAndTokenSCY.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./PendleConvexCurveLP2PoolSCY.sol";
+import "../Pendle3CrvHelper.sol";
+import "../../../../libraries/helpers/ArrayLib.sol";
+
+contract Pendle3CrvAndTokenSCY is PendleConvexCurveLP2PoolSCY {
+    using ArrayLib for address[];
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _pid,
+        address _convexBooster,
+        address _crvLpToken,
+        address _cvx,
+        address _baseCrvPool,
+        address[] memory _basePoolTokens
+    )
+        PendleConvexCurveLP2PoolSCY(
+            _name,
+            _symbol,
+            _pid,
+            _convexBooster,
+            _crvLpToken,
+            _cvx,
+            _baseCrvPool,
+            _basePoolTokens
+        )
+    {
+        if (!_basePoolTokens.contains(Pendle3CrvHelper.TOKEN))
+            revert Errors.SCYCurve3crvPoolNotFound();
+
+        _safeApproveInf(Pendle3CrvHelper.DAI, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDC, Pendle3CrvHelper.POOL);
+        _safeApproveInf(Pendle3CrvHelper.USDT, Pendle3CrvHelper.POOL);
+    }
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amountLp = Pendle3CrvHelper.deposit3Crv(tokenIn, amount);
+            return super._deposit(Pendle3CrvHelper.TOKEN, amountLp);
+        } else {
+            return super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            uint256 amountLp = super._redeem(
+                address(this),
+                Pendle3CrvHelper.TOKEN,
+                amountSharesToRedeem
+            );
+            amountTokenOut = Pendle3CrvHelper.redeem3Crv(tokenOut, amountLp);
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        } else {
+            return super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        if (Pendle3CrvHelper.is3CrvToken(tokenIn)) {
+            uint256 amountLp = Pendle3CrvHelper.preview3CrvDeposit(tokenIn, amountTokenToDeposit);
+            return super._previewDeposit(Pendle3CrvHelper.TOKEN, amountLp);
+        } else {
+            return super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        if (Pendle3CrvHelper.is3CrvToken(tokenOut)) {
+            uint256 amountLp = super._previewRedeem(Pendle3CrvHelper.TOKEN, amountSharesToRedeem);
+            return Pendle3CrvHelper.preview3CrvRedeem(tokenOut, amountLp);
+        } else {
+            return super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = LP;
+        res[1] = token1;
+        res[2] = token2;
+        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] = LP;
+        res[1] = token1;
+        res[2] = token2;
+        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 == LP ||
+            token == token1 ||
+            token == token2 ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool res) {
+        res = (token == LP ||
+            token == token1 ||
+            token == token2 ||
+            Pendle3CrvHelper.is3CrvToken(token));
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/Convex/ConvexCurveLP/PendleConvexCurveLP2PoolSCY.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./PendleConvexCurveLPSCY.sol";
+
+contract PendleConvexCurveLP2PoolSCY is PendleConvexCurveLPSCY {
+    address public immutable token1;
+    address public immutable token2;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _pid,
+        address _convexBooster,
+        address _crvLpToken,
+        address _cvx,
+        address _baseCrvPool,
+        address[] memory _basePoolTokens
+    )
+        PendleConvexCurveLPSCY(
+            _name,
+            _symbol,
+            _pid,
+            _convexBooster,
+            _crvLpToken,
+            _cvx,
+            _baseCrvPool
+        )
+    {
+        if (_basePoolTokens.length != 2) revert Errors.ArrayLengthMismatch();
+
+        token1 = _basePoolTokens[0];
+        token2 = _basePoolTokens[1];
+
+        _safeApprove(token1, crvPool, type(uint256).max);
+        _safeApprove(token2, crvPool, type(uint256).max);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = LP;
+        res[1] = token1;
+        res[2] = token2;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = LP;
+        res[1] = token1;
+        res[2] = token2;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool res) {
+        res = (token == LP || token == token1 || token == token2);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool res) {
+        res = (token == LP || token == token1 || token == token2);
+    }
+
+    function _getBaseTokenIndex(address crvBaseToken)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 index)
+    {
+        if (crvBaseToken == token1) {
+            index = 0;
+        } else {
+            index = 1;
+        }
+    }
+
+    function _isBaseToken(address token) internal view virtual override returns (bool res) {
+        return (token == token1 || token == token2);
+    }
+
+    function _depositToCurve(address token, uint256 amount) internal virtual override {
+        uint256[2] memory amounts;
+        amounts[_getBaseTokenIndex(token)] = amount;
+        ICrvPool(crvPool).add_liquidity(amounts, 0);
+    }
+
+    function _previewDepositToCurve(address token, uint256 amount)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256[2] memory amounts;
+        amounts[_getBaseTokenIndex(token)] = amount;
+        return ICrvPool(crvPool).calc_token_amount(amounts, true);
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/Convex/ConvexCurveLP/PendleConvexCurveLPSCY.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../base-implementations/SCYBaseWithRewards.sol";
+import "../../../../interfaces/ConvexCurve/IBooster.sol";
+import "../../../../interfaces/ConvexCurve/IRewards.sol";
+import "../../../../interfaces/Curve/ICrvPool.sol";
+
+abstract contract PendleConvexCurveLPSCY is SCYBaseWithRewards {
+    using SafeERC20 for IERC20;
+
+    uint256 public immutable pid;
+    address public immutable booster;
+    address public immutable baseRewards;
+    address public immutable crvPool;
+
+    address public immutable CRV;
+    address public immutable CVX;
+    address public immutable LP;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _pid,
+        address _convexBooster,
+        address _crvLpToken,
+        address _cvx,
+        address _baseCrvPool
+    ) SCYBaseWithRewards(_name, _symbol, _crvLpToken) {
+        pid = _pid;
+        CVX = _cvx;
+        crvPool = _baseCrvPool;
+
+        booster = _convexBooster;
+
+        (LP, baseRewards, CRV) = _getPoolInfo(pid);
+        if (LP != _crvLpToken) revert Errors.SCYCurveInvalidPid();
+
+        _safeApprove(LP, booster, type(uint256).max);
+    }
+
+    function _getPoolInfo(uint256 _pid)
+        internal
+        view
+        returns (
+            address lptoken,
+            address crvRewards,
+            address crv
+        )
+    {
+        if (_pid > IBooster(booster).poolLength()) revert Errors.SCYCurveInvalidPid();
+
+        (lptoken, , , crvRewards, , ) = IBooster(booster).poolInfo(_pid);
+        crv = IBooster(booster).crv();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * If any of the base pool tokens are deposited, it will first add liquidity to the curve pool and mint LP,
+     * which will then be deposited into convex
+     */
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == LP) {
+            IBooster(booster).deposit(pid, amount, true);
+            amountSharesOut = amount;
+        } else {
+            uint256 prevLpBalance = _selfBalance(LP);
+            _depositToCurve(tokenIn, amount);
+            amountSharesOut = _selfBalance(LP) - prevLpBalance;
+
+            // Deposit LP Token received into Convex Booster
+            IBooster(booster).deposit(pid, amountSharesOut, true);
+        }
+    }
+
+    /**
+     * If any of the base curve pool tokens is specified as 'tokenOut',
+     * it will redeem the corresponding liquidity the LP token represents via the prevailing exchange rate.
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        IRewards(baseRewards).withdrawAndUnwrap(amountSharesToRedeem, false);
+
+        if (_isBaseToken(tokenOut)) {
+            uint256 prevBal = _selfBalance(tokenOut);
+            ICrvPool(crvPool).remove_liquidity_one_coin(
+                amountSharesToRedeem,
+                Math.Int128(_getBaseTokenIndex(tokenOut)),
+                0
+            );
+            amountTokenOut = _selfBalance(tokenOut) - prevBal;
+        } else {
+            // 'tokenOut' is LP
+            amountTokenOut = amountSharesToRedeem;
+        }
+        if (receiver != address(this)) _transferOut(tokenOut, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The current price of the pool LP token relative to the underlying pool assets. Given as an integer with 1e18 precision.
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return ICrvPool(crvPool).get_virtual_price();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * Refer to currentExtraRewards array of reward tokens specific to the curve pool.
+     * @dev We are aware that Convex might add or remove reward tokens, but also agreed that it was
+     * not worth the complexity
+     **/
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = CRV;
+        res[1] = CVX;
+    }
+
+    function _redeemExternalReward() internal virtual override {
+        // Redeem all extra rewards from the curve pool
+        IRewards(baseRewards).getReward();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == LP) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            // Calculate expected amount of LpToken to receive
+            amountSharesOut = _previewDepositToCurve(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        uint256 amountLpTokenToReceive = (amountSharesToRedeem * exchangeRate()) / 1e18;
+
+        if (tokenOut == LP) {
+            amountTokenOut = amountLpTokenToReceive;
+        } else {
+            // If 'tokenOut' is a CrvBaseToken, withdraw liquidity from curvePool to return the base token back to user.
+            amountTokenOut = ICrvPool(crvPool).calc_withdraw_one_coin(
+                amountLpTokenToReceive,
+                Math.Int128(_getBaseTokenIndex(tokenOut))
+            );
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res);
+
+    function getTokensOut() public view virtual override returns (address[] memory res);
+
+    function isValidTokenIn(address token) public view virtual override returns (bool);
+
+    function isValidTokenOut(address token) public view virtual override returns (bool);
+
+    function _depositToCurve(address token, uint256 amount) internal virtual;
+
+    function _previewDepositToCurve(address token, uint256 amount)
+        internal
+        view
+        virtual
+        returns (uint256 amountLpOut);
+
+    function _getBaseTokenIndex(address crvBaseToken)
+        internal
+        view
+        virtual
+        returns (uint256 index);
+
+    function _isBaseToken(address token) internal view virtual returns (bool res);
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, LP, IERC20Metadata(LP).decimals());
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/Convex/Pendle3CrvHelper.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../interfaces/Curve/ICrvPool.sol";
+import "../../../libraries/math/Math.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library Pendle3CrvHelper {
+    using Math for uint256;
+
+    address public constant TOKEN = address(0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490);
+    address public constant POOL = address(0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7);
+    address public constant DAI = address(0x6B175474E89094C44Da98b954EedeAC495271d0F);
+    address public constant USDC = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
+    address public constant USDT = address(0xdAC17F958D2ee523a2206206994597C13D831ec7);
+
+    function preview3CrvDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            ICrvPool(POOL).calc_token_amount(
+                _getTokenAmounts(tokenIn, amountTokenToDeposit),
+                true
+            );
+    }
+
+    function preview3CrvRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            ICrvPool(POOL).calc_withdraw_one_coin(
+                amountSharesToRedeem,
+                _get3CrvTokenIndex(tokenOut).Int128()
+            );
+    }
+
+    function deposit3Crv(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(TOKEN).balanceOf(address(this));
+        ICrvPool(POOL).add_liquidity(_getTokenAmounts(tokenIn, amountTokenToDeposit), 0);
+        uint256 balAfter = IERC20(TOKEN).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function redeem3Crv(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
+        ICrvPool(POOL).remove_liquidity_one_coin(
+            amountSharesToRedeem,
+            _get3CrvTokenIndex(tokenOut).Int128(),
+            0
+        );
+        uint256 balAfter = IERC20(tokenOut).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[3] memory res)
+    {
+        res[_get3CrvTokenIndex(token)] = amount;
+    }
+
+    function _get3CrvTokenIndex(address token) internal pure returns (uint256) {
+        if (token == DAI) return 0;
+        if (token == USDC) return 1;
+        if (token == USDT) return 2;
+        revert("Pendle3CrvHelper: not valid token");
+    }
+
+    function is3CrvToken(address token) internal pure returns (bool) {
+        return (token == DAI || token == USDC || token == USDT);
+    }
+}

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

@@ -47,12 +47,8 @@ contract PendleWstEthSCY is SCYBase {
             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;
+                if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
+                amountStETH = IStETH(stETH).submit{ value: amountDeposited }(address(0));
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
@@ -64,17 +60,17 @@ contract PendleWstEthSCY is SCYBase {
      * The shares are redeemed into the same amount of wstETH. If `tokenOut` is stETH, the function also
      * unwraps said amount of wstETH into stETH for redemption.
      */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
         if (tokenOut == wstETH) {
             amountTokenOut = amountSharesToRedeem;
         } else {
             amountTokenOut = IWstETH(wstETH).unwrap(amountSharesToRedeem);
         }
+        _transferOut(tokenOut, receiver, amountTokenOut);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -103,7 +99,7 @@ contract PendleWstEthSCY is SCYBase {
         else {
             uint256 amountStETH;
             if (tokenIn == stETH) {
-                amountStETH = amountTokenToDeposit; 
+                amountStETH = amountTokenToDeposit;
             } else {
                 amountStETH = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
             }
@@ -124,10 +120,9 @@ contract PendleWstEthSCY is SCYBase {
     function getTokensIn() public view virtual override returns (address[] memory res) {
         res = new address[](4);
         res[0] = NATIVE;
-        res[1] = wETH;        
+        res[1] = wETH;
         res[2] = stETH;
         res[3] = wstETH;
-
     }
 
     function getTokensOut() public view virtual override returns (address[] memory res) {