@pendle/core-v2 5.0.7 → 5.1.0

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);
+    }
+}

package/contracts/router/math/ApproxStateLib.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
+
+enum ApproxStage {
+    INITIAL,
+    RANGE_SEARCHING,
+    RESULT_FINDING
+}
+
+struct ApproxState {
+    ApproxStage stage;
+    uint256 maxIteration;
+    uint256 eps;
+    uint256 startingGuess;
+    uint256 curGuess;
+    /// Defines the range that constrains the result.
+    /// This range will be dynamically adjusted if the result falls outside of it.
+    uint256[2] ranges;
+    /// Specifies the range within which the result must fall.
+    /// Any value outside this range is considered invalid.
+    uint256[2] hardBounds;
+}
+
+using ApproxStateLib for ApproxState global;
+
+/// A library for determining the next guess from the current / `ApproxState`
+/// state, dynamically adjusting the search range to fit the valid / result
+/// range.
+///
+/// @dev Invariants to maintain:
+/// - state.hardBounds should always include state.ranges
+/// - state.ranges should always include state.curGuess
+/// That is:
+///     state.hardBounds[0] <= state.ranges[0] <= state.curGuess <= state.ranges[1] <= state.hardBounds[1]
+library ApproxStateLib {
+    using PMath for uint256;
+    using ApproxStateLib for ApproxState;
+
+    uint256 internal constant GUESS_RANGE_TWEAK = (5 * PMath.ONE) / 100;
+
+    uint256 internal constant DEFAULT_MAX_ITERATION = 30;
+    uint256 internal constant DEFAULT_EPS = 5e13;
+
+    function initWithOffchain(ApproxParams memory approx) internal pure returns (ApproxState memory) {
+        if (approx.guessMin > approx.guessOffchain || approx.guessOffchain > approx.guessMax || approx.eps > PMath.ONE)
+            revert("Internal: INVALID_APPROX_PARAMS");
+        return
+            ApproxState({
+                stage: ApproxStage.RESULT_FINDING,
+                ranges: [approx.guessMin, approx.guessMax],
+                hardBounds: [approx.guessMin, approx.guessMax],
+                curGuess: approx.guessOffchain,
+                startingGuess: approx.guessOffchain,
+                maxIteration: approx.maxIteration,
+                eps: approx.eps
+            });
+    }
+
+    function initNoOffChain(
+        uint256 estimation,
+        uint256[2] memory hardBounds
+    ) internal pure returns (ApproxState memory) {
+        assert(hardBounds[0] <= hardBounds[1]);
+
+        uint256 startingGuess = PMath.clamp(estimation, hardBounds[0], hardBounds[1]);
+        uint256 rangesLower = PMath.max(startingGuess.tweakDown(GUESS_RANGE_TWEAK), hardBounds[0]);
+        uint256 rangesUpper = PMath.min(startingGuess.tweakUp(GUESS_RANGE_TWEAK), hardBounds[1]);
+        return
+            ApproxState({
+                stage: ApproxStage.INITIAL,
+                ranges: [rangesLower, rangesUpper],
+                hardBounds: hardBounds,
+                curGuess: startingGuess,
+                startingGuess: startingGuess,
+                maxIteration: DEFAULT_MAX_ITERATION,
+                eps: DEFAULT_EPS
+            });
+    }
+
+    function transitionDown(ApproxState memory state, bool excludeGuessFromRange) internal pure {
+        state.ranges[1] = state.curGuess;
+        if (excludeGuessFromRange) state.ranges[1]--;
+
+        if (state.stage == ApproxStage.INITIAL) {
+            state.stage = ApproxStage.RANGE_SEARCHING;
+            state.curGuess = state.ranges[0];
+        } else if (state.stage == ApproxStage.RANGE_SEARCHING) {
+            if (state.curGuess == state.hardBounds[0]) revert("Slippage: search range underflow");
+
+            bool shouldExtend = state.curGuess == state.ranges[0];
+            if (!shouldExtend) {
+                state.stage = ApproxStage.RESULT_FINDING;
+                moveGuessToMiddle(state);
+                return;
+            }
+            uint256 distToStartingGuess = state.startingGuess - state.ranges[0];
+            uint256 extendedLower = PMath.subWithLowerBound(state.ranges[0], distToStartingGuess, state.hardBounds[0]);
+            state.ranges[0] = extendedLower;
+            state.curGuess = extendedLower;
+        } else if (state.stage == ApproxStage.RESULT_FINDING) {
+            moveGuessToMiddle(state);
+        } else {
+            assert(false);
+        }
+    }
+
+    function transitionUp(ApproxState memory state, bool excludeGuessFromRange) internal pure {
+        state.ranges[0] = state.curGuess;
+        if (excludeGuessFromRange) state.ranges[0]++;
+
+        if (state.stage == ApproxStage.INITIAL) {
+            state.stage = ApproxStage.RANGE_SEARCHING;
+            state.curGuess = state.ranges[1];
+        } else if (state.stage == ApproxStage.RANGE_SEARCHING) {
+            if (state.curGuess == state.hardBounds[1]) revert("Slippage: search range overflow");
+
+            bool shouldExtend = state.curGuess == state.ranges[1];
+            if (!shouldExtend) {
+                state.stage = ApproxStage.RESULT_FINDING;
+                moveGuessToMiddle(state);
+                return;
+            }
+            uint256 distFromStartingGuess = state.ranges[1] - state.startingGuess;
+            uint256 extendedUpper = (
+                PMath.addWithUpperBound(state.ranges[1], distFromStartingGuess, state.hardBounds[1])
+            );
+            state.ranges[1] = extendedUpper;
+            state.curGuess = extendedUpper;
+        } else if (state.stage == ApproxStage.RESULT_FINDING) {
+            moveGuessToMiddle(state);
+        } else {
+            assert(false);
+        }
+    }
+
+    function moveGuessToMiddle(ApproxState memory state) internal pure {
+        if (state.ranges[0] > state.ranges[1]) revert("Slippage: guessMin > guessMax");
+        state.curGuess = (state.ranges[0] + state.ranges[1]) / 2;
+    }
+}

package/contracts/router/math/MarketApproxEstimateLib.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {MarketMathCore, MarketState} from "../../core/Market/MarketMathCore.sol";
+import {PYIndexLib, PYIndex} from "../../core/StandardizedYield/PYIndex.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
+
+library MarketApproxEstimateLib {
+    using MarketMathCore for MarketState;
+    using PYIndexLib for PYIndex;
+    using PMath for uint256;
+    using PMath for int256;
+
+    enum TokenType {
+        PT,
+        YT,
+        SY
+    }
+
+    function estimateAmount(
+        MarketState memory market,
+        PYIndex index,
+        uint256 blockTime,
+        uint256 amountIn,
+        TokenType tokenIn,
+        TokenType tokenOut
+    ) internal pure returns (uint256 estimatedAmountOut) {
+        uint256 assetToPtRate = uint256(
+            MarketMathCore._getExchangeRateFromImpliedRate(market.lastLnImpliedRate, market.expiry - blockTime)
+        );
+
+        uint256 ptToAssetRate = PMath.ONE.divDown(assetToPtRate);
+        uint256 ytToAssetRate = PMath.ONE - ptToAssetRate;
+
+        uint256 exactAssetIn;
+
+        if (tokenIn == TokenType.SY) {
+            exactAssetIn = index.syToAsset(amountIn);
+        } else if (tokenIn == TokenType.PT) {
+            exactAssetIn = amountIn.mulDown(ptToAssetRate);
+        } else {
+            exactAssetIn = amountIn.mulDown(ytToAssetRate);
+        }
+
+        if (tokenOut == TokenType.SY) {
+            estimatedAmountOut = index.assetToSy(exactAssetIn);
+        } else if (tokenOut == TokenType.PT) {
+            estimatedAmountOut = exactAssetIn.divDown(ptToAssetRate);
+        } else {
+            estimatedAmountOut = exactAssetIn.divDown(ytToAssetRate);
+        }
+    }
+
+    function estimateSwapExactSyForPt(
+        MarketState memory market,
+        PYIndex index,
+        uint256 blockTime,
+        uint256 amountSyIn
+    ) internal pure returns (uint256 estimatedPtOut) {
+        return estimateAmount(market, index, blockTime, amountSyIn, TokenType.SY, TokenType.PT);
+    }
+
+    function estimateSwapExactSyForYt(
+        MarketState memory market,
+        PYIndex index,
+        uint256 blockTime,
+        uint256 amountSyIn
+    ) internal pure returns (uint256 estimatedYtOut) {
+        return estimateAmount(market, index, blockTime, amountSyIn, TokenType.SY, TokenType.YT);
+    }
+
+    function estimateAddLiquidity(
+        MarketState memory market,
+        PYIndex index,
+        uint256 blockTime,
+        uint256 netPtOwning,
+        uint256 netSyOwning
+    ) internal pure returns (uint256 estimatedPtToAdd, uint256 estimatedSyToAdd) {
+        // Let `pa` be `estimatedPtToAdd`, `sa` be `estimatedSyToAdd`.
+
+        // Conditions to satisfy:
+        // +) Add liquidity amounts need to be proportional to the existing
+        //    liquidity:
+        //      pa / sa = totalPt / totalSy
+        //   => pa = totalPt / totalSy * sa
+        //
+        // +) Let `syToPtRate` be the spot price between the PT and SY amount.
+        //    Conversion between exessive/missing parts need to respect the
+        //    current price:
+        //      (sa - netSyOwning) * syToPtRate = netPtOwning - pa
+        //  <=> (sa - netSyOwning) * syToPtRate = netPtOwning - totalPt / totalSy * sa
+        //  <=> (sa - netSyOwning) * syToPtRate * totalSy = netPtOwning * totalSy - totalPt * sa
+        //
+        //  Let x = syToPtRate * totalSy (x can be calculated with the function `estimateAmount` above).
+        //      (sa - netSyOwning) * x = netPtOwning * totalSy - totalPt * sa
+        //  <=> sa * x - netSyOwning * x = netPtOwning * totalSy - totalPt * sa
+        //  <=> sa * (x + totalPt) = netPtOwning * totalSy + netSyOwning * x
+
+        uint256 totalSy = market.totalSy.Uint();
+        uint256 totalPt = market.totalPt.Uint();
+        uint256 x = estimateSwapExactSyForPt(market, index, blockTime, totalSy);
+        uint256 sa = (netPtOwning * totalSy + netSyOwning * x) / (x + totalPt);
+        uint256 pa = (totalPt * sa) / totalSy;
+
+        return (pa, sa);
+    }
+}

package/contracts/router/{base → math}/MarketApproxLib.sol

@@ -3,15 +3,7 @@ pragma solidity ^0.8.0;
 
 import "../../core/libraries/math/PMath.sol";
 import "../../core/Market/MarketMathCore.sol";
-
-struct ApproxParams {
-    uint256 guessMin;
-    uint256 guessMax;
-    uint256 guessOffchain; // pass 0 in to skip this variable
-    uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2
-    uint256 eps; // the max eps between the returned result & the correct result, base 1e18. Normally this number will be set
-    // to 1e15 (1e18/1000 = 0.1%)
-}
+import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 
 /// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
 /// it's necessary to run an approximation algorithm, because by default there only exists the Pt to Sy formula