@pendle/core-v2 0.8.1-gamma → 0.9.0-gamma-2

package/contracts/core/actions/ActionCore.sol

@@ -13,8 +13,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variabless
-    constructor(address _joeFactory, address _marketFactory)
-        ActionSCYAndPYBase(_joeFactory) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter, address _marketFactory)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     /// @dev refer to the internal function
@@ -48,7 +48,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtSwapToScy
+        ApproxParams calldata guessPtSwapToScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -58,18 +58,17 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netScyIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function addLiquiditySingleRawToken(
+    function addLiquiditySingleToken(
         address receiver,
         address market,
-        uint256 netRawTokenIn,
         uint256 minLpOut,
-        address[] calldata path,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -98,7 +97,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 lpToRemove,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -112,13 +111,12 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquiditySingleRawToken(
+    function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 lpToRemove,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
@@ -139,7 +137,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyOut,
         uint256 maxPtIn,
-        ApproxParams memory guessPtIn
+        ApproxParams calldata guessPtIn
     ) external returns (uint256 netPtIn) {
         netPtIn = _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
@@ -162,71 +160,62 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyIn,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         netPtOut = _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
     }
 
     /// @dev refer to the internal function
-    function mintScyFromRawToken(
+    function mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netScyOut) {
-        return _mintScyFromRawToken(receiver, SCY, netRawTokenIn, minScyOut, path, true);
+        netScyOut = _mintScyFromToken(receiver, SCY, minScyOut, input);
+
+        emit MintScyFromToken(
+            msg.sender,
+            receiver,
+            SCY,
+            input.tokenIn,
+            input.netTokenIn,
+            netScyOut
+        );
     }
 
     /// @dev refer to the internal function
-    function redeemScyToRawToken(
+    function redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
-        emit RedeemScyToRawToken(
-            msg.sender,
-            receiver,
-            SCY,
-            netScyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemScyToToken(receiver, SCY, netScyIn, output, true);
+        emit RedeemScyToToken(msg.sender, receiver, SCY, netScyIn, output.tokenOut, netTokenOut);
     }
 
     /// @dev refer to the internal function
-    function mintPyFromRawToken(
+    function mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
-        emit MintPyFromRawToken(msg.sender, receiver, YT, path[0], netRawTokenIn, netPyOut);
+        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
+        emit MintPyFromToken(msg.sender, receiver, YT, input.tokenIn, input.netTokenIn, netPyOut);
     }
 
     /// @dev refer to the internal function
-    function redeemPyToRawToken(
+    function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
-        emit RedeemPyToRawToken(
-            msg.sender,
-            receiver,
-            YT,
-            netPyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
+        emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
     function mintPyFromScy(
@@ -250,57 +239,41 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForPt(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
     ) external returns (uint256 netPtOut) {
-        netPtOut = _swapExactRawTokenForPt(
-            receiver,
-            market,
-            exactRawTokenIn,
-            minPtOut,
-            path,
-            guessPtOut,
-            true
-        );
+        netPtOut = _swapExactTokenForPt(receiver, market, minPtOut, guessPtOut, input);
 
-        emit SwapPtAndRawToken(
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[0],
+            input.tokenIn,
             receiver,
             netPtOut.Int(),
-            exactRawTokenIn.neg()
+            input.netTokenIn.neg()
         );
     }
 
     /// @dev refer to the internal function
-    function swapExactPtForRawToken(
+    function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactPtForRawToken(
-            receiver,
-            market,
-            exactPtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapPtAndRawToken(
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactPtForToken(receiver, market, exactPtIn, output, true);
+
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[path.length - 1],
+            output.tokenOut,
             receiver,
             exactPtIn.neg(),
-            netRawTokenOut.Int()
+            netTokenOut.Int()
         );
     }
 

package/contracts/core/actions/ActionYT.sol

@@ -12,12 +12,9 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeFactory)
-        ActionSCYAndPYBase(_joeFactory)
-    //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
+    constructor(address _kyberSwapRouter)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
 
     /// @dev refer to the internal function
     function swapExactYtForScy(
@@ -66,48 +63,31 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
-        ApproxParams memory guessYtOut
+        ApproxParams memory guessYtOut,
+        TokenInput calldata input
     ) external returns (uint256 netYtOut) {
-        netYtOut = _swapExactRawTokenForYt(
+        netYtOut = _swapExactTokenForYt(receiver, market, minYtOut, guessYtOut, input);
+        emit SwapYTAndToken(
             receiver,
             market,
-            exactRawTokenIn,
-            minYtOut,
-            path,
-            guessYtOut,
-            true
+            input.tokenIn,
+            netYtOut.Int(),
+            input.netTokenIn.neg()
         );
-        emit SwapYTAndRawToken(receiver, market, path[0], netYtOut.Int(), exactRawTokenIn.neg());
     }
 
     /// @dev refer to the internal function
-    function swapExactYtForRawToken(
+    function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactYtForRawToken(
-            receiver,
-            market,
-            exactYtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapYTAndRawToken(
-            receiver,
-            market,
-            path[path.length - 1],
-            exactYtIn.neg(),
-            netRawTokenOut.Int()
-        );
+        uint256 netYtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactYtForToken(receiver, market, netYtIn, output, true);
+        emit SwapYTAndToken(receiver, market, output.tokenOut, netYtIn.neg(), netTokenOut.Int());
     }
 }

package/contracts/core/actions/base/ActionSCYAndPTBase.sol

@@ -199,28 +199,19 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     /**
      * @notice swap from any ERC20 tokens, through Uniswap's forks, to get baseTokens to make SCY, then swap
         from SCY to PT
-     * @dev simply a combination of _mintScyFromRawToken & _swapExactScyForPt
+     * @dev simply a combination of _mintScyFromToken & _swapExactScyForPt
      */
-    function _swapExactRawTokenForPt(
+    function _swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
         ApproxParams memory guessPtOut,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netPtOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         // all output SCY is transferred directly to the market
-        uint256 netScyUseToBuyPt = _mintScyFromRawToken(
-            market,
-            address(SCY),
-            exactRawTokenIn,
-            1,
-            path,
-            doPull
-        );
+        uint256 netScyUseToBuyPt = _mintScyFromToken(address(market), address(SCY), 1, input);
 
         // SCY is already in the market, hence doPull = false
         netPtOut = _swapExactScyForPt(
@@ -234,30 +225,22 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     }
 
     /**
-     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get rawTokenOut
-     * @dev simply a combination of _swapExactPtForScy & _redeemScyToRawToken
+     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get tokenOut
+     * @dev simply a combination of _swapExactPtForScy & _redeemScyToToken
      */
-    function _swapExactPtForRawToken(
+    function _swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         // all output SCY is directly transferred to the SCY contract
-        _swapExactPtForScy(address(SCY), market, exactPtIn, 1, doPull);
+        uint256 netScyReceived = _swapExactPtForScy(address(SCY), market, exactPtIn, 1, doPull);
 
         // since all SCY is already at the SCY contract, doPull = false
-        netRawTokenOut = _redeemScyToRawToken(
-            receiver,
-            address(SCY),
-            0,
-            minRawTokenOut,
-            path,
-            false
-        );
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
     }
 }

package/contracts/core/actions/base/ActionSCYAndPYBase.sol

@@ -2,120 +2,108 @@
 pragma solidity 0.8.15;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../../libraries/traderjoe/PendleJoeSwapHelperUpg.sol";
+import "../../../libraries/kyberswap/KyberSwapHelper.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
 import "../../../libraries/helpers/TokenHelper.sol";
 import "../../../interfaces/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
+abstract contract ActionSCYAndPYBase is TokenHelper, KyberSwapHelper {
     using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeFactory) PendleJoeSwapHelperUpg(_joeFactory) {}
+    constructor(address _kyberSwapRouter) KyberSwapHelper(_kyberSwapRouter) {}
 
     /// @dev for Path. If no swap is needed, path = [token]
     /// else, path = [inputToken, token0, token1, ...., outputToken]
 
     /**
-     * @notice swap rawToken to baseToken through Uniswap's forks & use it to mint SCY
+     * @notice swap token to baseToken through Uniswap's forks & use it to mint SCY
      */
-    function _mintScyFromRawToken(
+    function _mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netScyOut) {
-        uint256 amountBaseToken;
-        if (path.length == 1) {
-            if (doPull) {
-                IERC20(path[0]).safeTransferFrom(msg.sender, address(this), netRawTokenIn);
-            }
-            amountBaseToken = netRawTokenIn;
-        } else {
-            if (doPull) {
-                IERC20(path[0]).safeTransferFrom(msg.sender, _getFirstPair(path), netRawTokenIn);
-            }
-            amountBaseToken = _swapExactIn(path, netRawTokenIn, address(this));
+        _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
+        if (input.tokenIn != input.tokenMintScy) {
+            _kyberswap(input.tokenIn, input.netTokenIn, input.kybercall);
         }
 
-        address baseToken = path[path.length - 1];
-        IERC20(baseToken).approve(SCY, amountBaseToken);
+        _safeApproveInf(input.tokenMintScy, SCY);
         netScyOut = ISuperComposableYield(SCY).deposit(
             receiver,
-            baseToken,
-            amountBaseToken,
+            input.tokenMintScy,
+            _selfBalance(input.tokenMintScy),
             minScyOut
         );
     }
 
     /**
-     * @notice redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks
+     * @notice redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks
      */
-    function _redeemScyToRawToken(
+    function _redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, SCY, netScyIn);
         }
 
-        address baseToken = path[0];
-        if (path.length == 1) {
-            netRawTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
+        if (output.tokenRedeemScy == output.tokenOut) {
+            netTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
                 receiver,
-                baseToken,
-                minRawTokenOut
+                output.tokenRedeemScy,
+                output.minTokenOut
             );
         } else {
-            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
-                _getFirstPair(path),
-                baseToken,
+            uint256 netTokenRedeemed = ISuperComposableYield(SCY).redeemAfterTransfer(
+                address(this),
+                output.tokenRedeemScy,
                 1
             );
-            netRawTokenOut = _swapExactIn(path, netBaseTokenOut, receiver);
-            require(netRawTokenOut >= minRawTokenOut, "insufficient out");
+            _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
+
+            netTokenOut = _selfBalance(output.tokenOut);
+            require(netTokenOut >= output.minTokenOut, "insufficient out");
+
+            _transferOut(output.tokenOut, receiver, netTokenOut);
         }
     }
 
     /**
-     * @notice swap rawToken to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
+     * @notice swap token to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
      */
-    function _mintPyFromRawToken(
+    function _mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netPyOut) {
         address SCY = IPYieldToken(YT).SCY();
 
-        _mintScyFromRawToken(YT, SCY, netRawTokenIn, 1, path, doPull);
+        _mintScyFromToken(YT, SCY, 1, input);
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         require(netPyOut >= minPyOut, "insufficient PY out");
     }
 
     /**
-     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks.
+     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks.
         If the YT hasn't expired, both PT & YT will be needed to redeem. Else, only PT is needed
      */
-    function _redeemPyToRawToken(
+    function _redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         address PT = IPYieldToken(YT).PT();
         address SCY = IPYieldToken(YT).SCY();
 
@@ -125,9 +113,9 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
             if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
-        IPYieldToken(YT).redeemPY(SCY); // ignore return
+        uint256 amountScyOut = IPYieldToken(YT).redeemPY(SCY); // ignore return
 
-        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, 0, minRawTokenOut, path, false);
+        netTokenOut = _redeemScyToToken(receiver, SCY, amountScyOut, output, false);
     }
 
     function _mintPyFromScy(

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -167,25 +167,16 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
      * @notice swap any ERC20 tokens, through Uniswap's forks, to baseToken of the corresponding SCY of YT. These SCY is then
         used to swap to YT. Please refer to swapExactScyForYt for more details.
      */
-    function _swapExactRawTokenForYt(
+    function _swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
         ApproxParams memory guessYtOut,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netScyUsedToBuyYT = _mintScyFromRawToken(
-            address(YT),
-            address(SCY),
-            exactRawTokenIn,
-            1,
-            path,
-            doPull
-        );
+        uint256 netScyUsedToBuyYT = _mintScyFromToken(address(YT), address(SCY), 1, input);
 
         netYtOut = _swapExactScyForYt(
             receiver,
@@ -198,28 +189,20 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     }
 
     /**
-     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to rawToken
+     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to token
         through Uniswap's forks
      */
-    function _swapExactYtForRawToken(
+    function _swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path,
+        uint256 netYtIn,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
-        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, exactYtIn, 1, doPull);
+        uint256 netScyOut = _swapExactYtForScy(receiver, market, netYtIn, 1, doPull);
 
-        netRawTokenOut = _redeemScyToRawToken(
-            receiver,
-            address(SCY),
-            netScyOut,
-            minRawTokenOut,
-            path,
-            false
-        );
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
     }
 }