@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/router/base/ActionBase.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/libraries/Errors.sol";
 import "../../core/libraries/TokenHelper.sol";
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPAllActionTypeV3.sol";
 import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPYieldToken.sol";
-import "../../interfaces/IStandardizedYield.sol";
 import "../../router/math/MarketApproxLibV2.sol";
+import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
 import "./CallbackHelper.sol";
 
@@ -22,10 +22,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
 
     // ----------------- MINT REDEEM SY PY -----------------
 
-    function _mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata inp)
-        internal
-        returns (uint256 netSyOut)
-    {
+    function _mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) internal returns (uint256 netSyOut) {
         SwapType swapType = inp.swapData.swapType;
 
         uint256 netTokenMintSy;
@@ -50,23 +52,36 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
 
         IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
-            inp.tokenIn, inp.netTokenIn, inp.swapData
+            inp.tokenIn,
+            inp.netTokenIn,
+            inp.swapData
         );
     }
 
-    function __mintSy(address receiver, address SY, uint256 netTokenMintSy, uint256 minSyOut, TokenInput calldata inp)
-        private
-        returns (uint256 netSyOut)
-    {
+    function __mintSy(
+        address receiver,
+        address SY,
+        uint256 netTokenMintSy,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) private returns (uint256 netSyOut) {
         uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
         _safeApproveInf(inp.tokenMintSy, SY);
-        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(receiver, inp.tokenMintSy, netTokenMintSy, minSyOut);
+        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(
+            receiver,
+            inp.tokenMintSy,
+            netTokenMintSy,
+            minSyOut
+        );
     }
 
-    function _redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
-        internal
-        returns (uint256 netTokenOut)
-    {
+    function _redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) internal returns (uint256 netTokenOut) {
         SwapType swapType = out.swapData.swapType;
 
         if (swapType == SwapType.NONE) {
@@ -90,10 +105,13 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         if (netTokenOut < out.minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
     }
 
-    function __redeemSy(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
-        private
-        returns (uint256 netTokenRedeemed)
-    {
+    function __redeemSy(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) private returns (uint256 netTokenRedeemed) {
         if (doPull) {
             _transferFrom(IERC20(SY), msg.sender, SY, netSyIn);
         }
@@ -101,10 +119,14 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
     }
 
-    function _mintPyFromSy(address receiver, address SY, address YT, uint256 netSyIn, uint256 minPyOut, bool doPull)
-        internal
-        returns (uint256 netPyOut)
-    {
+    function _mintPyFromSy(
+        address receiver,
+        address SY,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut,
+        bool doPull
+    ) internal returns (uint256 netPyOut) {
         if (doPull) {
             _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
         }
@@ -113,10 +135,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         if (netPyOut < minPyOut) revert("Slippage: INSUFFICIENT_PT_YT_OUT");
     }
 
-    function _redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
-        internal
-        returns (uint256 netSyOut)
-    {
+    function _redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
         address PT = IPYieldToken(YT).PT();
 
         _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
@@ -151,7 +175,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         uint256 minSyOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netPtLeft = exactPtIn;
         bool doMarketOrder = true;
@@ -166,8 +190,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         }
 
         if (doMarketOrder) {
-            (uint256 netSyOutMarket, uint256 netSyFeeMarket) =
-                IPMarket(market).swapExactPtForSy(receiver, netPtLeft, EMPTY_BYTES);
+            (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                receiver,
+                netPtLeft,
+                EMPTY_BYTES
+            );
 
             netSyOut += netSyOutMarket;
             netSyFee += netSyFeeMarket;
@@ -192,7 +219,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         ApproxParams calldata guessPtOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         uint256 netSyLeft = exactSyIn;
         bool doMarketOrder = true;
 
@@ -206,8 +233,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         }
 
         if (doMarketOrder) {
-            (uint256 netPtOutMarket,) =
-                _readMarket(market).approxSwapExactSyForPtV2(YT.newIndex(), netSyLeft, block.timestamp, guessPtOut);
+            (uint256 netPtOutMarket, ) = _readMarket(market).approxSwapExactSyForPtV2(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessPtOut
+            );
 
             (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);
 
@@ -252,12 +283,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         if (doMarketOrder) {
             uint256 preSyBalance = SY.balanceOf(receiver);
 
-            (, uint256 netSyFeeMarket) = IPMarket(market)
-                .swapSyForExactPt(
-                    address(YT),
-                    netYtLeft, // exactPtOut = netYtLeft
-                    _encodeSwapYtForSy(receiver, YT)
-                );
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
+                address(YT),
+                netYtLeft, // exactPtOut = netYtLeft
+                _encodeSwapYtForSy(receiver, YT)
+            );
 
             // avoid stack issue
             netSyFee += netSyFeeMarket;
@@ -298,15 +328,18 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         }
 
         if (doMarketOrder) {
-            (uint256 netYtOutMarket,) =
-                _readMarket(market).approxSwapExactSyForYtV2(YT.newIndex(), netSyLeft, block.timestamp, guessYtOut);
+            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYtV2(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessYtOut
+            );
 
-            (, uint256 netSyFeeMarket) = IPMarket(market)
-                .swapExactPtForSy(
-                    address(YT),
-                    netYtOutMarket, // exactPtIn = netYtOut
-                    _encodeSwapExactSyForYt(receiver, YT)
-                );
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                address(YT),
+                netYtOutMarket, // exactPtIn = netYtOut
+                _encodeSwapExactSyForYt(receiver, YT)
+            );
 
             netYtOut += netYtOutMarket;
             netSyFee += netSyFeeMarket;
@@ -316,17 +349,24 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     }
 
     // ----------------- LIMIT ORDERS -----------------
-    function _fillLimit(address receiver, IERC20 tokenIn, uint256 netInput, LimitOrderData calldata lim)
-        internal
-        returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder)
-    {
+    function _fillLimit(
+        address receiver,
+        IERC20 tokenIn,
+        uint256 netInput,
+        LimitOrderData calldata lim
+    ) internal returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder) {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
         if (lim.normalFills.length != 0) {
             _safeApproveInf(address(tokenIn), lim.limitRouter);
-            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee,) =
-                router.fill(lim.normalFills, receiver, netLeft, lim.optData, EMPTY_BYTES);
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, ) = router.fill(
+                lim.normalFills,
+                receiver,
+                netLeft,
+                lim.optData,
+                EMPTY_BYTES
+            );
             netOut += actualMaking;
             netLeft -= actualTaking;
             netSyFee += totalFee;
@@ -336,8 +376,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             address YT = lim.flashFills[0].order.YT;
             OrderType orderType = lim.flashFills[0].order.orderType;
 
-            (,, uint256 totalFee, bytes memory ret) = router.fill(
-                lim.flashFills, YT, type(uint256).max, lim.optData, abi.encode(orderType, YT, netLeft, receiver)
+            (, , uint256 totalFee, bytes memory ret) = router.fill(
+                lim.flashFills,
+                YT,
+                type(uint256).max,
+                lim.optData,
+                abi.encode(orderType, YT, netLeft, receiver)
             );
             (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
 
@@ -373,10 +417,10 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
 
     // ----------------- MISC HELPER -----------------
 
-    function _delegateToSelf(bytes memory data, bool allowFailure)
-        internal
-        returns (bool success, bytes memory result)
-    {
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
         (success, result) = address(this).delegatecall(data);
 
         if (!success && !allowFailure) {

package/contracts/router/base/ActionDelegateBase.sol

@@ -1,19 +1,20 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {IPActionSimple} from "../../interfaces/IPActionSimple.sol";
-import {ApproxParams, LimitOrderData, TokenInput} from "../../interfaces/IPAllActionTypeV3.sol";
 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)
-    {
+    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
+            /* allowFailure= */ false
         );
         assert(success);
         return abi.decode(res, (uint256, uint256));
@@ -27,21 +28,21 @@ contract ActionDelegateBase is ActionBase {
     ) internal returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
         (bool success, bytes memory res) = _delegateToSelf(
             abi.encodeCall(IPActionSimple.addLiquiditySingleTokenSimple, (receiver, market, minLpOut, input)),
-            /* allowFailure= */
-            false
+            /* 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)
-    {
+    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
+            /* allowFailure= */ false
         );
         assert(success);
         return abi.decode(res, (uint256, uint256));
@@ -55,8 +56,7 @@ contract ActionDelegateBase is ActionBase {
     ) internal returns (uint256 netPtOut, uint256 netSyFee) {
         (bool success, bytes memory res) = _delegateToSelf(
             abi.encodeCall(IPActionSimple.removeLiquiditySinglePtSimple, (receiver, market, netLpToRemove, minPtOut)),
-            /* allowFailure= */
-            false
+            /* allowFailure= */ false
         );
         assert(success);
         return abi.decode(res, (uint256, uint256));
@@ -70,21 +70,21 @@ contract ActionDelegateBase is ActionBase {
     ) internal returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
         (bool success, bytes memory res) = _delegateToSelf(
             abi.encodeCall(IPActionSimple.swapExactTokenForPtSimple, (receiver, market, minPtOut, input)),
-            /* allowFailure= */
-            false
+            /* 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)
-    {
+    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
+            /* allowFailure= */ false
         );
         assert(success);
         return abi.decode(res, (uint256, uint256));
@@ -98,31 +98,30 @@ contract ActionDelegateBase is ActionBase {
     ) internal returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
         (bool success, bytes memory res) = _delegateToSelf(
             abi.encodeCall(IPActionSimple.swapExactTokenForYtSimple, (receiver, market, minYtOut, input)),
-            /* allowFailure= */
-            false
+            /* 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)
-    {
+    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
+            /* allowFailure= */ false
         );
         assert(success);
         return abi.decode(res, (uint256, uint256));
     }
 
-    function canUseOnchainApproximation(ApproxParams calldata approx, LimitOrderData calldata limit)
-        internal
-        pure
-        returns (bool)
-    {
+    function canUseOnchainApproximation(
+        ApproxParams calldata approx,
+        LimitOrderData calldata limit
+    ) internal pure returns (bool) {
         return approx.guessOffchain == 0 && _isEmptyLimit(limit);
     }
 }

package/contracts/router/base/CallbackHelper.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 abstract contract CallbackHelper {
@@ -59,11 +59,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactYtForPt(address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactYtForPt(
+        address receiver,
+        uint256 netPtOut,
+        IPPrincipalToken PT,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactYtForPt);
 
@@ -76,11 +77,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-    {
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -90,11 +89,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactPtForYt(address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactPtForYt(
+        address receiver,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactPtForYt);
 
@@ -107,11 +107,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-    {
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))

package/contracts/router/math/ApproxStateLib.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {PMath} from "../../core/libraries/math/PMath.sol";
 import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
 
 enum ApproxStage {
     INITIAL,
@@ -46,39 +46,38 @@ library ApproxStateLib {
 
     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
-        });
+        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)
-    {
+    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
-        });
+        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 {
@@ -125,8 +124,9 @@ library ApproxStateLib {
                 return;
             }
             uint256 distFromStartingGuess = state.ranges[1] - state.startingGuess;
-            uint256 extendedUpper =
-                (PMath.addWithUpperBound(state.ranges[1], distFromStartingGuess, state.hardBounds[1]));
+            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) {

package/contracts/router/math/MarketApproxEstimateLib.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import {MarketMathCore, MarketState} from "../../core/Market/MarketMathCore.sol";
-import {PYIndex, PYIndexLib} from "../../core/StandardizedYield/PYIndex.sol";
+import {PYIndexLib, PYIndex} from "../../core/StandardizedYield/PYIndex.sol";
 import {PMath} from "../../core/libraries/math/PMath.sol";
 
 library MarketApproxEstimateLib {
@@ -51,19 +51,21 @@ library MarketApproxEstimateLib {
         }
     }
 
-    function estimateSwapExactSyForPt(MarketState memory market, PYIndex index, uint256 blockTime, uint256 amountSyIn)
-        internal
-        pure
-        returns (uint256 estimatedPtOut)
-    {
+    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)
-    {
+    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);
     }