@pendle/core-v2 6.3.0-beta → 6.3.0-sweedtest

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,12 +22,10 @@ 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;
@@ -52,36 +50,23 @@ 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) {
@@ -105,13 +90,10 @@ 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);
         }
@@ -119,14 +101,10 @@ 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);
         }
@@ -135,12 +113,10 @@ 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);
@@ -175,7 +151,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;
@@ -190,11 +166,8 @@ 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;
@@ -219,7 +192,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;
 
@@ -233,12 +206,8 @@ 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);
 
@@ -283,11 +252,12 @@ 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;
@@ -328,18 +298,15 @@ 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;
@@ -349,24 +316,17 @@ 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;
@@ -376,12 +336,8 @@ 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));
 
@@ -417,10 +373,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,20 +1,19 @@
 // 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";
+import {ApproxParams, LimitOrderData, TokenInput} from "../../interfaces/IPAllActionTypeV3.sol";
+import {ActionBase} from "./ActionBase.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));
@@ -28,21 +27,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));
@@ -56,7 +55,8 @@ 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,30 +98,31 @@ 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/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 abstract contract CallbackHelper {
@@ -59,12 +59,11 @@ 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);
 
@@ -77,9 +76,11 @@ 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))
@@ -89,12 +90,11 @@ 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,9 +107,11 @@ 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 {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 import {PMath} from "../../core/libraries/math/PMath.sol";
+import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 
 enum ApproxStage {
     INITIAL,
@@ -46,38 +46,39 @@ 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 {
@@ -124,9 +125,8 @@ 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 {PYIndexLib, PYIndex} from "../../core/StandardizedYield/PYIndex.sol";
+import {PYIndex, PYIndexLib} from "../../core/StandardizedYield/PYIndex.sol";
 import {PMath} from "../../core/libraries/math/PMath.sol";
 
 library MarketApproxEstimateLib {
@@ -51,21 +51,19 @@ 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);
     }