@pendle/core-v2 6.3.0-fee-setter → 6.3.0-sweedtest

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/libraries/math/PMath.sol";
 import "../../core/Market/MarketMathCore.sol";
+import "../../core/libraries/math/PMath.sol";
 import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 import {ApproxState, ApproxStateLib} from "./ApproxStateLib.sol";
 import {MarketApproxEstimateLib} from "./MarketApproxEstimateLib.sol";
@@ -20,7 +20,15 @@ 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)];
@@ -28,7 +36,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);
 
@@ -55,21 +63,25 @@ 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);
@@ -109,12 +121,11 @@ 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);
@@ -139,7 +150,15 @@ 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)];
@@ -147,7 +166,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)) {
@@ -171,12 +190,17 @@ 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);
@@ -218,12 +242,11 @@ 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/libraries/math/PMath.sol";
 import "../../core/Market/MarketMathCore.sol";
+import "../../core/libraries/math/PMath.sol";
 import {ApproxParams} from "../../interfaces/IPAllActionTypeV3.sol";
 
 uint256 constant QUICK_CALC_MAX_ITER = 50;
@@ -22,7 +22,14 @@ 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));
@@ -35,7 +42,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);
 
@@ -80,7 +87,15 @@ 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) {
@@ -95,13 +110,8 @@ 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);
@@ -129,12 +139,11 @@ 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;
@@ -198,12 +207,11 @@ 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);
@@ -262,7 +270,14 @@ 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
@@ -272,7 +287,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)) {
@@ -312,7 +327,15 @@ 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);
@@ -375,12 +398,11 @@ 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;
 
@@ -421,12 +443,11 @@ 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
@@ -449,12 +470,10 @@ 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);