@pendle/core-v2 3.0.0-beta-2 → 3.0.0-beta-4

package/contracts/router/{ActionAddRemoveLiq.sol → ActionAddRemoveLiqV3.sol}

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "../interfaces/IPActionAddRemoveLiq.sol";
+import "../interfaces/IPActionAddRemoveLiqV3.sol";
 
-contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
+contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -20,16 +20,16 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    ) external payable returns (uint256 netLpOut, uint256 netPtUsed) {
+    ) external payable returns (uint256 netLpOut, uint256 netPtUsed, uint256 netSyInterm) {
         (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
 
-        uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);
+        netSyInterm = _mintSyFromToken(market, address(SY), 1, input);
         uint256 netSyUsed;
 
-        (,, netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(netSyDesired, netPtDesired, block.timestamp);
+        (,, netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(netSyInterm, netPtDesired, block.timestamp);
 
-        if (netSyDesired != netSyUsed) {
-            revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
+        if (netSyInterm != netSyUsed) {
+            revert Errors.RouterNotAllSyUsed(netSyInterm, netSyUsed);
         }
 
         // SY has been minted and transferred to the market
@@ -39,7 +39,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
         emit AddLiquidityDualTokenAndPt(
-            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netPtUsed, netLpOut
+            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netPtUsed, netLpOut, netSyInterm
         );
     }
 
@@ -82,7 +82,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netSyReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netPtLeft, netSyReceived, netSyFee,) = _fillLimit(receiver, netPtLeft, limit);
+            (netPtLeft, netSyReceived, netSyFee,) = _fillLimit(market, PT, netPtLeft, limit);
             _transferOut(address(PT), market, netPtLeft);
         }
 
@@ -119,15 +119,17 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         ApproxParams calldata guessPtReceivedFromSy,
         TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netLpOut, uint256 netSyFee) {
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netSyUsed = _mintSyFromToken(_entry_addLiquiditySingleSy(market, limit), address(SY), 1, input);
+        netSyInterm = _mintSyFromToken(_entry_addLiquiditySingleSy(market, limit), address(SY), 1, input);
 
         (netLpOut, netSyFee) =
-            _addLiquiditySingleSy(receiver, market, SY, YT, netSyUsed, minLpOut, guessPtReceivedFromSy, limit);
+            _addLiquiditySingleSy(receiver, market, SY, YT, netSyInterm, minLpOut, guessPtReceivedFromSy, limit);
 
-        emit AddLiquiditySingleToken(msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut);
+        emit AddLiquiditySingleToken(
+            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut, netSyInterm
+        );
     }
 
     function addLiquiditySingleSy(
@@ -166,7 +168,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netPtReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netPtReceived, netSyFee,) = _fillLimit(receiver, netSyLeft, limit);
+            (netSyLeft, netPtReceived, netSyFee,) = _fillLimit(market, SY, netSyLeft, limit);
             _transferOut(address(SY), market, netSyLeft);
         }
 
@@ -194,15 +196,16 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 minLpOut,
         uint256 minYtOut,
         TokenInput calldata input
-    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy, uint256 netSyInterm) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netSyUsed = _mintSyFromToken(address(this), address(SY), 1, input);
+        netSyInterm = _mintSyFromToken(address(this), address(SY), 1, input);
 
-        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyUsed, minLpOut, minYtOut);
+        (netLpOut, netYtOut, netSyMintPy) =
+            _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyInterm, minLpOut, minYtOut);
 
         emit AddLiquiditySingleTokenKeepYt(
-            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut, netYtOut
+            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut, netYtOut, netSyMintPy, netSyInterm
         );
     }
 
@@ -212,14 +215,15 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netSyIn,
         uint256 minLpOut,
         uint256 minYtOut
-    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
 
         _transferIn(address(SY), msg.sender, netSyIn);
 
-        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyIn, minLpOut, minYtOut);
+        (netLpOut, netYtOut, netSyMintPy) =
+            _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyIn, minLpOut, minYtOut);
 
-        emit AddLiquiditySingleSyKeepYt(msg.sender, market, receiver, netSyIn, netLpOut, netYtOut);
+        emit AddLiquiditySingleSyKeepYt(msg.sender, market, receiver, netSyIn, netSyMintPy, netLpOut, netYtOut);
     }
 
     function _addLiquiditySingleSyKeepYt(
@@ -230,24 +234,26 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netSyIn,
         uint256 minLpOut,
         uint256 minYtOut
-    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
         MarketState memory state = _readMarket(market);
 
         PYIndex pyIndex = YT.newIndex();
 
-        uint256 netSyToPt =
+        netSyMintPy =
             (netSyIn * state.totalPt.Uint()) / (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
 
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+
         // transfer SY to mint PY
-        _transferOut(address(SY), address(YT), netSyToPt);
+        _transferOut(address(SY), address(YT), netSyMintPy);
 
         // the rest of SY goes to market
-        _transferOut(address(SY), market, netSyIn - netSyToPt);
+        _transferOut(address(SY), market, netSyAddLiquidity);
 
         // PT goes to market, YT goes to receiver
         netYtOut = YT.mintPY(market, receiver);
 
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyIn - netSyToPt, netYtOut);
+        (netLpOut,,) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
         if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
@@ -261,20 +267,19 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netLpToRemove,
         TokenOutput calldata output,
         uint256 minPtOut
-    ) external returns (uint256 netTokenOut, uint256 netPtOut) {
+    ) external returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyInterm) {
         (IStandardizedYield SY,,) = IPMarket(market).readTokens();
 
         // burn LP, SY sent to SY, PT sent to receiver
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
-        uint256 netSyOut;
-        (netSyOut, netPtOut) = IPMarket(market).burn(address(SY), receiver, netLpToRemove);
+        (netSyInterm, netPtOut) = IPMarket(market).burn(address(SY), receiver, netLpToRemove);
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         // redeem SY to token
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
         emit RemoveLiquidityDualTokenAndPt(
-            msg.sender, market, output.tokenOut, receiver, netLpToRemove, netPtOut, netTokenOut
+            msg.sender, market, output.tokenOut, receiver, netLpToRemove, netPtOut, netTokenOut, netSyInterm
         );
     }
 
@@ -331,17 +336,18 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netLpToRemove,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY,,) = IPMarket(market).readTokens();
 
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
-        uint256 netSyReceived;
-        (netSyReceived, netSyFee) = _removeLiquiditySingleSy(address(SY), market, netLpToRemove, 1, limit);
+        (netSyInterm, netSyFee) = _removeLiquiditySingleSy(address(SY), market, netLpToRemove, 1, limit);
 
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
-        emit RemoveLiquiditySingleToken(msg.sender, market, output.tokenOut, receiver, netLpToRemove, netTokenOut);
+        emit RemoveLiquiditySingleToken(
+            msg.sender, market, output.tokenOut, receiver, netLpToRemove, netTokenOut, netSyInterm
+        );
     }
 
     function removeLiquiditySingleSy(

package/contracts/router/{ActionMisc.sol → ActionMiscV3.sol}

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "../interfaces/IPActionMisc.sol";
+import "./base/SimulateHelper.sol";
+import "../interfaces/IPActionMiscV3.sol";
 
-contract ActionMisc is IPActionMisc, ActionBase {
+contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
     function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
         external
         payable
@@ -25,26 +26,26 @@ contract ActionMisc is IPActionMisc, ActionBase {
     function mintPyFromToken(address receiver, address YT, uint256 minPyOut, TokenInput calldata input)
         external
         payable
-        returns (uint256 netPyOut)
+        returns (uint256 netPyOut, uint256 netSyInterm)
     {
         address SY = IPYieldToken(YT).SY();
 
-        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
-        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyToMint, minPyOut, false);
+        netSyInterm = _mintSyFromToken(YT, SY, 0, input);
+        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyInterm, minPyOut, false);
 
-        emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut);
+        emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut, netSyInterm);
     }
 
     function redeemPyToToken(address receiver, address YT, uint256 netPyIn, TokenOutput calldata output)
         external
-        returns (uint256 netTokenOut)
+        returns (uint256 netTokenOut, uint256 netSyInterm)
     {
         address SY = IPYieldToken(YT).SY();
 
-        uint256 netSyToRedeem = _redeemPyToSy(SY, YT, netPyIn, 1);
-        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
+        netSyInterm = _redeemPyToSy(SY, YT, netPyIn, 1);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyInterm, output, false);
 
-        emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut);
+        emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut, netSyInterm);
     }
 
     function mintPyFromSy(address receiver, address YT, uint256 netSyIn, uint256 minPyOut)
@@ -92,22 +93,29 @@ contract ActionMisc is IPActionMisc, ActionBase {
         _swapTokenInput(inp);
 
         netTokenOut = _selfBalance(inp.tokenMintSy);
-        if (netTokenOut < minTokenOut) revert Errors.RouterInsufficientTokenOut(netTokenOut, minTokenOut);
+        if (netTokenOut < minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, minTokenOut);
+        }
 
         _transferOut(receiver, receiver, netTokenOut);
     }
 
+    function swapTokenToTokenViaSy(
+        address receiver,
+        address SY,
+        TokenInput calldata input,
+        address tokenRedeemSy,
+        uint256 minTokenOut
+    ) external payable returns (uint256 netTokenOut, uint256 netSyInterm) {
+        netSyInterm = _mintSyFromToken(address(this), SY, 0, input);
+        netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
+    }
+
     // ----------------- MISC FUNCTIONS -----------------
 
-    function approveInf(MultiApproval[] calldata arr) external {
-        for (uint256 i = 0; i < arr.length;) {
-            MultiApproval calldata ele = arr[i];
-            for (uint256 j = 0; j < ele.tokens.length;) {
-                _safeApproveInf(ele.tokens[j], ele.spender);
-                unchecked {
-                    j++;
-                }
-            }
+    function boostMarkets(address[] memory markets) external {
+        for (uint256 i = 0; i < markets.length;) {
+            IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
             unchecked {
                 i++;
             }
@@ -140,32 +148,16 @@ contract ActionMisc is IPActionMisc, ActionBase {
         }
     }
 
-    function multicallRevert(uint256 gasLimit, Call3[] calldata calls)
+    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
         public
         payable
+        override(IPActionMiscV3, SimulateHelper)
         returns (bytes[] memory res, uint256[] memory gasUsed)
     {
-        uint256 length = calls.length;
-        res = new bytes[](length);
-        gasUsed = new uint256[](length);
-        Call3 calldata call;
-        for (uint256 i = 0; i < length;) {
-            call = calls[i];
-
-            uint256 gasBefore = gasleft();
-            (, res[i]) = address(this).delegatecall{gas: gasLimit}(
-                abi.encodeWithSignature("callThenRevert(address,bytes)", address(this), call.callData)
-            );
-            gasUsed[i] = gasBefore - gasleft();
-
-            unchecked {
-                ++i;
-            }
-        }
+        return super.multicallRevert(gasLimit, callDatas);
     }
 
-    function callThenRevert(address target, bytes memory callData) public payable {
-        (bool success, bytes memory resp) = target.delegatecall(callData);
-        revert Errors.CallThenRevertError(success, resp);
+    function callThenRevert(bytes memory callData) public payable override(IPActionMiscV3, SimulateHelper) {
+        return super.callThenRevert(callData);
     }
 }

package/contracts/router/{ActionSwapPT.sol → ActionSwapPTV3.sol}

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "../interfaces/IPActionSwapPT.sol";
+import "../interfaces/IPActionSwapPTV3.sol";
 
-contract ActionSwapPT is IPActionSwapPT, ActionBase {
+contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
     using PMath for uint256;
 
     // ------------------ SWAP TOKEN FOR PT ------------------
@@ -15,14 +15,14 @@ contract ActionSwapPT is IPActionSwapPT, ActionBase {
         ApproxParams calldata guessPtOut,
         TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netPtOut, uint256 netSyFee) {
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
 
-        uint256 netSyUseToBuyPt = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
-
-        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, netSyUseToBuyPt, minPtOut, guessPtOut, limit);
-
-        emit SwapPtAndToken(msg.sender, market, input.tokenIn, receiver, netPtOut.Int(), input.netTokenIn.neg());
+        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, netSyInterm, minPtOut, guessPtOut, limit);
+        emit SwapPtAndToken(
+            msg.sender, market, input.tokenIn, receiver, netPtOut.Int(), input.netTokenIn.neg(), netSyInterm
+        );
     }
 
     function swapExactSyForPt(
@@ -40,23 +40,23 @@ contract ActionSwapPT is IPActionSwapPT, ActionBase {
         emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
     }
 
-    // ------------------ SWAP PT FOR TOKEN ------------------
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
 
-        uint256 netSyReceived;
-        (netSyReceived, netSyFee) = _swapExactPtForSy(address(SY), market, exactPtIn, 0, limit);
+        (netSyInterm, netSyFee) = _swapExactPtForSy(address(SY), market, exactPtIn, 0, limit);
 
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
-        emit SwapPtAndToken(msg.sender, market, output.tokenOut, receiver, exactPtIn.neg(), netTokenOut.Int());
+        emit SwapPtAndToken(
+            msg.sender, market, output.tokenOut, receiver, exactPtIn.neg(), netTokenOut.Int(), netSyInterm
+        );
     }
 
     function swapExactPtForSy(

package/contracts/router/{ActionSwapYT.sol → ActionSwapYTV3.sol}

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "./base/ActionBaseCallback.sol";
-import "../interfaces/IPActionSwapYT.sol";
+import "../interfaces/IPActionSwapYTV3.sol";
 
-contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
+contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
     using PMath for uint256;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
@@ -20,14 +20,15 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
         ApproxParams calldata guessYtOut,
         TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netYtOut, uint256 netSyFee) {
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netSyUsedToBuyYT = _mintSyFromToken(_entry_swapExactSyForYt(YT, limit), address(SY), 1, input);
-        (netYtOut, netSyFee) =
-            _swapExactSyForYt(receiver, market, SY, YT, netSyUsedToBuyYT, minYtOut, guessYtOut, limit);
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForYt(YT, limit), address(SY), 1, input);
+        (netYtOut, netSyFee) = _swapExactSyForYt(receiver, market, SY, YT, netSyInterm, minYtOut, guessYtOut, limit);
 
-        emit SwapYtAndToken(msg.sender, market, input.tokenIn, receiver, netYtOut.Int(), input.netTokenIn.neg());
+        emit SwapYtAndToken(
+            msg.sender, market, input.tokenIn, receiver, netYtOut.Int(), input.netTokenIn.neg(), netSyInterm
+        );
     }
 
     function swapExactSyForYt(
@@ -63,7 +64,7 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
         bool doMarketOrder = true;
 
         if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netSyLeft, limit);
+            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), address(YT), netSyLeft);
             }
@@ -94,17 +95,17 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
         uint256 exactYtIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
 
-        uint256 netSyOut;
-
-        (netSyOut, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, exactYtIn, 0, limit);
+        (netSyInterm, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, exactYtIn, 0, limit);
 
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
-        emit SwapYtAndToken(msg.sender, market, output.tokenOut, receiver, exactYtIn.neg(), netTokenOut.Int());
+        emit SwapYtAndToken(
+            msg.sender, market, output.tokenOut, receiver, exactYtIn.neg(), netTokenOut.Int(), netSyInterm
+        );
     }
 
     function swapExactYtForSy(
@@ -138,7 +139,7 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
         bool doMarketOrder = true;
 
         if (!_isEmptyLimit(limit)) {
-            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netYtLeft, limit);
+            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(YT), address(YT), netYtLeft);
             }
@@ -173,10 +174,11 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBase {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 totalPtToSwap;
-        (, totalPtToSwap, netSyFee) =
+        (netYtOut, totalPtToSwap, netSyFee) =
             _readMarket(market).approxSwapExactPtForYt(YT.newIndex(), exactPtIn, block.timestamp, guessTotalPtToSwap);
 
         _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+
         IPMarket(market).swapExactPtForSy(
             address(YT), totalPtToSwap, _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
         );

package/contracts/router/PendleRouterHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPRouterHelper.sol";