@pendle/core-v2 0.20.2-testnet → 1.0.0-mainnet

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -14,17 +14,6 @@ library MarketMathStatic {
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
-    function getDefaultApproxParams() public pure returns (ApproxParams memory) {
-        return
-            ApproxParams({
-                guessMin: 0,
-                guessMax: type(uint256).max,
-                guessOffchain: 0,
-                maxIteration: 256,
-                eps: 1e14
-            });
-    }
-
     function addLiquidityDualSyAndPtStatic(
         address market,
         uint256 netSyDesired,
@@ -47,14 +36,17 @@ library MarketMathStatic {
     }
 
     /// @dev netPtToSwap is the parameter to approx
-    function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
+    function addLiquiditySinglePtStatic(
+        address market,
+        uint256 netPtIn,
+        ApproxParams memory approxParams
+    )
         external
         returns (
             uint256 netLpOut,
             uint256 netPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -63,7 +55,7 @@ library MarketMathStatic {
             pyIndex(market),
             netPtIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
 
         state = IPMarket(market).readState(address(this)); // re-read
@@ -80,19 +72,21 @@ library MarketMathStatic {
             block.timestamp
         );
 
-        priceImpact = calcPriceImpactPt(market, netPtToSwap.neg());
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netPtToSwap.neg());
     }
 
     /// @dev netPtFromSwap is the parameter to approx
-    function addLiquiditySingleSyStatic(address market, uint256 netSyIn)
+    function addLiquiditySingleSyStatic(
+        address market,
+        uint256 netSyIn,
+        ApproxParams memory approxParams
+    )
         public
         returns (
             uint256 netLpOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -101,7 +95,7 @@ library MarketMathStatic {
             pyIndex(market),
             netSyIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
 
         state = IPMarket(market).readState(address(this)); // re-read
@@ -114,8 +108,7 @@ library MarketMathStatic {
         );
         (, netLpOut, , ) = state.addLiquidity(netSyIn - netSySwap, netPtFromSwap, block.timestamp);
 
-        priceImpact = calcPriceImpactPt(market, netPtFromSwap.Int());
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netPtFromSwap.Int());
     }
 
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
@@ -128,14 +121,17 @@ library MarketMathStatic {
     }
 
     /// @dev netPtFromSwap is the parameter to approx
-    function removeLiquiditySinglePtStatic(address market, uint256 netLpToRemove)
+    function removeLiquiditySinglePtStatic(
+        address market,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    )
         external
         returns (
             uint256 netPtOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -145,15 +141,11 @@ library MarketMathStatic {
             pyIndex(market),
             syFromBurn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
 
         netPtOut = ptFromBurn + netPtFromSwap;
-        priceImpact = calcPriceImpactPt(market, netPtFromSwap.Int());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapSyForExactPt(pyIndex(market), netPtFromSwap, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netPtFromSwap.Int());
     }
 
     function removeLiquiditySingleSyStatic(address market, uint256 netLpToRemove)
@@ -161,8 +153,7 @@ library MarketMathStatic {
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -180,8 +171,7 @@ library MarketMathStatic {
             );
 
             netSyOut = syFromBurn + syFromSwap;
-            priceImpact = calcPriceImpactPt(market, ptFromBurn.neg());
-            exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+            priceImpact = calcPriceImpact(market, ptFromBurn.neg());
         }
     }
 
@@ -190,8 +180,7 @@ library MarketMathStatic {
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -200,8 +189,7 @@ library MarketMathStatic {
             exactPtIn,
             block.timestamp
         );
-        priceImpact = calcPriceImpactPt(market, exactPtIn.neg());
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, exactPtIn.neg());
     }
 
     function swapSyForExactPtStatic(address market, uint256 exactPtOut)
@@ -209,8 +197,7 @@ library MarketMathStatic {
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -219,18 +206,20 @@ library MarketMathStatic {
             exactPtOut,
             block.timestamp
         );
-        priceImpact = calcPriceImpactPt(market, exactPtOut.Int());
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, exactPtOut.Int());
     }
 
     /// @dev netPtOut is the parameter to approx
-    function swapExactSyForPtStatic(address market, uint256 exactSyIn)
+    function swapExactSyForPtStatic(
+        address market,
+        uint256 exactSyIn,
+        ApproxParams memory approxParams
+    )
         public
         returns (
             uint256 netPtOut,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -238,23 +227,22 @@ library MarketMathStatic {
             pyIndex(market),
             exactSyIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
-        priceImpact = calcPriceImpactPt(market, netPtOut.Int());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapSyForExactPt(pyIndex(market), netPtOut, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netPtOut.Int());
     }
 
     /// @dev netPtIn is the parameter to approx
-    function swapPtForExactSyStatic(address market, uint256 exactSyOut)
+    function swapPtForExactSyStatic(
+        address market,
+        uint256 exactSyOut,
+        ApproxParams memory approxParams
+    )
         public
         returns (
             uint256 netPtIn,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -263,13 +251,9 @@ library MarketMathStatic {
             pyIndex(market),
             exactSyOut,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
-        priceImpact = calcPriceImpactPt(market, netPtIn.neg());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapExactPtForSy(pyIndex(market), netPtIn, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netPtIn.neg());
     }
 
     function swapSyForExactYtStatic(address market, uint256 exactYtOut)
@@ -277,13 +261,11 @@ library MarketMathStatic {
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
-        priceImpact = calcPriceImpactYt(market, exactYtOut.neg());
-
         MarketState memory state = IPMarket(market).readState(address(this));
+
         PYIndex index = pyIndex(market);
 
         uint256 syReceived;
@@ -296,17 +278,20 @@ library MarketMathStatic {
         uint256 totalSyNeed = index.assetToSyUp(exactYtOut);
         netSyIn = totalSyNeed.subMax0(syReceived);
 
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, exactYtOut.neg());
     }
 
     /// @dev netYtOut is the parameter to approx
-    function swapExactSyForYtStatic(address market, uint256 exactSyIn)
+    function swapExactSyForYtStatic(
+        address market,
+        uint256 exactSyIn,
+        ApproxParams memory approxParams
+    )
         public
         returns (
             uint256 netYtOut,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -316,14 +301,10 @@ library MarketMathStatic {
             index,
             exactSyIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
 
-        priceImpact = calcPriceImpactYt(market, netYtOut.neg());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapExactPtForSy(index, netYtOut, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netYtOut.neg());
     }
 
     function swapExactYtForSyStatic(address market, uint256 exactYtIn)
@@ -331,12 +312,9 @@ library MarketMathStatic {
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
-        priceImpact = calcPriceImpactYt(market, exactYtIn.Int());
-
         MarketState memory state = IPMarket(market).readState(address(this));
 
         PYIndex index = pyIndex(market);
@@ -348,17 +326,20 @@ library MarketMathStatic {
         uint256 amountPYToRedeemSyOut = exactYtIn - amountPYToRepaySyOwed;
 
         netSyOut = index.assetToSy(amountPYToRedeemSyOut);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, exactYtIn.Int());
     }
 
     /// @dev netYtIn is the parameter to approx
-    function swapYtForExactSyStatic(address market, uint256 exactSyOut)
+    function swapYtForExactSyStatic(
+        address market,
+        uint256 exactSyOut,
+        ApproxParams memory approxParams
+    )
         external
         returns (
             uint256 netYtIn,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -369,24 +350,23 @@ library MarketMathStatic {
             index,
             exactSyOut,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
-        priceImpact = calcPriceImpactYt(market, netYtIn.Int());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapSyForExactPt(index, netYtIn, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, netYtIn.Int());
     }
 
     // totalPtToSwap is the param to approx
-    function swapExactPtForYt(address market, uint256 exactPtIn)
+    function swapExactPtForYt(
+        address market,
+        uint256 exactPtIn,
+        ApproxParams memory approxParams
+    )
         external
         returns (
             uint256 netYtOut,
             uint256 totalPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -396,24 +376,23 @@ library MarketMathStatic {
             index,
             exactPtIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
-        priceImpact = calcPriceImpactPY(market, totalPtToSwap.neg());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapExactPtForSy(index, totalPtToSwap, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, totalPtToSwap.neg());
     }
 
     // totalPtSwapped is the param to approx
-    function swapExactYtForPt(address market, uint256 exactYtIn)
+    function swapExactYtForPt(
+        address market,
+        uint256 exactYtIn,
+        ApproxParams memory approxParams
+    )
         external
         returns (
             uint256 netPtOut,
             uint256 totalPtSwapped,
             uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
+            uint256 priceImpact
         )
     {
         MarketState memory state = IPMarket(market).readState(address(this));
@@ -423,14 +402,10 @@ library MarketMathStatic {
             index,
             exactYtIn,
             block.timestamp,
-            getDefaultApproxParams()
+            approxParams
         );
 
-        priceImpact = calcPriceImpactPY(market, totalPtSwapped.Int());
-
-        // Execute swap to calculate exchangeRateAfter
-        state.swapSyForExactPt(index, totalPtSwapped, block.timestamp);
-        exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
+        priceImpact = calcPriceImpact(market, totalPtSwapped.Int());
     }
 
     function pyIndex(address market) public returns (PYIndex index) {
@@ -439,25 +414,8 @@ library MarketMathStatic {
         return YT.newIndex();
     }
 
-    function getTradeExchangeRateExcludeFee(address market) public returns (uint256) {
-        if (IPMarket(market).isExpired()) return Math.ONE;
-        MarketState memory state = IPMarket(market).readState(address(this));
-        return _getTradeExchangeRateExcludeFee(market, state);
-    }
-
-    function _getTradeExchangeRateExcludeFee(address market, MarketState memory state)
-        public
-        returns (uint256)
-    {
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndex(market), block.timestamp);
-        int256 preFeeExchangeRate = MarketMathCore._getExchangeRate(
-            state.totalPt,
-            comp.totalAsset,
-            comp.rateScalar,
-            comp.rateAnchor,
-            0
-        );
-        return preFeeExchangeRate.Uint();
+    function getExchangeRate(address market) public returns (uint256) {
+        return getTradeExchangeRateIncludeFee(market, 0);
     }
 
     function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
@@ -487,40 +445,14 @@ library MarketMathStatic {
         }
     }
 
-    function calcPriceImpactPt(address market, int256 netPtOut)
+    function calcPriceImpact(address market, int256 netPtOut)
         public
         returns (uint256 priceImpact)
     {
-        uint256 preTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
+        uint256 preTradeRate = getExchangeRate(market);
         uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-        priceImpact = _calculateImpact(preTradeRate, tradedRate);
-    }
 
-    function calcPriceImpactYt(address market, int256 netPtOut)
-        public
-        returns (uint256 priceImpact)
-    {
-        uint256 ytPreTradeRate = _calcVirtualYTPrice(
-            getTradeExchangeRateIncludeFee(market, _getSign(netPtOut))
-        );
-        uint256 ytTradedRate = _calcVirtualYTPrice(
-            getTradeExchangeRateIncludeFee(market, netPtOut)
-        );
-        priceImpact = _calculateImpact(ytPreTradeRate, ytTradedRate);
-    }
-
-    function calcPriceImpactPY(address market, int256 netPtOut)
-        public
-        returns (uint256 priceImpact)
-    {
-        uint256 ptPreTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
-        uint256 ytPreTradeRate = _calcVirtualYTPrice(ptPreTradeRate);
-        uint256 ptTradeRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-        uint256 ytTradeRate = _calcVirtualYTPrice(ptTradeRate);
-
-        uint256 pyPreTradeRate = ytPreTradeRate.divDown(ptPreTradeRate);
-        uint256 pyTradeRate = ytTradeRate.divDown(ptTradeRate);
-        priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
+        priceImpact = (tradedRate.Int() - preTradeRate.Int()).abs().divDown(preTradeRate);
     }
 
     function getPtImpliedYield(address market) public view returns (int256) {
@@ -529,29 +461,4 @@ library MarketMathStatic {
         int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
         return lnImpliedRate.exp();
     }
-
-    function _calcVirtualYTPrice(uint256 ptAssetExchangeRate)
-        private
-        pure
-        returns (uint256 ytAssetExchangeRate)
-    {
-        // 1 asset = EX pt
-        // 1 pt = 1/EX Asset
-        // 1 yt + 1/EX Asset = 1 Asset
-        // 1 yt = 1 Asset - 1/EX Asset
-        // 1 yt = (EX - 1) / EX Asset
-        return (ptAssetExchangeRate - Math.ONE).divDown(ptAssetExchangeRate);
-    }
-
-    function _getSign(int256 netPtOut) private pure returns (int256) {
-        return netPtOut > 0 ? int256(1) : int256(-1);
-    }
-
-    function _calculateImpact(uint256 rateBefore, uint256 rateTraded)
-        private
-        pure
-        returns (uint256 impact)
-    {
-        impact = (rateBefore.Int() - rateTraded.Int()).abs().divDown(rateBefore);
-    }
 }