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

package/contracts/router/math/MarketApproxLibOnchain.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/Market/MarketMathCore.sol";
 import "../../core/libraries/math/PMath.sol";
+import "../../core/Market/MarketMathCore.sol";
 import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 import {ApproxState, ApproxStateLib} from "./ApproxStateLib.sol";
 import {MarketApproxEstimateLib} from "./MarketApproxEstimateLib.sol";
@@ -20,15 +20,7 @@ library MarketApproxPtInLibOnchain {
         PYIndex index,
         uint256 exactSyIn,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256, /*netSyFee*/
-            uint256 /* iteration */
-        )
-    {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256, /*netSyFee*/ uint256 /* iteration */) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         uint256 estimatedYtOut = market.estimateSwapExactSyForYt(index, blockTime, exactSyIn);
         uint256[2] memory hardBounds = [index.syToAsset(exactSyIn), calcSoftMaxPtIn(market, comp)];
@@ -36,7 +28,7 @@ library MarketApproxPtInLibOnchain {
 
         for (uint256 iter = 0; iter < state.maxIteration; ++iter) {
             uint256 guess = state.curGuess;
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netSyToTokenizePt = index.assetToSyUp(guess);
 
@@ -63,25 +55,21 @@ library MarketApproxPtInLibOnchain {
     )
         internal
         pure
-        returns (
-            uint256, /*netPtSwap*/
-            uint256, /*netSyFromSwap*/
-            uint256, /*netSyFee*/
-            uint256 /* iteration */
-        )
+        returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256, /*netSyFee*/ uint256 /* iteration */)
     {
         require(market.totalLp != 0, "no existing lp");
 
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
-        (uint256 estimatedPtAdd,) = market.estimateAddLiquidity(index, blockTime, totalPtIn, netSyHolding);
+        (uint256 estimatedPtAdd, ) = market.estimateAddLiquidity(index, blockTime, totalPtIn, netSyHolding);
         uint256 estimatedPtSwap = totalPtIn.subMax0(estimatedPtAdd);
         uint256[2] memory hardBounds = [0, PMath.min(totalPtIn, calcSoftMaxPtIn(market, comp))];
         ApproxState memory state = ApproxStateLib.initNoOffChain(estimatedPtSwap, hardBounds);
 
         for (uint256 iter = 0; iter < state.maxIteration; ++iter) {
             uint256 guess = state.curGuess;
-            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee,) =
-                (calcNumerators(market, index, totalPtIn, netSyHolding, comp, guess));
+            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = (
+                calcNumerators(market, index, totalPtIn, netSyHolding, comp, guess)
+            );
 
             if (PMath.isAApproxB(syNumerator, ptNumerator, state.eps)) {
                 return (guess, netSyOut, netSyFee, iter);
@@ -121,11 +109,12 @@ library MarketApproxPtInLibOnchain {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyOut(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtIn)
-        internal
-        pure
-        returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyOut(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtIn
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, -int256(netPtIn));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
@@ -150,15 +139,7 @@ library MarketApproxPtOutLibOnchain {
         PYIndex index,
         uint256 exactSyIn,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256, /*netSyFee*/
-            uint256 /* iteration */
-        )
-    {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256, /*netSyFee*/ uint256 /* iteration */) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         uint256 estimatedPtOut = market.estimateSwapExactSyForPt(index, blockTime, exactSyIn);
         uint256[2] memory hardBounds = [0, calcMaxPtOut(comp, market.totalPt)];
@@ -166,7 +147,7 @@ library MarketApproxPtOutLibOnchain {
 
         for (uint256 iter = 0; iter < state.maxIteration; ++iter) {
             uint256 guess = state.curGuess;
-            (uint256 netSyIn, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
                 if (PMath.isASmallerApproxB(netSyIn, exactSyIn, state.eps)) {
@@ -190,17 +171,12 @@ library MarketApproxPtOutLibOnchain {
     )
         internal
         pure
-        returns (
-            uint256, /*netPtFromSwap*/
-            uint256, /*netSySwap*/
-            uint256, /*netSyFee*/
-            uint256 /* iteration */
-        )
+        returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256, /*netSyFee*/ uint256 /* iteration */)
     {
         require(market.totalLp != 0, "no existing lp");
 
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
-        (uint256 estimatedPtAdd,) = market.estimateAddLiquidity(index, blockTime, netPtHolding, totalSyIn);
+        (uint256 estimatedPtAdd, ) = market.estimateAddLiquidity(index, blockTime, netPtHolding, totalSyIn);
         uint256 estimatedPtSwap = estimatedPtAdd.subMax0(netPtHolding);
         uint256[2] memory hardBounds = [0, calcMaxPtOut(comp, market.totalPt)];
         ApproxState memory state = ApproxStateLib.initNoOffChain(estimatedPtSwap, hardBounds);
@@ -242,11 +218,12 @@ library MarketApproxPtOutLibOnchain {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyIn(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtOut)
-        internal
-        pure
-        returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyIn(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtOut
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, int256(netPtOut));
 
         netSyIn = uint256(-_netSyIn);

package/contracts/router/math/MarketApproxLibV2.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/Market/MarketMathCore.sol";
 import "../../core/libraries/math/PMath.sol";
+import "../../core/Market/MarketMathCore.sol";
 import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 
 uint256 constant QUICK_CALC_MAX_ITER = 50;
@@ -22,14 +22,7 @@ library MarketApproxPtInLibV2 {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -42,7 +35,7 @@ library MarketApproxPtInLibV2 {
         uint256 guess = getFirstGuess(approx);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netSyToTokenizePt = index.assetToSyUp(guess);
 
@@ -87,15 +80,7 @@ library MarketApproxPtInLibV2 {
         uint256 _netSyHolding,
         uint256 _blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtSwap*/
-            uint256, /*netSyFromSwap*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/) {
         Args5 memory a = Args5(_market, _index, _totalPtIn, _netSyHolding, _blockTime, approx);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (approx.guessOffchain == 0) {
@@ -110,8 +95,13 @@ library MarketApproxPtInLibV2 {
 
         bool quickCalcRan = false;
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
-            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) =
-                calcNumerators(a.market, a.index, a.totalPtIn, a.netSyHolding, comp, guess);
+            (
+                uint256 syNumerator,
+                uint256 ptNumerator,
+                uint256 netSyOut,
+                uint256 netSyFee,
+                uint256 netSyToReserve
+            ) = calcNumerators(a.market, a.index, a.totalPtIn, a.netSyHolding, comp, guess);
 
             if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) {
                 return (guess, netSyOut, netSyFee);
@@ -139,11 +129,12 @@ library MarketApproxPtInLibV2 {
         revert("Slippage: APPROX_EXHAUSTED");
     }
 
-    function quickCalc(Args5 memory a, uint256 _guess, uint256 _netSyOut, uint256 _netSyToReserve)
-        internal
-        pure
-        returns (uint256)
-    {
+    function quickCalc(
+        Args5 memory a,
+        uint256 _guess,
+        uint256 _netSyOut,
+        uint256 _netSyToReserve
+    ) internal pure returns (uint256) {
         unchecked {
             uint256 low = a.approx.guessMin;
             uint256 high = a.approx.guessMax;
@@ -207,11 +198,12 @@ library MarketApproxPtInLibV2 {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyOut(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtIn)
-        internal
-        pure
-        returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyOut(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtIn
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, -int256(netPtIn));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
@@ -270,14 +262,7 @@ library MarketApproxPtOutLibV2 {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -287,7 +272,7 @@ library MarketApproxPtOutLibV2 {
         uint256 guess = getFirstGuess(approx);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
-            (uint256 netSyIn, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
                 if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {
@@ -327,15 +312,7 @@ library MarketApproxPtOutLibV2 {
         uint256 _netPtHolding,
         uint256 _blockTime,
         ApproxParams memory _approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtFromSwap*/
-            uint256, /*netSySwap*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256 /*netSyFee*/) {
         Args6 memory a = Args6(_market, _index, _totalSyIn, _netPtHolding, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -398,11 +375,12 @@ library MarketApproxPtOutLibV2 {
         revert("Slippage: APPROX_EXHAUSTED");
     }
 
-    function quickCalc(Args6 memory a, uint256 _guess, uint256 _netSyIn, uint256 _netSyToReserve)
-        internal
-        pure
-        returns (uint256)
-    {
+    function quickCalc(
+        Args6 memory a,
+        uint256 _guess,
+        uint256 _netSyIn,
+        uint256 _netSyToReserve
+    ) internal pure returns (uint256) {
         uint256 low = a.approx.guessMin;
         uint256 high = a.approx.guessMax;
 
@@ -443,11 +421,12 @@ library MarketApproxPtOutLibV2 {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyIn(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtOut)
-        internal
-        pure
-        returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyIn(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtOut
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, int256(netPtOut));
 
         // all safe since totalPt and totalSy is int128
@@ -470,10 +449,12 @@ library MarketApproxPtOutLibV2 {
     }
 }
 
-function scaleClamp(uint256 original, uint256 target, uint256 current, ApproxParams memory approx)
-    pure
-    returns (uint256)
-{
+function scaleClamp(
+    uint256 original,
+    uint256 target,
+    uint256 current,
+    ApproxParams memory approx
+) pure returns (uint256) {
     uint256 scaled = (original * target) / current;
     if (scaled >= approx.guessMax) return calcMidpoint(approx);
     if (scaled <= approx.guessMin) return calcMidpoint(approx);