@pendle/core-v2 5.0.7-beta → 5.1.0

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -4,7 +4,9 @@ pragma solidity ^0.8.17;
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionAddRemoveLiqV3.sol";
 
-contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
+import {ActionDelegateBase} from "./base/ActionDelegateBase.sol";
+
+contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDelegateBase {
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -14,6 +16,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
     using PYIndexLib for PYIndex;
 
     // ------------------ ADD LIQUIDITY DUAL ------------------
+
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,
@@ -77,6 +81,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
     // ------------------ ADD LIQUIDITY SINGLE PT ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function addLiquiditySinglePt(
         address receiver,
         address market,
@@ -85,6 +90,9 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         ApproxParams calldata guessPtSwapToSy,
         LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
+        if (canUseOnchainApproximation(guessPtSwapToSy, limit)) {
+            return delegateToAddLiquiditySinglePtSimple(receiver, market, netPtIn, minLpOut);
+        }
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_addLiquiditySinglePt(market, limit), netPtIn);
 
@@ -123,12 +131,9 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
     }
 
-    function _entry_addLiquiditySinglePt(address market, LimitOrderData calldata lim) internal view returns (address) {
-        return !_isEmptyLimit(lim) ? address(this) : market;
-    }
-
     // ------------------ ADD LIQUIDITY SINGLE TOKEN ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function addLiquiditySingleToken(
         address receiver,
         address market,
@@ -137,6 +142,10 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
+        if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
+            return delegateToAddLiquiditySingleTokenSimple(receiver, market, minLpOut, input);
+        }
+
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(_entry_addLiquiditySingleSy(market, limit), address(SY), 1, input);
@@ -163,6 +172,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function addLiquiditySingleSy(
         address receiver,
         address market,
@@ -171,6 +181,10 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         ApproxParams calldata guessPtReceivedFromSy,
         LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
+        if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
+            return delegateToAddLiquiditySingleSySimple(receiver, market, netSyIn, minLpOut);
+        }
+
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         _transferFrom(SY, msg.sender, _entry_addLiquiditySingleSy(market, limit), netSyIn);
@@ -189,10 +203,6 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         emit AddLiquiditySingleSy(msg.sender, market, receiver, netSyIn, netLpOut);
     }
 
-    function _entry_addLiquiditySingleSy(address market, LimitOrderData calldata lim) internal view returns (address) {
-        return !_isEmptyLimit(lim) ? address(this) : market;
-    }
-
     function _addLiquiditySingleSy(
         address receiver,
         address market,
@@ -236,6 +246,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
     // ------------------ ADD LIQUIDITY SINGLE TOKEN KEEP YT ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function addLiquiditySingleTokenKeepYt(
         address receiver,
         address market,
@@ -330,6 +341,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
     // ------------------ REMOVE LIQUIDITY DUAL ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function removeLiquidityDualTokenAndPt(
         address receiver,
         address market,
@@ -377,6 +389,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
     }
 
     // ------------------ REMOVE LIQUIDITY SINGLE PT ------------------
+
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function removeLiquiditySinglePt(
         address receiver,
         address market,
@@ -385,6 +399,10 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         ApproxParams calldata guessPtReceivedFromSy,
         LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
+            return delegateToRemoveLiquiditySinglePtSimple(receiver, market, netLpToRemove, minPtOut);
+        }
+
         uint256 netSyLeft;
 
         // execute the burn
@@ -415,6 +433,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
     // ------------------ REMOVE LIQUIDITY SINGLE TOKEN ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function removeLiquiditySingleToken(
         address receiver,
         address market,
@@ -441,6 +460,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function removeLiquiditySingleSy(
         address receiver,
         address market,

package/contracts/router/ActionMiscV3.sol

@@ -7,7 +7,6 @@ import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     uint256 private constant NOT_FOUND = type(uint256).max;
-    address private constant SKIP_REDEEM_SY = address(0x1);
 
     function mintSyFromToken(
         address receiver,
@@ -19,6 +18,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit MintSyFromToken(msg.sender, input.tokenIn, SY, receiver, input.netTokenIn, netSyOut);
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function redeemSyToToken(
         address receiver,
         address SY,
@@ -29,6 +29,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit RedeemSyToToken(msg.sender, output.tokenOut, SY, receiver, netSyIn, netTokenOut);
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function mintPyFromToken(
         address receiver,
         address YT,
@@ -43,6 +44,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut, netSyInterm);
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function redeemPyToToken(
         address receiver,
         address YT,
@@ -104,6 +106,45 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         IPSwapAggregator pendleSwap,
         SwapDataExtra[] calldata swaps
     ) external returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests) {
+        if (swaps.length == 0) {
+            return (netOutFromSwaps, __redeemDueInterestAndRewardsV2NoSwap(SYs, YTs, markets));
+        } else {
+            return __redeemDueInterestAndRewardsV2AndSwap(SYs, YTs, markets, pendleSwap, swaps);
+        }
+    }
+
+    function __redeemDueInterestAndRewardsV2NoSwap(
+        IStandardizedYield[] calldata SYs,
+        RedeemYtIncomeToTokenStruct[] calldata YTs,
+        IPMarket[] calldata markets
+    ) private returns (uint256[] memory netInterests) {
+        netInterests = new uint256[](YTs.length);
+        for (uint256 i = 0; i < SYs.length; ++i) SYs[i].claimRewards(msg.sender);
+
+        for (uint256 i = 0; i < YTs.length; ++i) {
+            (uint256 netSyInt, ) = YTs[i].yt.redeemDueInterestAndRewards(
+                msg.sender,
+                YTs[i].doRedeemInterest,
+                YTs[i].doRedeemRewards
+            );
+
+            if (netSyInt == 0) continue;
+
+            IStandardizedYield SY = IStandardizedYield(YTs[i].yt.SY());
+            _transferFrom(SY, msg.sender, address(SY), netSyInt);
+            netInterests[i] = SY.redeem(msg.sender, netSyInt, YTs[i].tokenRedeemSy, YTs[i].minTokenRedeemOut, true);
+        }
+
+        for (uint256 i = 0; i < markets.length; ++i) markets[i].redeemRewards(msg.sender);
+    }
+
+    function __redeemDueInterestAndRewardsV2AndSwap(
+        IStandardizedYield[] calldata SYs,
+        RedeemYtIncomeToTokenStruct[] calldata YTs,
+        IPMarket[] calldata markets,
+        IPSwapAggregator pendleSwap,
+        SwapDataExtra[] calldata swaps
+    ) private returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests) {
         netOutFromSwaps = new uint256[](swaps.length);
         uint256[] memory netSwaps = new uint256[](swaps.length);
 
@@ -190,6 +231,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function exitPreExpToToken(
         address receiver,
         address market,
@@ -207,6 +249,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function exitPreExpToSy(
         address receiver,
         address market,
@@ -269,7 +312,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem + p.netSyFromSwap;
     }
 
-    /// @dev The interface might change in the future, check with Pendle team before use
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function exitPostExpToToken(
         address receiver,
         address market,
@@ -428,20 +471,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         revert Errors.SimulationResults(success, result);
     }
 
-    function _delegateToSelf(
-        bytes memory data,
-        bool allowFailure
-    ) internal returns (bool success, bytes memory result) {
-        (success, result) = address(this).delegatecall(data);
-
-        if (!success && !allowFailure) {
-            assembly {
-                // We use Yul's revert() to bubble up errors from the target contract.
-                revert(add(32, result), mload(result))
-            }
-        }
-    }
-
     function _callToReflector(address payable reflector, bytes memory data) internal returns (bytes memory) {
         return IPReflector(reflector).reflect(data);
     }

package/contracts/router/ActionSimple.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IPMarket} from "../interfaces/IPMarket.sol";
+import {IStandardizedYield} from "../interfaces/IStandardizedYield.sol";
+import {IPPrincipalToken} from "../interfaces/IPPrincipalToken.sol";
+import {IPActionSimple} from "../interfaces/IPActionSimple.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {PYIndexLib, IPYieldToken, PYIndex} from "../core/StandardizedYield/PYIndex.sol";
+import {MarketState} from "../core/Market/MarketMathCore.sol";
+import {PMath} from "../core/libraries/math/PMath.sol";
+
+import {CallbackHelper} from "./base/CallbackHelper.sol";
+import {MarketApproxPtInLibOnchain, MarketApproxPtOutLibOnchain} from "./math/MarketApproxLibOnchain.sol";
+import {TokenInput, TokenOutput} from "../interfaces/IPAllActionTypeV3.sol";
+import {ActionBase} from "./base/ActionBase.sol";
+
+contract ActionSimple is ActionBase, IPActionSimple {
+    using MarketApproxPtInLibOnchain for MarketState;
+    using MarketApproxPtOutLibOnchain for MarketState;
+    using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
+    using PMath for uint256;
+
+    // ------------------ SWAP TOKEN FOR PT ------------------
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use swapExactTokenForPt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function swapExactTokenForPtSimple(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForPt(market, false), address(SY), 1, input);
+
+        (netPtOut, netSyFee) = _swapExactSyForPtSimple(receiver, market, netSyInterm, minPtOut);
+        emit SwapPtAndToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netPtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
+        );
+    }
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use swapExactSyForPt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function swapExactSyForPtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        _transferFrom(SY, msg.sender, _entry_swapExactSyForPt(market, false), exactSyIn);
+
+        (netPtOut, netSyFee) = _swapExactSyForPtSimple(receiver, market, exactSyIn, minPtOut);
+        emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
+    }
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use swapExactTokenForYt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function swapExactTokenForYtSimple(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForYt(YT, false), address(SY), 1, input);
+        (netYtOut, netSyFee) = _swapExactSyForYtSimple(receiver, market, SY, YT, netSyInterm, minYtOut);
+
+        emit SwapYtAndToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netYtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
+        );
+    }
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use swapExactSyForYt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function swapExactSyForYtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minYtOut
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        _transferFrom(SY, msg.sender, _entry_swapExactSyForYt(YT, false), exactSyIn);
+
+        (netYtOut, netSyFee) = _swapExactSyForYtSimple(receiver, market, SY, YT, exactSyIn, minYtOut);
+        emit SwapYtAndSy(msg.sender, market, receiver, netYtOut.Int(), exactSyIn.neg());
+    }
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use addLiquiditySinglePt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function addLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut
+    ) external returns (uint256 netLpOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, _entry_addLiquiditySinglePt(market, false), netPtIn);
+
+        uint256 netPtLeft = netPtIn;
+        uint256 netSyReceived;
+
+        (uint256 netPtSwapMarket, , , ) = _readMarket(market).approxSwapPtToAddLiquidityOnchain(
+            YT.newIndex(),
+            netPtLeft,
+            netSyReceived,
+            block.timestamp
+        );
+
+        // execute the swap
+        (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+            market,
+            netPtSwapMarket,
+            EMPTY_BYTES
+        );
+
+        netPtLeft -= netPtSwapMarket;
+        netSyReceived += netSyOutMarket;
+        netSyFee += netSyFeeMarket;
+
+        // execute the addLiquidity
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyReceived, netPtLeft);
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+
+        emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
+    }
+
+    // ------------------ ADD LIQUIDITY SINGLE TOKEN ------------------
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use addLiquiditySingleToken from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function addLiquiditySingleTokenSimple(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        netSyInterm = _mintSyFromToken(_entry_addLiquiditySingleSy(market, false), address(SY), 1, input);
+
+        (netLpOut, netSyFee) = _addLiquiditySingleSySimple(receiver, market, SY, YT, netSyInterm, minLpOut);
+
+        emit AddLiquiditySingleToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut,
+            netSyInterm
+        );
+    }
+
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use addLiquiditySingleSy from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function addLiquiditySingleSySimple(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut
+    ) external returns (uint256 netLpOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        _transferFrom(SY, msg.sender, _entry_addLiquiditySingleSy(market, false), netSyIn);
+
+        (netLpOut, netSyFee) = _addLiquiditySingleSySimple(receiver, market, SY, YT, netSyIn, minLpOut);
+
+        emit AddLiquiditySingleSy(msg.sender, market, receiver, netSyIn, netLpOut);
+    }
+
+    function _addLiquiditySingleSySimple(
+        address receiver,
+        address market,
+        IStandardizedYield /*SY*/,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 minLpOut
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        uint256 netSyLeft = netSyIn;
+        uint256 netPtReceived;
+
+        (uint256 netPtOutMarket, , , ) = _readMarket(market).approxSwapSyToAddLiquidityOnchain(
+            YT.newIndex(),
+            netSyLeft,
+            netPtReceived,
+            block.timestamp
+        );
+
+        (uint256 netSySwapMarket, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
+            market,
+            netPtOutMarket,
+            EMPTY_BYTES
+        );
+
+        netSyLeft -= netSySwapMarket;
+        netPtReceived += netPtOutMarket;
+        netSyFee += netSyFeeMarket;
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyLeft, netPtReceived);
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+    }
+
+    // ------------------ REMOVE LIQUIDITY SINGLE PT ------------------
+    /// @notice This function is for internal router use only and should not be called directly.
+    /// @dev Use removeLiquiditySinglePt from the main router instead.
+    /// @dev The interface of this simple function is subject to change without notice.
+    function removeLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minPtOut
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        uint256 netSyLeft;
+
+        // execute the burn
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+        (uint256 netSyOutBurn, uint256 netPtOutBurn) = IPMarket(market).burn(
+            _entry_swapExactSyForPt(market, false),
+            receiver,
+            netLpToRemove
+        );
+        netSyLeft += netSyOutBurn;
+        netPtOut += netPtOutBurn;
+
+        (uint256 netPtOutSwap, uint256 netSyFeeSwap) = _swapExactSyForPtSimple(receiver, market, netSyLeft, 0);
+        netPtOut += netPtOutSwap;
+        netSyFee += netSyFeeSwap;
+
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
+
+        emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
+    }
+
+    function _swapExactSyForPtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 netSyLeft = exactSyIn;
+
+        (uint256 netPtOutMarket, , ) = _readMarket(market).approxSwapExactSyForPtOnchain(
+            YT.newIndex(),
+            netSyLeft,
+            block.timestamp
+        );
+
+        (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, "");
+
+        netPtOut += netPtOutMarket;
+        netSyFee += netSyFeeMarket;
+
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
+    }
+
+    function _swapExactSyForYtSimple(
+        address receiver,
+        address market,
+        IStandardizedYield /* SY */,
+        IPYieldToken YT,
+        uint256 exactSyIn,
+        uint256 minYtOut
+    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
+        uint256 netSyLeft = exactSyIn;
+
+        (uint256 netYtOutMarket, , ) = _readMarket(market).approxSwapExactSyForYtOnchain(
+            YT.newIndex(),
+            netSyLeft,
+            block.timestamp
+        );
+
+        (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+            address(YT),
+            netYtOutMarket, // exactPtIn = netYtOut
+            _encodeSwapExactSyForYt(receiver, YT)
+        );
+
+        netYtOut += netYtOutMarket;
+        netSyFee += netSyFeeMarket;
+
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+}

package/contracts/router/ActionSwapPTV3.sol

@@ -3,11 +3,13 @@ pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionSwapPTV3.sol";
+import {ActionDelegateBase} from "./base/ActionDelegateBase.sol";
 
-contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
+contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
     using PMath for uint256;
 
     // ------------------ SWAP TOKEN FOR PT ------------------
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactTokenForPt(
         address receiver,
         address market,
@@ -16,6 +18,10 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
+        if (canUseOnchainApproximation(guessPtOut, limit)) {
+            return delegateToSwapExactTokenForPtSimple(receiver, market, minPtOut, input);
+        }
+
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
         netSyInterm = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
 
@@ -31,6 +37,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactSyForPt(
         address receiver,
         address market,
@@ -39,6 +46,10 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         ApproxParams calldata guessPtOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        if (canUseOnchainApproximation(guessPtOut, limit)) {
+            return delegateToSwapExactSyForPtSimple(receiver, market, exactSyIn, minPtOut);
+        }
+
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
         _transferFrom(SY, msg.sender, _entry_swapExactSyForPt(market, limit), exactSyIn);
 
@@ -46,6 +57,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactPtForToken(
         address receiver,
         address market,
@@ -71,6 +83,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactPtForSy(
         address receiver,
         address market,