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

package/contracts/router/ActionMintRedeem.sol

@@ -10,6 +10,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
     using Math for uint256;
     using Math for int256;
+    using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _kyberSwapRouter)
@@ -17,33 +18,26 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     {}
 
     /// @dev refer to the internal function
-    function mintScyFromToken(
+    function mintSyFromToken(
         address receiver,
-        address SCY,
-        uint256 minScyOut,
+        address SY,
+        uint256 minSyOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netScyOut) {
-        netScyOut = _mintScyFromToken(receiver, SCY, minScyOut, input);
+    ) external payable returns (uint256 netSyOut) {
+        netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
 
-        emit MintScyFromToken(
-            msg.sender,
-            receiver,
-            SCY,
-            input.tokenIn,
-            input.netTokenIn,
-            netScyOut
-        );
+        emit MintSyFromToken(msg.sender, receiver, SY, input.tokenIn, input.netTokenIn, netSyOut);
     }
 
     /// @dev refer to the internal function
-    function redeemScyToToken(
+    function redeemSyToToken(
         address receiver,
-        address SCY,
-        uint256 netScyIn,
+        address SY,
+        uint256 netSyIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut) {
-        netTokenOut = _redeemScyToToken(receiver, SCY, netScyIn, output, true);
-        emit RedeemScyToToken(msg.sender, receiver, SCY, netScyIn, output.tokenOut, netTokenOut);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyIn, output, true);
+        emit RedeemSyToToken(msg.sender, receiver, SY, netSyIn, output.tokenOut, netTokenOut);
     }
 
     /// @dev refer to the internal function
@@ -68,43 +62,43 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
-    function mintPyFromScy(
+    function mintPyFromSy(
         address receiver,
         address YT,
-        uint256 netScyIn,
+        uint256 netSyIn,
         uint256 minPyOut
     ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromScy(receiver, YT, netScyIn, minPyOut, true);
-        emit MintPyFromScy(msg.sender, receiver, YT, netScyIn, netPyOut);
+        netPyOut = _mintPyFromSy(receiver, YT, netSyIn, minPyOut, true);
+        emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
     }
 
-    function redeemPyToScy(
+    function redeemPyToSy(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut) {
-        netScyOut = _redeemPyToScy(receiver, YT, netPyIn, minScyOut, true);
-        emit RedeemPyToScy(msg.sender, receiver, YT, netPyIn, netScyOut);
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut) {
+        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut, true);
+        emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
     }
 
     function redeemDueInterestAndRewards(
         address user,
-        address[] calldata scys,
+        address[] calldata sys,
         address[] calldata yts,
         address[] calldata markets
     )
         external
         returns (
-            uint256[][] memory scyRewards,
+            uint256[][] memory syRewards,
             uint256[] memory ytInterests,
             uint256[][] memory ytRewards,
             uint256[][] memory marketRewards
         )
     {
-        scyRewards = new uint256[][](scys.length);
-        for (uint256 i = 0; i < scys.length; ++i) {
-            scyRewards[i] = ISuperComposableYield(scys[i]).claimRewards(user);
+        syRewards = new uint256[][](sys.length);
+        for (uint256 i = 0; i < sys.length; ++i) {
+            syRewards[i] = IStandardizedYield(sys[i]).claimRewards(user);
         }
 
         ytInterests = new uint256[](yts.length);
@@ -123,10 +117,10 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         }
         emit RedeemDueInterestAndRewards(
             user,
-            scys,
+            sys,
             yts,
             markets,
-            scyRewards,
+            syRewards,
             ytInterests,
             ytRewards,
             marketRewards
@@ -139,7 +133,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     }
 
     function redeemDueInterestAndRewardsThenSwapAll(
-        address[] calldata scys,
+        address[] calldata sys,
         RouterYtRedeemStruct calldata dataYT,
         address[] calldata markets,
         RouterSwapAllStruct calldata dataSwap
@@ -147,18 +141,18 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         if (dataSwap.tokens.length != dataSwap.kybercalls.length)
             revert Errors.ArrayLengthMismatch();
 
-        if (dataYT.tokenRedeemScys.length != dataYT.scyAddrs.length)
+        if (dataYT.tokenRedeemSys.length != dataYT.syAddrs.length)
             revert Errors.ArrayLengthMismatch();
 
         RouterTokenAmounts memory tokensOut = _newRouterTokenAmounts(dataSwap.tokens);
-        RouterTokenAmounts memory scysOut = _newRouterTokenAmounts(dataYT.scyAddrs);
+        RouterTokenAmounts memory sysOut = _newRouterTokenAmounts(dataYT.syAddrs);
 
-        // redeem SCY
-        for (uint256 i = 0; i < scys.length; ++i) {
-            ISuperComposableYield SCY = ISuperComposableYield(scys[i]);
+        // redeem SY
+        for (uint256 i = 0; i < sys.length; ++i) {
+            IStandardizedYield SY = IStandardizedYield(sys[i]);
 
-            address[] memory rewardTokens = SCY.getRewardTokens();
-            uint256[] memory rewardAmounts = SCY.claimRewards(msg.sender);
+            address[] memory rewardTokens = SY.getRewardTokens();
+            uint256[] memory rewardAmounts = SY.claimRewards(msg.sender);
             _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
         }
 
@@ -169,10 +163,10 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
             (uint256 interestAmount, uint256[] memory rewardAmounts) = YT
                 .redeemDueInterestAndRewards(msg.sender, true, true);
 
-            address scyAddr = YT.SCY();
+            address syAddr = YT.SY();
             address[] memory rewardTokens = YT.getRewardTokens();
 
-            _addTokenAmount(scysOut, scyAddr, interestAmount);
+            _addTokenAmount(sysOut, syAddr, interestAmount);
             _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
         }
 
@@ -186,8 +180,14 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         }
 
         // guaranteed no ETH, all rewards are ERC20
-        _transferFrom(tokensOut.tokens, msg.sender, address(this), tokensOut.amounts);
-        _redeemAllScys(scysOut, dataYT.tokenRedeemScys, tokensOut);
+        for (uint256 i = 0; i < tokensOut.tokens.length; ++i) {
+            IERC20(tokensOut.tokens[i]).safeTransferFrom(
+                msg.sender,
+                address(this),
+                tokensOut.amounts[i]
+            );
+        }
+        _redeemAllSys(sysOut, dataYT.tokenRedeemSys, tokensOut);
 
         // now swap all to outputToken
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
@@ -199,7 +199,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
 
         emit RedeemDueInterestAndRewardsThenSwapAll(
             msg.sender,
-            scys,
+            sys,
             dataYT.yts,
             markets,
             dataSwap.outputToken,
@@ -215,25 +215,25 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         return RouterTokenAmounts(tokens, new uint256[](tokens.length));
     }
 
-    /// @dev pull SCYs from users & redeem them, then add to tokensOut
-    function _redeemAllScys(
-        RouterTokenAmounts memory scys,
-        address[] calldata tokenRedeemScys,
+    /// @dev pull SYs from users & redeem them, then add to tokensOut
+    function _redeemAllSys(
+        RouterTokenAmounts memory sys,
+        address[] calldata tokenRedeemSys,
         RouterTokenAmounts memory tokensOut
     ) internal {
-        for (uint256 i = 0; i < scys.tokens.length; ++i) {
-            if (scys.amounts[i] == 0) continue;
+        for (uint256 i = 0; i < sys.tokens.length; ++i) {
+            if (sys.amounts[i] == 0) continue;
 
-            _transferFrom(scys.tokens[i], msg.sender, scys.tokens[i], scys.amounts[i]);
-            uint256 amountOut = ISuperComposableYield(scys.tokens[i]).redeem(
+            IERC20(sys.tokens[i]).safeTransferFrom(msg.sender, sys.tokens[i], sys.amounts[i]);
+            uint256 amountOut = IStandardizedYield(sys.tokens[i]).redeem(
                 address(this),
-                scys.amounts[i],
-                tokenRedeemScys[i],
+                sys.amounts[i],
+                tokenRedeemSys[i],
                 1,
                 true
             );
 
-            _addTokenAmount(tokensOut, tokenRedeemScys[i], amountOut);
+            _addTokenAmount(tokensOut, tokenRedeemSys[i], amountOut);
         }
     }
 

package/contracts/router/ActionSwapPT.sol

@@ -20,43 +20,39 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
-    function swapExactPtForScy(
+    function swapExactPtForSy(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut, uint256 netScyFee) {
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
-        (netScyOut, netScyFee) = IPMarket(market).swapExactPtForScy(
-            receiver,
-            exactPtIn,
-            EMPTY_BYTES
-        );
+        (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, exactPtIn, EMPTY_BYTES);
 
-        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
 
-        emit SwapPtAndScy(msg.sender, market, receiver, exactPtIn.neg(), netScyOut.Int());
+        emit SwapPtAndSy(msg.sender, market, receiver, exactPtIn.neg(), netSyOut.Int());
     }
 
     /**
-     * @notice Note that the amount of SCY out will be a bit more than `exactScyOut`, since an approximation is used. It's
-        guaranteed that the `netScyOut` is at least `exactScyOut`
+     * @notice Note that the amount of SY out will be a bit more than `exactSyOut`, since an approximation is used. It's
+        guaranteed that the `netSyOut` is at least `exactSyOut`
      */
-    function swapPtForExactScy(
+    function swapPtForExactSy(
         address receiver,
         address market,
-        uint256 exactScyOut,
+        uint256 exactSyOut,
         uint256 maxPtIn,
         ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn, uint256 netScyFee) {
+    ) external returns (uint256 netPtIn, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netPtIn, , ) = state.approxSwapPtForExactScy(
+        (netPtIn, , ) = state.approxSwapPtForExactSy(
             YT.newIndex(),
-            exactScyOut,
+            exactSyOut,
             block.timestamp,
             guessPtIn
         );
@@ -65,67 +61,63 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
 
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
-        uint256 netScyOut;
-        (netScyOut, netScyFee) = IPMarket(market).swapExactPtForScy(
-            receiver,
-            netPtIn,
-            EMPTY_BYTES
-        );
+        uint256 netSyOut;
+        (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, netPtIn, EMPTY_BYTES);
 
         // fail-safe
-        if (netScyOut < exactScyOut) assert(false);
+        if (netSyOut < exactSyOut) assert(false);
 
-        emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
+        emit SwapPtAndSy(msg.sender, market, receiver, netPtIn.neg(), exactSyOut.Int());
     }
 
-    function swapScyForExactPt(
+    function swapSyForExactPt(
         address receiver,
         address market,
         uint256 exactPtOut,
-        uint256 maxScyIn
-    ) external returns (uint256 netScyIn, uint256 netScyFee) {
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netScyIn, ) = state.swapScyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
+        (netSyIn, ) = state.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
-        if (netScyIn > maxScyIn) revert Errors.RouterExceededLimitScyIn(netScyIn, maxScyIn);
+        if (netSyIn > maxSyIn) revert Errors.RouterExceededLimitSyIn(netSyIn, maxSyIn);
 
-        IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
+        IERC20(SY).safeTransferFrom(msg.sender, market, netSyIn);
 
-        (, netScyFee) = IPMarket(market).swapScyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
+        (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
 
-        // no fail-safe since exactly netScyIn will go into the market
-        emit SwapPtAndScy(msg.sender, market, receiver, exactPtOut.Int(), netScyIn.neg());
+        // no fail-safe since exactly netSyIn will go into the market
+        emit SwapPtAndSy(msg.sender, market, receiver, exactPtOut.Int(), netSyIn.neg());
     }
 
-    function swapExactScyForPt(
+    function swapExactSyForPt(
         address receiver,
         address market,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
+        IERC20(SY).safeTransferFrom(msg.sender, market, exactSyIn);
 
-        (netPtOut, netScyFee) = _swapExactScyForPt(
+        (netPtOut, netSyFee) = _swapExactSyForPt(
             receiver,
             market,
             YT,
-            exactScyIn,
+            exactSyIn,
             minPtOut,
             guessPtOut
         );
 
-        emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
+        emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
     }
 
     /**
-     * @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 _mintScyFromToken & _swapExactScyForPt
+     * @notice swap from any ERC20 tokens, through Uniswap's forks, to get baseTokens to make SY, then swap
+        from SY to PT
+     * @dev simply a combination of _mintSyFromToken & _swapExactSyForPt
      */
     function swapExactTokenForPt(
         address receiver,
@@ -133,18 +125,18 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netPtOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        // all output SCY is transferred directly to the market
-        uint256 netScyUseToBuyPt = _mintScyFromToken(address(market), address(SCY), 1, input);
+        // all output SY is transferred directly to the market
+        uint256 netSyUseToBuyPt = _mintSyFromToken(address(market), address(SY), 1, input);
 
-        // SCY is already in the market, hence doPull = false
-        (netPtOut, netScyFee) = _swapExactScyForPt(
+        // SY is already in the market, hence doPull = false
+        (netPtOut, netSyFee) = _swapExactSyForPt(
             receiver,
             market,
             YT,
-            netScyUseToBuyPt,
+            netSyUseToBuyPt,
             minPtOut,
             guessPtOut
         );
@@ -160,29 +152,29 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     }
 
     /**
-     * @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
+     * @notice swap from PT to SY, then redeem SY to baseToken & swap through Uniswap's forks to get tokenOut
+     * @dev simply a combination of _swapExactPtForSy & _redeemSyToToken
      */
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netScyFee) {
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
-        // all output SCY is directly transferred to the SCY contract
-        uint256 netScyReceived;
-        (netScyReceived, netScyFee) = IPMarket(market).swapExactPtForScy(
-            address(SCY),
+        // all output SY is directly transferred to the SY contract
+        uint256 netSyReceived;
+        (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
+            address(SY),
             exactPtIn,
             EMPTY_BYTES
         );
 
-        // since all SCY is already at the SCY contract, doPull = false
-        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
+        // since all SY is already at the SY contract, doPull = false
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
 
         emit SwapPtAndToken(
             msg.sender,
@@ -194,26 +186,26 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         );
     }
 
-    function _swapExactScyForPt(
+    function _swapExactSyForPt(
         address receiver,
         address market,
         IPYieldToken YT,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) internal returns (uint256 netPtOut, uint256 netScyFee) {
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
 
-        (netPtOut, ) = state.approxSwapExactScyForPt(
+        (netPtOut, ) = state.approxSwapExactSyForPt(
             YT.newIndex(),
-            exactScyIn,
+            exactSyIn,
             block.timestamp,
             guessPtOut
         );
 
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
-        (, netScyFee) = IPMarket(market).swapScyForExactPt(receiver, netPtOut, EMPTY_BYTES);
+        (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, netPtOut, EMPTY_BYTES);
         // no fail-safe since exactly netPtOut >= minPtOut will be out
     }
 }

package/contracts/router/ActionSwapPTYT.sol

@@ -13,7 +13,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
     using Math for int256;
     using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
-    using SafeERC20 for ISuperComposableYield;
+    using SafeERC20 for IStandardizedYield;
     using SafeERC20 for IPYieldToken;
     using SafeERC20 for IPPrincipalToken;
 
@@ -29,14 +29,14 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         uint256 exactPtIn,
         uint256 minYtOut,
         ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut, uint256 netScyFee) {
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
         PT.safeTransferFrom(msg.sender, market, exactPtIn);
 
         uint256 totalPtToSwap;
-        (netYtOut, totalPtToSwap, netScyFee) = state.approxSwapExactPtForYt(
+        (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
             YT.newIndex(),
             exactPtIn,
             block.timestamp,
@@ -45,7 +45,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
 
         if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
 
-        IPMarket(market).swapExactPtForScy(
+        IPMarket(market).swapExactPtForSy(
             address(YT),
             totalPtToSwap,
             _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut)
@@ -60,14 +60,14 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         uint256 exactYtIn,
         uint256 minPtOut,
         ApproxParams calldata guessTotalPtSwapped
-    ) external returns (uint256 netPtOut, uint256 netScyFee) {
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
         YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
         uint256 totalPtSwapped;
-        (netPtOut, totalPtSwapped, netScyFee) = state.approxSwapExactYtForPt(
+        (netPtOut, totalPtSwapped, netSyFee) = state.approxSwapExactYtForPt(
             YT.newIndex(),
             exactYtIn,
             block.timestamp,
@@ -76,7 +76,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
 
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
-        IPMarket(market).swapScyForExactPt(
+        IPMarket(market).swapSyForExactPt(
             address(this),
             totalPtSwapped,
             _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut)