@pendle/core-v2 0.2.2 → 0.3.0

package/contracts/libraries/math/MarketApproxLib.sol

@@ -1,140 +1,382 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "./FixedPoint.sol";
-import "./MarketMathLib.sol";
+import "./Math.sol";
+import "./MarketMathCore.sol";
+import "./MarketMathCore.sol";
+
+struct ApproxParams {
+    uint256 guessMin;
+    uint256 guessMax;
+    uint256 maxIteration;
+    uint256 eps;
+}
 
 // solhint-disable reason-string, ordering
 library MarketApproxLib {
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
+    using Math for uint256;
+    using Math for int256;
     using LogExpMath for int256;
     using SCYIndexLib for SCYIndex;
-    using MarketMathLib for MarketParameters;
-
-    struct ApproxSwapExactScyForYtSlot {
-        uint256 low;
-        uint256 high;
-        bool isAcceptableAnswerExisted;
-        uint256 currentYtOutGuess;
-        uint256 otToMarket;
-        uint256 scyReceived;
-        uint256 totalScyToMintYo;
-        uint256 netYoFromScy;
-        bool isResultAcceptable;
+    using MarketMathCore for MarketState;
+
+    function approxSwapOtForExactScy(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 minScyOut,
+        uint256 blockTime,
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netOtIn*/
+            uint256 /*netScyOut*/
+        )
+    {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(minScyOut > 0, "invalid minScyOut");
+        require(isValidApproxParams(approx), "invalid approx approx");
+
+        /// ------------------------------------------------------------
+        /// SET UP VAIRBALES
+        /// ------------------------------------------------------------
+        uint256 minAssetOut = index.scyToAsset(minScyOut);
+        uint256 largestGoodSlope;
+        bool isSlopeNonNeg;
+
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
+
+        if (approx.guessMax == type(uint256).max) {
+            approx.guessMax = calcMaxOtIn(market.totalOt, comp.totalAsset);
+        }
+
+        /// ------------------------------------------------------------
+        /// BINARY SEARCH
+        /// ------------------------------------------------------------
+
+        while (approx.maxIteration != 0) {
+            unchecked {
+                approx.maxIteration--;
+            }
+            uint256 otInGuess = (approx.guessMin + approx.guessMax) / 2;
+
+            /// ------------------------------------------------------------
+            /// CHECK SLOPE
+            /// ------------------------------------------------------------
+            (isSlopeNonNeg, largestGoodSlope) = updateSlope(
+                market.totalOt,
+                otInGuess,
+                comp,
+                largestGoodSlope
+            );
+            if (!isSlopeNonNeg) {
+                approx.guessMax = otInGuess;
+                continue;
+            }
+
+            /// ------------------------------------------------------------
+            /// CHECK ASSET
+            /// ------------------------------------------------------------
+            (int256 _assetToAccount, ) = market.calcTrade(comp, otInGuess.neg());
+            uint256 netAssetOut = _assetToAccount.Uint();
+
+            if (netAssetOut >= minAssetOut) {
+                approx.guessMax = otInGuess;
+                /// ------------------------------------------------------------
+                /// CHECK IF ANSWER FOUND
+                /// ------------------------------------------------------------
+                if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
+                    return (otInGuess, index.assetToScy(netAssetOut));
+                }
+            } else {
+                approx.guessMin = otInGuess + 1;
+            }
+        }
+        revert("approx fail");
     }
 
     function approxSwapExactScyForOt(
-        MarketParameters memory marketImmutable,
+        MarketState memory market,
         SCYIndex index,
-        uint256 exactScyIn,
+        uint256 maxScyIn,
         uint256 blockTime,
-        uint256 netOtOutGuessMin,
-        uint256 netOtOutGuessMax
-    ) internal pure returns (uint256 netOtOut) {
-        require(exactScyIn > 0, "invalid scy in");
-        require(
-            netOtOutGuessMin >= 0 && netOtOutGuessMax >= 0 && netOtOutGuessMin <= netOtOutGuessMax,
-            "invalid guess"
-        );
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netOtOut*/
+            uint256 /*netScyIn*/
+        )
+    {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(maxScyIn > 0, "invalid maxScyIn");
+        require(isValidApproxParams(approx), "invalid approx approx");
+
+        /// ------------------------------------------------------------
+        /// SET UP VAIRBALES
+        /// ------------------------------------------------------------
+        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
+
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
-        uint256 low = netOtOutGuessMin;
-        uint256 high = netOtOutGuessMax;
-        bool isAcceptableAnswerExisted;
+        if (approx.guessMax == type(uint256).max) {
+            approx.guessMax = calcMaxOtOut(market.totalOt, comp);
+        }
+
+        /// ------------------------------------------------------------
+        /// BINARY SEARCH
+        /// ------------------------------------------------------------
+
+        while (approx.maxIteration != 0) {
+            unchecked {
+                approx.maxIteration--;
+            }
+            uint256 otOutGuess = (approx.guessMin + approx.guessMax + 1) / 2;
 
-        while (low != high) {
-            uint256 currentOtOutGuess = (low + high + 1) / 2;
-            MarketParameters memory market = MarketMathLib.deepCloneMarket(marketImmutable);
+            /// ------------------------------------------------------------
+            /// CHECK ASSET
+            /// ------------------------------------------------------------
+            (int256 _assetToAccount, ) = market.calcTrade(comp, otOutGuess.Int());
+            uint256 netAssetIn = _assetToAccount.neg().Uint();
 
-            (uint256 netScyNeed, ) = market.swapScyForExactOt(index, currentOtOutGuess, blockTime);
-            bool isResultAcceptable = (netScyNeed <= exactScyIn);
-            if (isResultAcceptable) {
-                low = currentOtOutGuess;
-                isAcceptableAnswerExisted = true;
-            } else high = currentOtOutGuess - 1;
+            if (netAssetIn <= maxAssetIn) {
+                approx.guessMin = otOutGuess;
+                /// ------------------------------------------------------------
+                /// CHECK IF ANSWER FOUND
+                /// ------------------------------------------------------------
+                if (Math.isASmallerApproxB(netAssetIn, maxAssetIn, approx.eps)) {
+                    return (otOutGuess, index.assetToScy(netAssetIn));
+                }
+            } else {
+                approx.guessMax = otOutGuess - 1;
+            }
         }
+        revert("approx fail");
+    }
 
-        require(isAcceptableAnswerExisted, "guess fail");
-        netOtOut = low;
+    struct SlotSwapExactScyForYt {
+        uint256 otInGuess;
+        int256 _assetToAccount;
+        uint256 netAssetOut;
+        uint256 amountAssetNeedMore;
     }
 
-    function approxSwapOtForExactScy(
-        MarketParameters memory marketImmutable,
+    function approxSwapExactScyForYt(
+        MarketState memory market,
         SCYIndex index,
-        uint256 exactScyOut,
+        uint256 maxScyIn,
         uint256 blockTime,
-        uint256 netOtInGuessMin,
-        uint256 netOtInGuessMax
-    ) internal pure returns (uint256 netOtIn) {
-        require(exactScyOut > 0, "invalid scy in");
-        require(
-            netOtInGuessMin >= 0 && netOtInGuessMax >= 0 && netOtInGuessMin <= netOtInGuessMax,
-            "invalid guess"
-        );
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netYtOut*/
+            uint256 /*netScyIn*/
+        )
+    {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(maxScyIn > 0, "invalid maxScyIn");
+        require(isValidApproxParams(approx), "invalid approx approx");
+
+        /// ------------------------------------------------------------
+        /// SET UP VAIRBALES
+        /// ------------------------------------------------------------
+        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
+        uint256 largestGoodSlope;
+        bool isSlopeNonNeg;
+
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
-        uint256 low = netOtInGuessMin;
-        uint256 high = netOtInGuessMax;
-        bool isAcceptableAnswerExisted;
+        if (approx.guessMax == type(uint256).max) {
+            approx.guessMax = calcMaxOtIn(market.totalOt, comp.totalAsset);
+        }
+
+        /// ------------------------------------------------------------
+        /// BINARY SEARCH
+        /// ------------------------------------------------------------
+
+        while (approx.maxIteration != 0) {
+            unchecked {
+                approx.maxIteration--;
+            }
 
-        while (low != high) {
-            uint256 currentOtInGuess = (low + high) / 2;
-            MarketParameters memory market = MarketMathLib.deepCloneMarket(marketImmutable);
+            SlotSwapExactScyForYt memory slot;
+            // ytOutGuess = otInGuess
+            slot.otInGuess = (approx.guessMin + approx.guessMax + 1) / 2;
 
-            (uint256 netScyToAccount, ) = market.swapExactOtForScy(
-                index,
-                currentOtInGuess,
-                blockTime
+            /// ------------------------------------------------------------
+            /// CHECK SLOPE
+            /// ------------------------------------------------------------
+            (isSlopeNonNeg, largestGoodSlope) = updateSlope(
+                market.totalOt,
+                slot.otInGuess,
+                comp,
+                largestGoodSlope
             );
-            bool isResultAcceptable = (netScyToAccount >= exactScyOut);
-            if (isResultAcceptable) {
-                high = currentOtInGuess;
-                isAcceptableAnswerExisted = true;
+            if (!isSlopeNonNeg) {
+                approx.guessMax = slot.otInGuess - 1;
+                continue;
+            }
+
+            /// ------------------------------------------------------------
+            /// CHECK ASSET
+            /// ------------------------------------------------------------
+            (slot._assetToAccount, ) = market.calcTrade(comp, slot.otInGuess.neg());
+            slot.netAssetOut = slot._assetToAccount.Uint();
+            slot.amountAssetNeedMore = slot.otInGuess - slot.netAssetOut;
+
+            if (slot.amountAssetNeedMore <= maxAssetIn) {
+                approx.guessMin = slot.otInGuess;
+                /// ------------------------------------------------------------
+                /// CHECK IF ANSWER FOUND
+                /// ------------------------------------------------------------
+                if (Math.isASmallerApproxB(slot.amountAssetNeedMore, maxAssetIn, approx.eps)) {
+                    return (slot.otInGuess, index.assetToScy(slot.amountAssetNeedMore));
+                }
             } else {
-                low = currentOtInGuess + 1;
+                approx.guessMax = slot.otInGuess - 1;
             }
         }
-
-        require(isAcceptableAnswerExisted, "guess fail");
-        netOtIn = high;
+        revert("approx fail");
     }
 
-    function approxSwapExactScyForYt(
-        MarketParameters memory marketImmutable,
+    function approxSwapYtForExactScy(
+        MarketState memory market,
         SCYIndex index,
-        uint256 exactScyIn,
+        uint256 minScyOut,
         uint256 blockTime,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax
-    ) internal pure returns (uint256 netYtOut) {
-        require(exactScyIn > 0, "invalid scy in");
-        require(netYtOutGuessMin >= 0 && netYtOutGuessMax >= 0, "invalid guess");
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netYtIn*/
+            uint256 /*netScyOut*/
+        )
+    {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(minScyOut > 0, "invalid maxScyIn");
+        require(isValidApproxParams(approx), "invalid approx approx");
+
+        /// ------------------------------------------------------------
+        /// SET UP VAIRBALES
+        /// ------------------------------------------------------------
+        uint256 minAssetOut = index.scyToAsset(minScyOut);
 
-        ApproxSwapExactScyForYtSlot memory slot;
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
-        slot.low = netYtOutGuessMin;
-        slot.high = netYtOutGuessMax;
+        if (approx.guessMax == type(uint256).max) {
+            approx.guessMax = calcMaxOtOut(market.totalOt, comp);
+        }
 
-        while (slot.low != slot.high) {
-            slot.currentYtOutGuess = (slot.low + slot.high + 1) / 2;
-            MarketParameters memory market = MarketMathLib.deepCloneMarket(marketImmutable);
+        /// ------------------------------------------------------------
+        /// BINARY SEARCH
+        /// ------------------------------------------------------------
 
-            slot.otToMarket = slot.currentYtOutGuess;
+        while (approx.maxIteration != 0) {
+            unchecked {
+                approx.maxIteration--;
+            }
+            // ytInGuess = otOutGuess
+            uint256 otOutGuess = (approx.guessMin + approx.guessMax) / 2;
 
-            (slot.scyReceived, ) = market.swapExactOtForScy(index, slot.otToMarket, blockTime);
+            /// ------------------------------------------------------------
+            /// CHECK ASSET
+            /// ------------------------------------------------------------
+            (int256 _assetToAccount, ) = market.calcTrade(comp, otOutGuess.Int());
+            uint256 netAssetOwed = _assetToAccount.neg().Uint();
 
-            slot.totalScyToMintYo = slot.scyReceived + exactScyIn;
+            // since otOutGuess is between guessMin & guessMax, it's guaranteed that
+            // there are enough Yt to pair with otOut
 
-            slot.netYoFromScy = index.scyToAsset(slot.totalScyToMintYo);
+            uint256 netAssetOut = otOutGuess - netAssetOwed;
 
-            bool isResultAcceptable = (slot.netYoFromScy >= slot.currentYtOutGuess);
+            if (netAssetOut >= minAssetOut) {
+                approx.guessMax = otOutGuess;
+                /// ------------------------------------------------------------
+                /// CHECK IF ANSWER FOUND
+                /// ------------------------------------------------------------
+                if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
+                    return (otOutGuess, index.assetToScy(netAssetOut));
+                }
+            } else {
+                approx.guessMin = otOutGuess + 1;
+            }
+        }
+        revert("approx fail");
+    }
 
-            if (isResultAcceptable) {
-                slot.low = slot.currentYtOutGuess;
-                slot.isAcceptableAnswerExisted = true;
-            } else slot.high = slot.currentYtOutGuess - 1;
+    function updateSlope(
+        int256 totalOt,
+        uint256 otInGuess,
+        MarketPreCompute memory comp,
+        uint256 largestGoodSlope
+    ) internal pure returns (bool isSlopeNonNeg, uint256 newLargestGoodSlop) {
+        if (otInGuess <= largestGoodSlope) {
+            return (true, largestGoodSlope);
         }
+        // it's not guaranteed that the current slop is good
+        // we therefore have to recalculate the slope
+        int256 slope = slopeFactor(totalOt, otInGuess.neg(), comp);
+        if (slope >= 0) return (true, otInGuess);
+        else return (false, largestGoodSlope);
+    }
+
+    // otToMarket < totalAsset && totalOt
+    function slopeFactor(
+        int256 totalOt,
+        int256 otToAccount,
+        MarketPreCompute memory comp
+    ) internal pure returns (int256) {
+        int256 otToMarket = -otToAccount;
+        int256 diffAssetOtToMarket = comp.totalAsset - otToMarket;
+        int256 sumOt = otToMarket + totalOt;
+
+        require(diffAssetOtToMarket > 0 && sumOt > 0, "invalid otToMarket");
+
+        int256 part1 = (otToMarket * (totalOt + comp.totalAsset)).divDown(
+            sumOt * diffAssetOtToMarket
+        );
+
+        int256 part2 = sumOt.divDown(diffAssetOtToMarket).ln();
+        int256 part3 = Math.IONE.divDown(comp.rateScalar);
+
+        return comp.rateAnchor - (part1 - part2).mulDown(part3);
+    }
+
+    function calcMaxOtOut(int256 totalOt, MarketPreCompute memory comp)
+        internal
+        pure
+        returns (uint256)
+    {
+        int256 logitP = (Math.IONE.mulDown(comp.feeRate) - comp.rateAnchor)
+            .mulDown(comp.rateScalar)
+            .exp();
+        int256 proportion = logitP.divDown(logitP + Math.IONE);
+        int256 numerator = proportion.mulDown(totalOt + comp.totalAsset);
+        int256 maxOtOut = totalOt - numerator;
+        // TODO: 999 & 1000 are magic numbers
+        return (maxOtOut.Uint() * 999) / 1000;
+    }
+
+    function calcMaxOtIn(int256 totalOt, int256 totalAsset) internal pure returns (uint256) {
+        return Math.min(totalOt, totalAsset).Uint() - 1;
+    }
 
-        require(slot.isAcceptableAnswerExisted, "guess fail");
-        netYtOut = slot.low;
+    function isValidApproxParams(ApproxParams memory approx) internal pure returns (bool) {
+        return (approx.guessMin <= approx.guessMax &&
+            approx.maxIteration <= 256 &&
+            approx.eps <= Math.ONE);
     }
 }

package/contracts/libraries/math/MarketMathAux.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./Math.sol";
+import "./LogExpMath.sol";
+import "../SCYIndex.sol";
+import "./MarketMathCore.sol";
+
+// solhint-disable ordering
+library MarketMathAux {
+    using Math for uint256;
+    using Math for int256;
+
+    function addLiquidity(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 scyDesired,
+        uint256 otDesired,
+        bool updateState
+    )
+        internal
+        pure
+        returns (
+            uint256 lpToReserve,
+            uint256 lpToAccount,
+            uint256 scyUsed,
+            uint256 otUsed
+        )
+    {
+        (
+            int256 _lpToReserve,
+            int256 _lpToAccount,
+            int256 _scyUsed,
+            int256 _otUsed
+        ) = MarketMathCore.addLiquidityCore(
+                market,
+                index,
+                scyDesired.Int(),
+                otDesired.Int(),
+                updateState
+            );
+
+        lpToReserve = _lpToReserve.Uint();
+        lpToAccount = _lpToAccount.Uint();
+        scyUsed = _scyUsed.Uint();
+        otUsed = _otUsed.Uint();
+    }
+
+    function removeLiquidity(
+        MarketState memory market,
+        uint256 lpToRemove,
+        bool updateState
+    ) internal pure returns (uint256 scyToAccount, uint256 netOtToAccount) {
+        (int256 _scyToAccount, int256 _otToAccount) = MarketMathCore.removeLiquidityCore(
+            market,
+            lpToRemove.Int(),
+            updateState
+        );
+
+        scyToAccount = _scyToAccount.Uint();
+        netOtToAccount = _otToAccount.Uint();
+    }
+
+    function swapExactOtForScy(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 exactOtToMarket,
+        uint256 blockTime,
+        bool updateState
+    ) internal pure returns (uint256 netScyToAccount, uint256 netScyToReserve) {
+        (int256 _netScyToAccount, int256 _netScyToReserve) = MarketMathCore.executeTradeCore(
+            market,
+            index,
+            exactOtToMarket.neg(),
+            blockTime,
+            updateState
+        );
+
+        netScyToAccount = _netScyToAccount.Uint();
+        netScyToReserve = _netScyToReserve.Uint();
+    }
+
+    function swapScyForExactOt(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 exactOtToAccount,
+        uint256 blockTime,
+        bool updateState
+    ) internal pure returns (uint256 netScyToMarket, uint256 netScyToReserve) {
+        (int256 _netScyToAccount, int256 _netScyToReserve) = MarketMathCore.executeTradeCore(
+            market,
+            index,
+            exactOtToAccount.Int(),
+            blockTime,
+            updateState
+        );
+
+        netScyToMarket = _netScyToAccount.neg().Uint();
+        netScyToReserve = _netScyToReserve.Uint();
+    }
+}