@pendle/core-v2 5.0.7 → 5.1.0

package/contracts/router/ActionMiscV3.sol

@@ -6,6 +6,8 @@ import "../interfaces/IPActionMiscV3.sol";
 import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
+    uint256 private constant NOT_FOUND = type(uint256).max;
+
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -16,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,
@@ -26,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,
@@ -40,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,
@@ -93,6 +98,114 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function redeemDueInterestAndRewardsV2(
+        IStandardizedYield[] calldata SYs,
+        RedeemYtIncomeToTokenStruct[] calldata YTs,
+        IPMarket[] calldata markets,
+        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);
+
+        for (uint256 i = 0; i < SYs.length; ++i) {
+            _add(swaps, netSwaps, SYs[i].getRewardTokens(), SYs[i].claimRewards(msg.sender));
+        }
+
+        netInterests = new uint256[](YTs.length);
+        for (uint256 i = 0; i < YTs.length; ++i) {
+            uint256[] memory netRewards;
+            (netInterests[i], netRewards) = YTs[i].yt.redeemDueInterestAndRewards(
+                msg.sender,
+                YTs[i].doRedeemInterest,
+                YTs[i].doRedeemRewards
+            );
+
+            if (YTs[i].doRedeemRewards) _add(swaps, netSwaps, YTs[i].yt.getRewardTokens(), netRewards);
+        }
+
+        for (uint256 i = 0; i < markets.length; ++i) {
+            _add(swaps, netSwaps, markets[i].getRewardTokens(), markets[i].redeemRewards(msg.sender));
+        }
+
+        for (uint256 i = 0; i < swaps.length; ++i) {
+            _transferIn(swaps[i].tokenIn, msg.sender, netSwaps[i]);
+        }
+
+        for (uint256 i = 0; i < YTs.length; ++i) {
+            if (netInterests[i] == 0) continue;
+            IStandardizedYield SY = IStandardizedYield(YTs[i].yt.SY());
+            netInterests[i] = _redeemSyAndAdd(
+                swaps,
+                netSwaps,
+                SY,
+                netInterests[i],
+                YTs[i].tokenRedeemSy,
+                YTs[i].minTokenRedeemOut
+            );
+        }
+
+        for (uint256 i = 0; i < swaps.length; ++i) netOutFromSwaps[i] = _swap(swaps[i], netSwaps[i], pendleSwap, true);
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function swapTokensToTokens(
+        IPSwapAggregator pendleSwap,
+        SwapDataExtra[] calldata swaps,
+        uint256[] calldata netSwaps
+    ) external payable returns (uint256[] memory netOutFromSwaps) {
+        netOutFromSwaps = new uint256[](swaps.length);
+
+        for (uint256 i = 0; i < swaps.length; ++i) {
+            _transferIn(swaps[i].tokenIn, msg.sender, netSwaps[i]);
+        }
+
+        for (uint256 i = 0; i < swaps.length; ++i) {
+            netOutFromSwaps[i] = _swap(swaps[i], netSwaps[i], pendleSwap, false);
+        }
+    }
+
+    /// @dev Deprecated, please use swapTokensToTokens which support unwrapping ETH too
     function swapTokenToToken(
         address receiver,
         uint256 minTokenOut,
@@ -106,6 +219,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         _transferOut(inp.tokenMintSy, receiver, netTokenOut);
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
     function swapTokenToTokenViaSy(
         address receiver,
         address SY,
@@ -117,7 +231,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
-    /// @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 exitPreExpToToken(
         address receiver,
         address market,
@@ -135,7 +249,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
     }
 
-    /// @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 exitPreExpToSy(
         address receiver,
         address market,
@@ -198,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,
@@ -228,6 +342,73 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
     }
 
+    function _redeemSyAndAdd(
+        SwapDataExtra[] calldata swaps,
+        uint256[] memory netSwaps,
+        IStandardizedYield SY,
+        uint256 netSyToRedeem,
+        address tokenRedeemSy,
+        uint256 minTokenRedeemSy
+    ) internal returns (uint256 netTokenOut) {
+        _transferFrom(SY, msg.sender, address(SY), netSyToRedeem);
+
+        uint256 index = _find(swaps, tokenRedeemSy);
+        if (index == NOT_FOUND) {
+            return SY.redeem(msg.sender, netSyToRedeem, tokenRedeemSy, minTokenRedeemSy, true);
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyToRedeem, tokenRedeemSy, minTokenRedeemSy, true);
+        netSwaps[index] += netTokenOut;
+    }
+
+    function _add(
+        SwapDataExtra[] calldata swaps,
+        uint256[] memory netSwaps,
+        address[] memory tokens,
+        uint256[] memory amounts
+    ) internal pure {
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            uint256 index = _find(swaps, tokens[i]);
+            if (index == NOT_FOUND) continue;
+
+            netSwaps[index] += amounts[i];
+        }
+    }
+
+    function _swap(
+        SwapDataExtra calldata $,
+        uint256 netSwap,
+        IPSwapAggregator pendleSwap,
+        bool needScale
+    ) internal returns (uint256 netTokenOut) {
+        SwapType swapType = $.swapData.swapType;
+        assert(swapType != SwapType.NONE);
+
+        if (swapType == SwapType.ETH_WETH) {
+            _wrap_unwrap_ETH($.tokenIn, $.tokenOut, netSwap);
+
+            netTokenOut = netSwap;
+        } else {
+            assert($.swapData.needScale == needScale);
+
+            _transferOut($.tokenIn, address(pendleSwap), netSwap);
+
+            uint256 preBalance = _selfBalance($.tokenOut);
+            IPSwapAggregator(pendleSwap).swap($.tokenIn, netSwap, $.swapData);
+            netTokenOut = _selfBalance($.tokenOut) - preBalance;
+        }
+
+        require(netTokenOut >= $.minOut, "Slippage: INSUFFICIENT_TOKEN_OUT");
+        _transferOut($.tokenOut, msg.sender, netTokenOut);
+    }
+
+    function _find(SwapDataExtra[] calldata swaps, address token) internal pure returns (uint256 index) {
+        for (uint256 i = 0; i < swaps.length; ++i) {
+            if (swaps[i].tokenIn == token) return i;
+        }
+        return NOT_FOUND;
+    }
+
     function _exitPostExpToSy(
         bool setReceiverToSy,
         address receiver,
@@ -290,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,