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

package/contracts/router/ActionSwapYT.sol

@@ -13,7 +13,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
-    using SafeERC20 for ISuperComposableYield;
+    using SafeERC20 for IStandardizedYield;
     using SafeERC20 for IPYieldToken;
     using PYIndexLib for IPYieldToken;
 
@@ -23,123 +23,116 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     {}
 
     /**
-    * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
+    * @notice swap exact SY to YT with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
-     - `exactScyIn` SCY is transferred to YT contract
-     - `market.swapExactPtForScy` is called, which will transfer SCY directly to YT contract & callback is invoked.
+     - `exactSyIn` SY is transferred to YT contract
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
         Note that now we owe PT
-     - in callback, all SCY in YT contract is used to mint PT + YT, with PT used to pay back the loan, and YT
+     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay back the loan, and YT
         transferred to the receiver
     * @dev this function works in conjunction with ActionCallback
      */
-    function swapExactScyForYt(
+    function swapExactSyForYt(
         address receiver,
         address market,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams memory guessYtOut
-    ) external returns (uint256 netYtOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
+        SY.safeTransferFrom(msg.sender, address(YT), exactSyIn);
 
-        (netYtOut, netScyFee) = _swapExactScyForYt(
+        (netYtOut, netSyFee) = _swapExactSyForYt(
             receiver,
             market,
             YT,
-            exactScyIn,
+            exactSyIn,
             minYtOut,
             guessYtOut
         );
 
-        emit SwapYtAndScy(msg.sender, market, receiver, netYtOut.Int(), exactScyIn.neg());
+        emit SwapYtAndSy(msg.sender, market, receiver, netYtOut.Int(), exactSyIn.neg());
     }
 
     /**
-    * @notice swap exact YT to SCY with the help of flashswaps & YT tokenization / redemption
+    * @notice swap exact YT to SY with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
      - `exactYtIn` YT is transferred to YT contract
-     - `market.swapScyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
-        Note that now we owe SCY
-     - in callback, all PT + YT in YT contract is used to redeem SCY. A portion of SCY is used to payback the loan,
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
+        Note that now we owe SY
+     - in callback, all PT + YT in YT contract is used to redeem SY. A portion of SY is used to payback the loan,
         the rest is transferred to the `receiver`
     * @dev this function works in conjunction with ActionCallback
      */
-    function swapExactYtForScy(
+    function swapExactYtForSy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
-        (netScyOut, netScyFee) = _swapExactYtForScy(
-            receiver,
-            market,
-            SCY,
-            YT,
-            exactYtIn,
-            minScyOut
-        );
+        (netSyOut, netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, exactYtIn, minSyOut);
 
-        emit SwapYtAndScy(msg.sender, market, receiver, exactYtIn.neg(), netScyOut.Int());
+        emit SwapYtAndSy(msg.sender, market, receiver, exactYtIn.neg(), netSyOut.Int());
     }
 
     /**
-    * @notice swap SCY to exact YT with the help of flashswaps & YT tokenization / redemption
+    * @notice swap SY to exact YT with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
-     - `market.swapExactPtForScy` is called, which will transfer SCY directly to YT contract & callback is invoked.
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
         Note that now we owe PT
-     - in callback, we will pull in more SCY as needed & mint all SCY to PT + YT. PT is then used to payback the loan
+     - in callback, we will pull in more SY as needed & mint all SY to PT + YT. PT is then used to payback the loan
         while YT is transferred to the user
     * @dev this function works in conjunction with ActionCallback
      */
-    function swapScyForExactYt(
+    function swapSyForExactYt(
         address receiver,
         address market,
         uint256 exactYtOut,
-        uint256 maxScyIn
-    ) external returns (uint256 netScyIn, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 preScyBalance = SCY.balanceOf(msg.sender);
+        uint256 preSyBalance = SY.balanceOf(msg.sender);
 
-        (, netScyFee) = IPMarket(market).swapExactPtForScy(
+        (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
-            _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
+            _encodeSwapSyForExactYt(msg.sender, receiver, maxSyIn)
         );
 
-        netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
+        netSyIn = preSyBalance - SY.balanceOf(msg.sender);
 
-        emit SwapYtAndScy(msg.sender, market, receiver, exactYtOut.Int(), netScyIn.neg());
+        emit SwapYtAndSy(msg.sender, market, receiver, exactYtOut.Int(), netSyIn.neg());
     }
 
     /**
-    * @notice swap YT to exact SCY with the help of flashswaps & YT tokenization / redemption
+    * @notice swap YT to exact SY with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
      - transfer netYtIn (received from approx function) to YT contract
-     - `market.swapScyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
-        Note that now we owe SCY
-     - in callback, we will redeem all PT + YT to get SCY. A portion of it is used to payback the loan. The rest is
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
+        Note that now we owe SY
+     - in callback, we will redeem all PT + YT to get SY. A portion of it is used to payback the loan. The rest is
         transferred to `receiver`
     * @dev this function works in conjunction with ActionCallback
      */
-    function swapYtForExactScy(
+    function swapYtForExactSy(
         address receiver,
         address market,
-        uint256 exactScyOut,
+        uint256 exactSyOut,
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
-    ) external returns (uint256 netYtIn, uint256 netScyFee) {
+    ) external returns (uint256 netYtIn, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netYtIn, , ) = state.approxSwapYtForExactScy(
+        (netYtIn, , ) = state.approxSwapYtForExactSy(
             YT.newIndex(),
-            exactScyOut,
+            exactSyOut,
             block.timestamp,
             guessYtIn
         );
@@ -148,13 +141,13 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
 
         YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
-        (, netScyFee) = IPMarket(market).swapScyForExactPt(
+        (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
-            _encodeSwapYtForScy(receiver, exactScyOut)
+            _encodeSwapYtForSy(receiver, exactSyOut)
         );
 
-        emit SwapYtAndScy(msg.sender, market, receiver, netYtIn.neg(), exactScyOut.Int());
+        emit SwapYtAndSy(msg.sender, market, receiver, netYtIn.neg(), exactSyOut.Int());
     }
 
     function swapExactTokenForYt(
@@ -163,16 +156,16 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netYtOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netScyUsedToBuyYT = _mintScyFromToken(address(YT), address(SCY), 1, input);
+        uint256 netSyUsedToBuyYT = _mintSyFromToken(address(YT), address(SY), 1, input);
 
-        (netYtOut, netScyFee) = _swapExactScyForYt(
+        (netYtOut, netSyFee) = _swapExactSyForYt(
             receiver,
             market,
             YT,
-            netScyUsedToBuyYT,
+            netSyUsedToBuyYT,
             minYtOut,
             guessYtOut
         );
@@ -192,16 +185,16 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 netYtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
-        uint256 netScyOut;
+        uint256 netSyOut;
 
-        (netScyOut, netScyFee) = _swapExactYtForScy(address(SCY), market, SCY, YT, netYtIn, 1);
+        (netSyOut, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtIn, 1);
 
-        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
 
         emit SwapYtAndToken(
             msg.sender,
@@ -213,19 +206,19 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         );
     }
 
-    function _swapExactScyForYt(
+    function _swapExactSyForYt(
         address receiver,
         address market,
         IPYieldToken YT,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams memory guessYtOut
-    ) internal returns (uint256 netYtOut, uint256 netScyFee) {
+    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
 
-        (netYtOut, ) = state.approxSwapExactScyForYt(
+        (netYtOut, ) = state.approxSwapExactSyForYt(
             YT.newIndex(),
-            exactScyIn,
+            exactSyIn,
             block.timestamp,
             guessYtOut
         );
@@ -233,29 +226,29 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         // early-check
         if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
 
-        (, netScyFee) = IPMarket(market).swapExactPtForScy(
+        (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             netYtOut, // exactPtIn = netYtOut
-            _encodeSwapExactScyForYt(receiver, minYtOut)
+            _encodeSwapExactSyForYt(receiver, minYtOut)
         );
     }
 
-    function _swapExactYtForScy(
+    function _swapExactYtForSy(
         address receiver,
         address market,
-        ISuperComposableYield SCY,
+        IStandardizedYield SY,
         IPYieldToken YT,
         uint256 exactYtIn,
-        uint256 minScyOut
-    ) internal returns (uint256 netScyOut, uint256 netScyFee) {
-        uint256 preScyBalance = SCY.balanceOf(receiver);
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
+        uint256 preSyBalance = SY.balanceOf(receiver);
 
-        (, netScyFee) = IPMarket(market).swapScyForExactPt(
+        (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
-            _encodeSwapYtForScy(receiver, minScyOut)
+            _encodeSwapYtForSy(receiver, minSyOut)
         ); // ignore return
 
-        netScyOut = SCY.balanceOf(receiver) - preScyBalance;
+        netSyOut = SY.balanceOf(receiver) - preSyBalance;
     }
 }

package/contracts/router/PendleRouter.sol

@@ -46,45 +46,45 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
 
     function getRouterImplementation(bytes4 sig) public view returns (address) {
         if (
-            sig == IPActionMintRedeem.mintScyFromToken.selector ||
-            sig == IPActionMintRedeem.redeemScyToToken.selector ||
+            sig == IPActionMintRedeem.mintSyFromToken.selector ||
+            sig == IPActionMintRedeem.redeemSyToToken.selector ||
             sig == IPActionMintRedeem.mintPyFromToken.selector ||
             sig == IPActionMintRedeem.redeemPyToToken.selector ||
-            sig == IPActionMintRedeem.mintPyFromScy.selector ||
-            sig == IPActionMintRedeem.redeemPyToScy.selector ||
+            sig == IPActionMintRedeem.mintPyFromSy.selector ||
+            sig == IPActionMintRedeem.redeemPyToSy.selector ||
             sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector ||
             sig == IPActionMintRedeem.redeemDueInterestAndRewardsThenSwapAll.selector
         ) {
             return ACTION_MINT_REDEEM;
         } else if (
-            sig == IPActionAddRemoveLiq.addLiquidityDualScyAndPt.selector ||
+            sig == IPActionAddRemoveLiq.addLiquidityDualSyAndPt.selector ||
             sig == IPActionAddRemoveLiq.addLiquidityDualTokenAndPt.selector ||
             sig == IPActionAddRemoveLiq.addLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySingleScy.selector ||
+            sig == IPActionAddRemoveLiq.addLiquiditySingleSy.selector ||
             sig == IPActionAddRemoveLiq.addLiquiditySingleToken.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquidityDualScyAndPt.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquidityDualSyAndPt.selector ||
             sig == IPActionAddRemoveLiq.removeLiquidityDualTokenAndPt.selector ||
             sig == IPActionAddRemoveLiq.removeLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySingleScy.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquiditySingleSy.selector ||
             sig == IPActionAddRemoveLiq.removeLiquiditySingleToken.selector
         ) {
             return ACTION_ADD_REMOVE_LIQ;
         } else if (
-            sig == IPActionSwapPT.swapExactPtForScy.selector ||
-            sig == IPActionSwapPT.swapPtForExactScy.selector ||
-            sig == IPActionSwapPT.swapScyForExactPt.selector ||
-            sig == IPActionSwapPT.swapExactScyForPt.selector ||
+            sig == IPActionSwapPT.swapExactPtForSy.selector ||
+            sig == IPActionSwapPT.swapPtForExactSy.selector ||
+            sig == IPActionSwapPT.swapSyForExactPt.selector ||
+            sig == IPActionSwapPT.swapExactSyForPt.selector ||
             sig == IPActionSwapPT.swapExactTokenForPt.selector ||
             sig == IPActionSwapPT.swapExactPtForToken.selector
         ) {
             return ACTION_SWAP_PT;
         } else if (
-            sig == IPActionSwapYT.swapExactYtForScy.selector ||
-            sig == IPActionSwapYT.swapScyForExactYt.selector ||
-            sig == IPActionSwapYT.swapExactScyForYt.selector ||
+            sig == IPActionSwapYT.swapExactYtForSy.selector ||
+            sig == IPActionSwapYT.swapSyForExactYt.selector ||
+            sig == IPActionSwapYT.swapExactSyForYt.selector ||
             sig == IPActionSwapYT.swapExactTokenForYt.selector ||
             sig == IPActionSwapYT.swapExactYtForToken.selector ||
-            sig == IPActionSwapYT.swapYtForExactScy.selector
+            sig == IPActionSwapYT.swapYtForExactSy.selector
         ) {
             return ACTION_SWAP_YT;
         } else if (

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 
 import "../kyberswap/KyberSwapHelper.sol";
 import "../../core/libraries/TokenHelper.sol";
-import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../core/libraries/Errors.sol";
 
@@ -17,63 +17,63 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
     constructor(address _kyberSwapRouter) KyberSwapHelper(_kyberSwapRouter) {}
 
     /**
-     * @notice swap token to baseToken through Uniswap's forks & use it to mint SCY
+     * @notice swap token to baseToken through Uniswap's forks & use it to mint SY
      */
-    function _mintScyFromToken(
+    function _mintSyFromToken(
         address receiver,
-        address SCY,
-        uint256 minScyOut,
+        address SY,
+        uint256 minSyOut,
         TokenInput calldata input
-    ) internal returns (uint256 netScyOut) {
+    ) internal returns (uint256 netSyOut) {
         _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
-        if (input.tokenIn != input.tokenMintScy) {
+        if (input.tokenIn != input.tokenMintSy) {
             _kyberswap(input.tokenIn, input.netTokenIn, input.kybercall);
         }
 
-        _safeApproveInf(input.tokenMintScy, SCY);
+        _safeApproveInf(input.tokenMintSy, SY);
 
-        uint256 tokenMintScyBal = _selfBalance(input.tokenMintScy);
-        uint256 nativeAmountToAttach = input.tokenMintScy == NATIVE ? tokenMintScyBal : 0;
+        uint256 tokenMintSyBal = _selfBalance(input.tokenMintSy);
+        uint256 nativeAmountToAttach = input.tokenMintSy == NATIVE ? tokenMintSyBal : 0;
 
-        netScyOut = ISuperComposableYield(SCY).deposit{ value: nativeAmountToAttach }(
+        netSyOut = IStandardizedYield(SY).deposit{ value: nativeAmountToAttach }(
             receiver,
-            input.tokenMintScy,
-            tokenMintScyBal,
-            minScyOut
+            input.tokenMintSy,
+            tokenMintSyBal,
+            minSyOut
         );
     }
 
     /**
-     * @notice redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks
+     * @notice redeem SY to baseToken -> swap baseToken to token through Uniswap's forks
      */
-    function _redeemScyToToken(
+    function _redeemSyToToken(
         address receiver,
-        address SCY,
-        uint256 netScyIn,
+        address SY,
+        uint256 netSyIn,
         TokenOutput calldata output,
         bool doPull
     ) internal returns (uint256 netTokenOut) {
         if (doPull) {
-            IERC20(SCY).safeTransferFrom(msg.sender, SCY, netScyIn);
+            IERC20(SY).safeTransferFrom(msg.sender, SY, netSyIn);
         }
 
-        if (output.tokenRedeemScy == output.tokenOut) {
-            netTokenOut = ISuperComposableYield(SCY).redeem(
+        if (output.tokenRedeemSy == output.tokenOut) {
+            netTokenOut = IStandardizedYield(SY).redeem(
                 receiver,
-                netScyIn,
-                output.tokenRedeemScy,
+                netSyIn,
+                output.tokenRedeemSy,
                 output.minTokenOut,
                 true
             );
         } else {
-            uint256 netTokenRedeemed = ISuperComposableYield(SCY).redeem(
+            uint256 netTokenRedeemed = IStandardizedYield(SY).redeem(
                 address(this),
-                netScyIn,
-                output.tokenRedeemScy,
+                netSyIn,
+                output.tokenRedeemSy,
                 1,
                 true
             );
-            _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
+            _kyberswap(output.tokenRedeemSy, netTokenRedeemed, output.kybercall);
 
             netTokenOut = _selfBalance(output.tokenOut);
 
@@ -85,7 +85,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
     }
 
     /**
-     * @notice swap token to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
+     * @notice swap token to baseToken through Uniswap's forks -> convert to SY -> convert to PT + YT
      */
     function _mintPyFromToken(
         address receiver,
@@ -93,16 +93,16 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         uint256 minPyOut,
         TokenInput calldata input
     ) internal returns (uint256 netPyOut) {
-        address SCY = IPYieldToken(YT).SCY();
+        address SY = IPYieldToken(YT).SY();
 
-        _mintScyFromToken(YT, SCY, 1, input);
+        _mintSyFromToken(YT, SY, 1, input);
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
     /**
-     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks.
+     * @notice redeem PT + YT to SY -> redeem SY 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 _redeemPyToToken(
@@ -113,7 +113,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         bool doPull
     ) internal returns (uint256 netTokenOut) {
         address PT = IPYieldToken(YT).PT();
-        address SCY = IPYieldToken(YT).SCY();
+        address SY = IPYieldToken(YT).SY();
 
         if (doPull) {
             bool needToBurnYt = (!IPYieldToken(YT).isExpired());
@@ -121,35 +121,35 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
             if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
-        uint256 amountScyOut = IPYieldToken(YT).redeemPY(SCY); // ignore return
+        uint256 amountSyOut = IPYieldToken(YT).redeemPY(SY); // ignore return
 
-        netTokenOut = _redeemScyToToken(receiver, SCY, amountScyOut, output, false);
+        netTokenOut = _redeemSyToToken(receiver, SY, amountSyOut, output, false);
     }
 
-    function _mintPyFromScy(
+    function _mintPyFromSy(
         address receiver,
         address YT,
-        uint256 netScyIn,
+        uint256 netSyIn,
         uint256 minPyOut,
         bool doPull
     ) internal returns (uint256 netPyOut) {
-        address SCY = IPYieldToken(YT).SCY();
+        address SY = IPYieldToken(YT).SY();
 
         if (doPull) {
-            IERC20(SCY).safeTransferFrom(msg.sender, YT, netScyIn);
+            IERC20(SY).safeTransferFrom(msg.sender, YT, netSyIn);
         }
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
-    function _redeemPyToScy(
+    function _redeemPyToSy(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minScyOut,
+        uint256 minSyOut,
         bool doPull
-    ) internal returns (uint256 netScyOut) {
+    ) internal returns (uint256 netSyOut) {
         address PT = IPYieldToken(YT).PT();
 
         if (doPull) {
@@ -158,7 +158,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
             if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
-        netScyOut = IPYieldToken(YT).redeemPY(receiver);
-        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
+        netSyOut = IPYieldToken(YT).redeemPY(receiver);
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 }

package/contracts/router/base/CallbackHelper.sol

@@ -3,26 +3,26 @@ pragma solidity 0.8.17;
 
 abstract contract CallbackHelper {
     enum ActionType {
-        SwapScyForExactYt,
-        SwapExactScyForYt,
-        SwapYtForScy,
+        SwapSyForExactYt,
+        SwapExactSyForYt,
+        SwapYtForSy,
         SwapExactYtForPt,
         SwapExactPtForYt
     }
 
     /// ------------------------------------------------------------
-    /// SwapExactScyForYt
+    /// SwapExactSyForYt
     /// ------------------------------------------------------------
 
-    function _encodeSwapExactScyForYt(address receiver, uint256 minYtOut)
+    function _encodeSwapExactSyForYt(address receiver, uint256 minYtOut)
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encode(ActionType.SwapExactScyForYt, receiver, minYtOut);
+        return abi.encode(ActionType.SwapExactSyForYt, receiver, minYtOut);
     }
 
-    function _decodeSwapExactScyForYt(bytes memory data)
+    function _decodeSwapExactSyForYt(bytes memory data)
         internal
         pure
         returns (address receiver, uint256 minYtOut)
@@ -31,47 +31,47 @@ abstract contract CallbackHelper {
     }
 
     /// ------------------------------------------------------------
-    /// SwapScyForExactYt
+    /// SwapSyForExactYt
     /// ------------------------------------------------------------
 
-    function _encodeSwapScyForExactYt(
+    function _encodeSwapSyForExactYt(
         address payer,
         address receiver,
-        uint256 maxScyIn
+        uint256 maxSyIn
     ) internal pure returns (bytes memory) {
-        return abi.encode(ActionType.SwapScyForExactYt, payer, receiver, maxScyIn);
+        return abi.encode(ActionType.SwapSyForExactYt, payer, receiver, maxSyIn);
     }
 
-    function _decodeSwapScyForExactYt(bytes memory data)
+    function _decodeSwapSyForExactYt(bytes memory data)
         internal
         pure
         returns (
             address payer,
             address receiver,
-            uint256 maxScyIn
+            uint256 maxSyIn
         )
     {
-        (, payer, receiver, maxScyIn) = abi.decode(data, (ActionType, address, address, uint256));
+        (, payer, receiver, maxSyIn) = abi.decode(data, (ActionType, address, address, uint256));
     }
 
     /// ------------------------------------------------------------
-    /// SwapYtForScy (common encode & decode)
+    /// SwapYtForSy (common encode & decode)
     /// ------------------------------------------------------------
 
-    function _encodeSwapYtForScy(address receiver, uint256 minScyOut)
+    function _encodeSwapYtForSy(address receiver, uint256 minSyOut)
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encode(ActionType.SwapYtForScy, receiver, minScyOut);
+        return abi.encode(ActionType.SwapYtForSy, receiver, minSyOut);
     }
 
-    function _decodeSwapYtForScy(bytes memory data)
+    function _decodeSwapYtForSy(bytes memory data)
         internal
         pure
-        returns (address receiver, uint256 minScyOut)
+        returns (address receiver, uint256 minSyOut)
     {
-        (, receiver, minScyOut) = abi.decode(data, (ActionType, address, uint256));
+        (, receiver, minSyOut) = abi.decode(data, (ActionType, address, uint256));
     }
 
     function _encodeSwapExactYtForPt(