@pendle/core-v2 5.0.7 → 5.1.1-beta

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,

package/contracts/router/ActionSwapYTV3.sol

@@ -4,8 +4,9 @@ pragma solidity ^0.8.17;
 import "./base/ActionBase.sol";
 import "./base/CallbackHelper.sol";
 import "../interfaces/IPActionSwapYTV3.sol";
+import {ActionDelegateBase} from "./base/ActionDelegateBase.sol";
 
-contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
+contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionDelegateBase {
     using PMath for uint256;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
@@ -13,6 +14,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
 
     // ------------------ SWAP TOKEN FOR YT ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactTokenForYt(
         address receiver,
         address market,
@@ -21,6 +23,10 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
+        if (canUseOnchainApproximation(guessYtOut, limit)) {
+            return delegateToSwapExactTokenForYtSimple(receiver, market, minYtOut, input);
+        }
+
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(_entry_swapExactSyForYt(YT, limit), address(SY), 1, input);
@@ -37,6 +43,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactSyForYt(
         address receiver,
         address market,
@@ -45,6 +52,10 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         ApproxParams calldata guessYtOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        if (canUseOnchainApproximation(guessYtOut, limit)) {
+            return delegateToSwapExactSyForYtSimple(receiver, market, exactSyIn, minYtOut);
+        }
+
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(SY, msg.sender, _entry_swapExactSyForYt(YT, limit), exactSyIn);
 
@@ -54,6 +65,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
 
     // ------------------ SWAP TOKEN FOR TOKEN ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactYtForToken(
         address receiver,
         address market,
@@ -79,6 +91,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         );
     }
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactYtForSy(
         address receiver,
         address market,
@@ -95,6 +108,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
 
     // ------------------ SWAP PT FOR YT ------------------
 
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactPtForYt(
         address receiver,
         address market,
@@ -124,6 +138,8 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
     }
 
     // ------------------ SWAP YT FOR PT ------------------
+
+    /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactYtForPt(
         address receiver,
         address market,

package/contracts/router/base/ActionBase.sol

@@ -6,7 +6,7 @@ import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPAllActionTypeV3.sol";
 import "../../interfaces/IPMarket.sol";
-import "../../router/base/MarketApproxLib.sol";
+import "../../router/math/MarketApproxLib.sol";
 
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
@@ -162,7 +162,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     // ----------------- PT SWAP -----------------
 
     function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : market;
+        return _entry_swapExactPtForSy(market, !_isEmptyLimit(limit));
+    }
+
+    function _entry_swapExactPtForSy(address market, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : market;
     }
 
     function _swapExactPtForSy(
@@ -199,7 +203,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     }
 
     function _entry_swapExactSyForPt(address market, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : market;
+        return _entry_swapExactSyForPt(market, !_isEmptyLimit(limit));
+    }
+
+    function _entry_swapExactSyForPt(address market, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : market;
     }
 
     function _swapExactSyForPt(
@@ -241,7 +249,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     // ----------------- YT SWAP -----------------
 
     function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+        return _entry_swapExactYtForSy(YT, !_isEmptyLimit(limit));
+    }
+
+    function _entry_swapExactYtForSy(IPYieldToken YT, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : address(YT);
     }
 
     function _swapExactYtForSy(
@@ -281,7 +293,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     }
 
     function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+        return _entry_swapExactSyForYt(YT, !_isEmptyLimit(limit));
+    }
+
+    function _entry_swapExactSyForYt(IPYieldToken YT, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : address(YT);
     }
 
     function _swapExactSyForYt(
@@ -373,4 +389,38 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }
+
+    // ----------------- ADD & REMOVE LIQUIDITY -----------------
+
+    function _entry_addLiquiditySinglePt(address market, LimitOrderData calldata lim) internal view returns (address) {
+        return _entry_addLiquiditySinglePt(market, !_isEmptyLimit(lim));
+    }
+
+    function _entry_addLiquiditySinglePt(address market, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : market;
+    }
+
+    function _entry_addLiquiditySingleSy(address market, LimitOrderData calldata lim) internal view returns (address) {
+        return _entry_addLiquiditySingleSy(market, !_isEmptyLimit(lim));
+    }
+
+    function _entry_addLiquiditySingleSy(address market, bool hasLimitOrder) internal view returns (address) {
+        return hasLimitOrder ? address(this) : market;
+    }
+
+    // ----------------- MISC HELPER -----------------
+
+    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))
+            }
+        }
+    }
 }

package/contracts/router/base/ActionDelegateBase.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ActionBase} from "./ActionBase.sol";
+import {IPActionSimple} from "../../interfaces/IPActionSimple.sol";
+import {ApproxParams, TokenInput, LimitOrderData} from "../../interfaces/IPAllActionTypeV3.sol";
+
+contract ActionDelegateBase is ActionBase {
+    function delegateToAddLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.addLiquiditySinglePtSimple, (receiver, market, netPtIn, minLpOut)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256));
+    }
+
+    function delegateToAddLiquiditySingleTokenSimple(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        TokenInput calldata input
+    ) internal returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.addLiquiditySingleTokenSimple, (receiver, market, minLpOut, input)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256, uint256));
+    }
+
+    function delegateToAddLiquiditySingleSySimple(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.addLiquiditySingleSySimple, (receiver, market, netSyIn, minLpOut)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256));
+    }
+
+    function delegateToRemoveLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minPtOut
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.removeLiquiditySinglePtSimple, (receiver, market, netLpToRemove, minPtOut)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256));
+    }
+
+    function delegateToSwapExactTokenForPtSimple(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        TokenInput calldata input
+    ) internal returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.swapExactTokenForPtSimple, (receiver, market, minPtOut, input)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256, uint256));
+    }
+
+    function delegateToSwapExactSyForPtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.swapExactSyForPtSimple, (receiver, market, exactSyIn, minPtOut)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256));
+    }
+
+    function delegateToSwapExactTokenForYtSimple(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) internal returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.swapExactTokenForYtSimple, (receiver, market, minYtOut, input)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256, uint256));
+    }
+
+    function delegateToSwapExactSyForYtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minYtOut
+    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
+        (bool success, bytes memory res) = _delegateToSelf(
+            abi.encodeCall(IPActionSimple.swapExactSyForYtSimple, (receiver, market, exactSyIn, minYtOut)),
+            /* allowFailure= */ false
+        );
+        assert(success);
+        return abi.decode(res, (uint256, uint256));
+    }
+
+    function canUseOnchainApproximation(
+        ApproxParams calldata approx,
+        LimitOrderData calldata limit
+    ) internal pure returns (bool) {
+        return approx.guessOffchain == 0 && _isEmptyLimit(limit);
+    }
+}