@pendle/core-v2 3.0.0-beta-3 → 3.0.0-beta-5

package/contracts/interfaces/{IPActionSwapYT.sol → IPActionSwapYTV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionType.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionSwapYT {
+interface IPActionSwapYTV3 {
     event SwapYtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,7 +19,8 @@ interface IPActionSwapYT {
         address indexed token,
         address receiver,
         int256 netYtToAccount,
-        int256 netTokenToAccount
+        int256 netTokenToAccount,
+        uint256 netSyInterm
     );
 
     event SwapPtAndYt(
@@ -30,31 +31,23 @@ interface IPActionSwapYT {
         int256 netYtToAccount
     );
 
-    function swapExactSyForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
+        TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external returns (uint256 netYtOut, uint256 netSyFee);
-
-    function swapExactYtForSy(
-        address receiver,
-        address market,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function swapExactTokenForYt(
+    function swapExactSyForYt(
         address receiver,
         address market,
+        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netYtOut, uint256 netSyFee);
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
         address receiver,
@@ -62,7 +55,15 @@ interface IPActionSwapYT {
         uint256 exactYtIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapExactYtForSy(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function swapExactPtForYt(
         address receiver,
@@ -77,6 +78,6 @@ interface IPActionSwapYT {
         address market,
         uint256 exactYtIn,
         uint256 minPtOut,
-        ApproxParams calldata guessTotalPtSwapped
+        ApproxParams calldata guessTotalPtFromSwap
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllActionV3.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "./IPActionAddRemoveLiqV3.sol";
+import "./IPActionSwapPTV3.sol";
+import "./IPActionSwapYTV3.sol";
+import "./IPActionMiscV3.sol";
+import "./IPMarketSwapCallback.sol";
+import "./IDiamondLoupe.sol";
+
+interface IPAllActionV3 is
+    IPActionAddRemoveLiqV3,
+    IPActionSwapPTV3,
+    IPActionSwapYTV3,
+    IPActionMiscV3,
+    IPMarketSwapCallback,
+    IDiamondLoupe
+{}

package/contracts/interfaces/IPLimitRouter.sol

@@ -60,6 +60,11 @@ struct FillOrderParams {
 }
 
 interface IPOrderMixin is IPOrderMixinType {
+    struct OrderStatus {
+        uint128 filledAmount;
+        uint128 remaining;
+    }
+
     event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
     event OrderFilled(
@@ -126,22 +131,19 @@ interface ILimitOrderCallee is IPOrderMixinType {
 }
 
 interface IPLimitRouter is IPOrderMixin {
-    struct MultiApproval {
-        address[] tokens;
-        address spender;
-    }
-
     function cancelSingle(Order calldata order) external;
 
     function cancelBatch(Order[] calldata orders) external;
 
-    function approveInf(MultiApproval[] calldata arr) external;
-
-    function remaining(bytes32 orderHash) external view returns (uint256);
-
-    function remainingRaw(bytes32 orderHash) external view returns (uint256);
+    function orderStatusesRaw(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts);
 
-    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory);
+    function orderStatuses(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainings, uint256[] memory filledAmounts);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../interfaces/IPAllActionType.sol";
+import "../interfaces/IPAllActionTypeV3.sol";
 
 interface IPRouterHelper {
     /**

package/contracts/limit/PendleLimitRouter.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./PendleOrderMixin.sol";
 import "./helpers/NonceManager.sol";
@@ -10,7 +10,9 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
     using ArgumentsDecoder for bytes;
     using Address for address;
 
-    constructor(address _WNATIVE) initializer PendleOrderMixin(_WNATIVE) {}
+    constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
+        _disableInitializers();
+    }
 
     /// @notice Cancels multiple orders by setting remaining amount to zero
     function cancelBatch(Order[] calldata orders) external {
@@ -19,51 +21,44 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
         }
     }
 
-    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++;
-                }
-            }
-            unchecked {
-                i++;
-            }
-        }
-    }
-
     /// @notice Cancels order by setting remaining amount to zero
     function cancelSingle(Order calldata order) public {
         require(order.maker == msg.sender, "LOP: Access denied");
 
         bytes32 orderHash = hashOrder(order);
-        require(_remaining[orderHash] != _ORDER_FILLED, "LOP: already filled");
-        _remaining[orderHash] = _ORDER_FILLED;
+        require(_status[orderHash].remaining != _ORDER_FILLED, "LOP: already filled");
+        _status[orderHash].remaining = _ORDER_FILLED;
 
         emit OrderCanceled(msg.sender, orderHash);
     }
 
-    function remaining(bytes32 orderHash) external view returns (uint256) {
-        uint256 amount = _remaining[orderHash];
-        require(amount != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");
-        unchecked {
-            amount -= 1;
-        }
-        return amount;
-    }
+    function orderStatusesRaw(bytes32[] memory orderHashes)
+        public
+        view
+        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts)
+    {
+        uint256 len = orderHashes.length;
+        remainingsRaw = new uint256[](len);
+        filledAmounts = new uint256[](len);
 
-    function remainingRaw(bytes32 orderHash) external view returns (uint256) {
-        return _remaining[orderHash];
+        for (uint256 i = 0; i < len; i++) {
+            OrderStatus memory status = _status[orderHashes[i]];
+            (remainingsRaw[i], filledAmounts[i]) = (status.remaining, status.filledAmount);
+        }
     }
 
-    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory) {
-        uint256[] memory results = new uint256[](orderHashes.length);
-        for (uint256 i = 0; i < orderHashes.length; i++) {
-            results[i] = _remaining[orderHashes[i]];
+    function orderStatuses(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainings, uint256[] memory filledAmounts)
+    {
+        (remainings, filledAmounts) = orderStatusesRaw(orderHashes);
+        for (uint256 i = 0; i < remainings.length; i++) {
+            require(remainings[i] != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");
+            unchecked {
+                remainings[i] -= 1;
+            }
         }
-        return results;
     }
 
     function DOMAIN_SEPARATOR() external view returns (bytes32) {

package/contracts/limit/PendleOrderMixin.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -36,15 +36,17 @@ abstract contract PendleOrderMixin is
         "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
     );
 
-    uint256 internal constant _ORDER_DOES_NOT_EXIST = 0;
-    uint256 internal constant _ORDER_FILLED = 1;
+    uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
+    uint128 internal constant _ORDER_FILLED = 1;
 
     address public feeRecipient;
     uint96 public lnFeeRateRoot;
 
     address private immutable WNATIVE;
 
-    mapping(bytes32 => uint256) internal _remaining;
+    mapping(bytes32 => OrderStatus) internal _status;
+
+    uint256[100] private __gap;
 
     constructor(address _WNATIVE) {
         WNATIVE = _WNATIVE;
@@ -288,12 +290,14 @@ abstract contract PendleOrderMixin is
         for (uint256 i = 0; i < len; i = _inc1(i)) {
             FillOrderParams memory param = params[i];
 
-            (bytes32 orderHash, uint256 remainingMakerAmount) = _checkSig_doPermit(param.order, param.signature);
+            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
+                _checkSig_doPermit(param.order, param.signature);
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
                 remainingMakerAmount = remainingMakerAmount - netMaking;
-                _remaining[orderHash] = remainingMakerAmount + 1;
+                _status[orderHash] =
+                    OrderStatus((remainingMakerAmount + 1).Uint128(), (filledMakerAmount + netMaking).Uint128());
             }
 
             param.makingAmount = netMaking;
@@ -337,12 +341,13 @@ abstract contract PendleOrderMixin is
 
     function _checkSig_doPermit(Order memory order, bytes memory signature)
         internal
-        returns (bytes32, /*orderHash*/ uint256 /*remainingMakerAmount*/ )
+        returns (bytes32, /*orderHash*/ uint256, /*remainingMakerAmount*/ uint256 /*filledMakerAmount*/ )
     {
         bytes32 orderHash = hashOrder(order);
-        uint256 remainingMakerAmount = _remaining[orderHash];
+        OrderStatus memory status = _status[orderHash];
+        (uint256 remainingMakerAmount, uint256 filledMakerAmount) = (status.remaining, status.filledAmount);
 
-        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0);
+        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0, filledMakerAmount);
 
         if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
             require(SignatureChecker.isValidSignatureNow(order.maker, orderHash, signature), "LOP: bad signature");
@@ -354,7 +359,7 @@ abstract contract PendleOrderMixin is
                 // proceed only if permit length is enough to store address
                 (address token, bytes memory permit) = order.permit.decodeTargetAndCalldata();
                 _permitMemory(token, permit);
-                require(_remaining[orderHash] == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
+                require(_status[orderHash].remaining == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
             }
         } else {
             unchecked {
@@ -362,7 +367,7 @@ abstract contract PendleOrderMixin is
             }
         }
 
-        return (orderHash, remainingMakerAmount);
+        return (orderHash, remainingMakerAmount, filledMakerAmount);
     }
 
     // ----------------- simple helper functions functions -----------------
@@ -397,6 +402,7 @@ abstract contract PendleOrderMixin is
             _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenIn);
             token = NATIVE;
         }
+        _safeApproveInf(token, SY);
         return
             IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
     }

package/contracts/limit/helpers/NonceManager.sol

@@ -8,6 +8,8 @@ contract NonceManager {
 
     mapping(address => uint256) public nonce;
 
+    uint256[100] private __gap;
+
     /// @notice Advances nonce by one
     function increaseNonce() external {
         advanceNonce(1);

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(market, 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(market, 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 payable 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,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/SimulateHelper.sol";
-import "../interfaces/IPActionMisc.sol";
+import "../interfaces/IPActionMiscV3.sol";
 
-contract ActionMisc is IPActionMisc, ActionBase, SimulateHelper {
+contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
     function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
         external
         payable
@@ -26,26 +26,26 @@ contract ActionMisc is IPActionMisc, ActionBase, SimulateHelper {
     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)
@@ -93,29 +93,27 @@ contract ActionMisc is IPActionMisc, ActionBase, SimulateHelper {
         _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);
     }
 
-    // ----------------- 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++;
-                }
-            }
-            unchecked {
-                i++;
-            }
-        }
+    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);
     }
 
-    function marketsBoost(address[] memory markets) external {
+    // ----------------- MISC FUNCTIONS -----------------
+
+    function boostMarkets(address[] memory markets) external {
         for (uint256 i = 0; i < markets.length;) {
             IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
             unchecked {
@@ -153,13 +151,13 @@ contract ActionMisc is IPActionMisc, ActionBase, SimulateHelper {
     function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
         public
         payable
-        override(IPActionMisc, SimulateHelper)
+        override(IPActionMiscV3, SimulateHelper)
         returns (bytes[] memory res, uint256[] memory gasUsed)
     {
         return super.multicallRevert(gasLimit, callDatas);
     }
 
-    function callThenRevert(bytes memory callData) public payable override(IPActionMisc, SimulateHelper) {
+    function callThenRevert(bytes memory callData) public payable override(IPActionMiscV3, SimulateHelper) {
         return super.callThenRevert(callData);
     }
 }