@pendle/core-v2 0.5.1-beta-4 → 0.6.0

package/contracts/libraries/math/MarketApproxLib.sol

@@ -8,8 +8,24 @@ import "./MarketMathCore.sol";
 struct ApproxParams {
     uint256 guessMin;
     uint256 guessMax;
-    uint256 maxIteration;
-    uint256 eps;
+    uint256 guessOffchain; // pass 0 in to skip this variable
+    uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2
+    uint256 eps; // the max eps between the returned result & the correct result, base 1e18. Normally this number will be set
+    // to 1e15 (1e18/1000 = 0.1%)
+
+    /// Further explanation of the eps. Take swapExactScyForPt for example. To calc the corresponding amount of Pt to swap out,
+    /// it's necessary to run an approximation algorithm, because by default there only exists the Pt to Scy formula
+    /// To approx, the 5 values above will have to be provided, and the approx process will run as follows:
+    /// mid = (guessMin + guessMax) / 2 // mid here is the current guess of the amount of Pt out
+    /// netScyNeed = calcSwapScyForExactPt(mid)
+    /// if (netScyNeed > exactScyIn) guessMax = mid - 1 // since the maximum Scy in can't exceed the exactScyIn
+    /// else guessMin = mid (1)
+    /// For the (1), since netScyNeed <= exactScyIn, the result might be usable. If the netScyNeed is within eps of
+    /// exactScyIn (ex eps=0.1% => we have used 99.9% the amount of Scy specified), mid will be chosen as the final guess result
+
+    /// for guessOffchain, this is to provide a shortcut to guessing. The offchain SDK can precalculate the exact result
+    /// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it satisfies the
+    /// approximation, it will be used (and save all the guessing).
 }
 
 // solhint-disable reason-string, ordering
@@ -20,7 +36,13 @@ library MarketApproxLib {
     using SCYIndexLib for SCYIndex;
     using MarketMathCore for MarketState;
 
-    function approxSwapOtForExactScy(
+    struct SlotSwapPtForExactScy {
+        uint256 ptInGuess;
+        int256 _assetToAccount;
+        uint256 netAssetOut;
+    }
+
+    function approxSwapPtForExactScy(
         MarketState memory market,
         SCYIndex index,
         uint256 minScyOut,
@@ -30,7 +52,7 @@ library MarketApproxLib {
         internal
         pure
         returns (
-            uint256, /*netOtIn*/
+            uint256, /*netPtIn*/
             uint256 /*netScyOut*/
         )
     {
@@ -50,55 +72,59 @@ library MarketApproxLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxOtIn(market.totalOt, comp.totalAsset);
+            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
         }
 
         /// ------------------------------------------------------------
         /// BINARY SEARCH
         /// ------------------------------------------------------------
 
-        while (approx.maxIteration != 0) {
-            unchecked {
-                approx.maxIteration--;
-            }
-            uint256 otInGuess = (approx.guessMin + approx.guessMax) / 2;
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            // ++iter at end of loop
+
+            SlotSwapPtForExactScy memory slot;
+            slot.ptInGuess = getCurrentGuess(iter, approx);
 
             /// ------------------------------------------------------------
             /// CHECK SLOPE
             /// ------------------------------------------------------------
             (isSlopeNonNeg, largestGoodSlope) = updateSlope(
-                market.totalOt,
-                otInGuess,
+                market.totalPt,
+                slot.ptInGuess,
                 comp,
                 largestGoodSlope
             );
             if (!isSlopeNonNeg) {
-                approx.guessMax = otInGuess;
+                approx.guessMax = slot.ptInGuess;
                 continue;
             }
 
             /// ------------------------------------------------------------
             /// CHECK ASSET
             /// ------------------------------------------------------------
-            (int256 _assetToAccount, ) = market.calcTrade(comp, otInGuess.neg());
-            uint256 netAssetOut = _assetToAccount.Uint();
+            (slot._assetToAccount, ) = market.calcTrade(comp, slot.ptInGuess.neg());
+            slot.netAssetOut = slot._assetToAccount.Uint();
 
-            if (netAssetOut >= minAssetOut) {
-                approx.guessMax = otInGuess;
+            if (slot.netAssetOut >= minAssetOut) {
+                approx.guessMax = slot.ptInGuess;
                 /// ------------------------------------------------------------
                 /// CHECK IF ANSWER FOUND
                 /// ------------------------------------------------------------
-                if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
-                    return (otInGuess, index.assetToScy(netAssetOut));
+                if (Math.isAGreaterApproxB(slot.netAssetOut, minAssetOut, approx.eps)) {
+                    return (slot.ptInGuess, index.assetToScy(slot.netAssetOut));
                 }
             } else {
-                approx.guessMin = otInGuess + 1;
+                approx.guessMin = slot.ptInGuess + 1;
+            }
+
+            unchecked {
+                ++iter;
             }
         }
         revert("approx fail");
     }
 
-    function approxSwapExactScyForOt(
+    function approxSwapExactScyForPt(
         MarketState memory market,
         SCYIndex index,
         uint256 maxScyIn,
@@ -108,7 +134,7 @@ library MarketApproxLib {
         internal
         pure
         returns (
-            uint256, /*netOtOut*/
+            uint256, /*netPtOut*/
             uint256 /*netScyIn*/
         )
     {
@@ -126,42 +152,43 @@ library MarketApproxLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxOtOut(market.totalOt, comp);
+            approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
         /// ------------------------------------------------------------
         /// BINARY SEARCH
         /// ------------------------------------------------------------
 
-        while (approx.maxIteration != 0) {
-            unchecked {
-                approx.maxIteration--;
-            }
-            uint256 otOutGuess = (approx.guessMin + approx.guessMax + 1) / 2;
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            uint256 ptOutGuess = getCurrentGuess(iter, approx);
 
             /// ------------------------------------------------------------
             /// CHECK ASSET
             /// ------------------------------------------------------------
-            (int256 _assetToAccount, ) = market.calcTrade(comp, otOutGuess.Int());
+            (int256 _assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
             uint256 netAssetIn = _assetToAccount.neg().Uint();
 
             if (netAssetIn <= maxAssetIn) {
-                approx.guessMin = otOutGuess;
+                approx.guessMin = ptOutGuess;
                 /// ------------------------------------------------------------
                 /// CHECK IF ANSWER FOUND
                 /// ------------------------------------------------------------
                 if (Math.isASmallerApproxB(netAssetIn, maxAssetIn, approx.eps)) {
-                    return (otOutGuess, index.assetToScy(netAssetIn));
+                    return (ptOutGuess, index.assetToScy(netAssetIn));
                 }
             } else {
-                approx.guessMax = otOutGuess - 1;
+                approx.guessMax = ptOutGuess - 1;
+            }
+
+            unchecked {
+                ++iter;
             }
         }
         revert("approx fail");
     }
 
     struct SlotSwapExactScyForYt {
-        uint256 otInGuess;
+        uint256 ptInGuess;
         int256 _assetToAccount;
         uint256 netAssetOut;
         uint256 amountAssetNeedMore;
@@ -197,53 +224,56 @@ library MarketApproxLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxOtIn(market.totalOt, comp.totalAsset);
+            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
         }
 
         /// ------------------------------------------------------------
         /// BINARY SEARCH
         /// ------------------------------------------------------------
 
-        while (approx.maxIteration != 0) {
-            unchecked {
-                approx.maxIteration--;
-            }
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            // iter++ at end of loop
 
             SlotSwapExactScyForYt memory slot;
-            // ytOutGuess = otInGuess
-            slot.otInGuess = (approx.guessMin + approx.guessMax + 1) / 2;
+            // ytOutGuess = ptInGuess
+
+            slot.ptInGuess = getCurrentGuess(iter, approx);
 
             /// ------------------------------------------------------------
             /// CHECK SLOPE
             /// ------------------------------------------------------------
             (isSlopeNonNeg, largestGoodSlope) = updateSlope(
-                market.totalOt,
-                slot.otInGuess,
+                market.totalPt,
+                slot.ptInGuess,
                 comp,
                 largestGoodSlope
             );
             if (!isSlopeNonNeg) {
-                approx.guessMax = slot.otInGuess - 1;
+                approx.guessMax = slot.ptInGuess - 1;
                 continue;
             }
 
             /// ------------------------------------------------------------
             /// CHECK ASSET
             /// ------------------------------------------------------------
-            (slot._assetToAccount, ) = market.calcTrade(comp, slot.otInGuess.neg());
+            (slot._assetToAccount, ) = market.calcTrade(comp, slot.ptInGuess.neg());
             slot.netAssetOut = slot._assetToAccount.Uint();
-            slot.amountAssetNeedMore = slot.otInGuess - slot.netAssetOut;
+            slot.amountAssetNeedMore = slot.ptInGuess - slot.netAssetOut;
 
             if (slot.amountAssetNeedMore <= maxAssetIn) {
-                approx.guessMin = slot.otInGuess;
+                approx.guessMin = slot.ptInGuess;
                 /// ------------------------------------------------------------
                 /// CHECK IF ANSWER FOUND
                 /// ------------------------------------------------------------
                 if (Math.isASmallerApproxB(slot.amountAssetNeedMore, maxAssetIn, approx.eps)) {
-                    return (slot.otInGuess, index.assetToScy(slot.amountAssetNeedMore));
+                    return (slot.ptInGuess, index.assetToScy(slot.amountAssetNeedMore));
                 }
             } else {
-                approx.guessMax = slot.otInGuess - 1;
+                approx.guessMax = slot.ptInGuess - 1;
+            }
+
+            unchecked {
+                ++iter;
             }
         }
         revert("approx fail");
@@ -277,106 +307,116 @@ library MarketApproxLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxOtOut(market.totalOt, comp);
+            approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
         /// ------------------------------------------------------------
         /// BINARY SEARCH
         /// ------------------------------------------------------------
 
-        while (approx.maxIteration != 0) {
-            unchecked {
-                approx.maxIteration--;
-            }
-            // ytInGuess = otOutGuess
-            uint256 otOutGuess = (approx.guessMin + approx.guessMax) / 2;
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            // iter++ at end of loop
+
+            // ytInGuess = ptOutGuess
+            uint256 ptOutGuess = getCurrentGuess(iter, approx);
 
             /// ------------------------------------------------------------
             /// CHECK ASSET
             /// ------------------------------------------------------------
-            (int256 _assetToAccount, ) = market.calcTrade(comp, otOutGuess.Int());
+            (int256 _assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
             uint256 netAssetOwed = _assetToAccount.neg().Uint();
 
-            // since otOutGuess is between guessMin & guessMax, it's guaranteed that
-            // there are enough Yt to pair with otOut
+            // since ptOutGuess is between guessMin & guessMax, it's guaranteed that
+            // there are enough Yt to pair with ptOut
 
-            uint256 netAssetOut = otOutGuess - netAssetOwed;
+            uint256 netAssetOut = ptOutGuess - netAssetOwed;
 
             if (netAssetOut >= minAssetOut) {
-                approx.guessMax = otOutGuess;
+                approx.guessMax = ptOutGuess;
                 /// ------------------------------------------------------------
                 /// CHECK IF ANSWER FOUND
                 /// ------------------------------------------------------------
                 if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
-                    return (otOutGuess, index.assetToScy(netAssetOut));
+                    return (ptOutGuess, index.assetToScy(netAssetOut));
                 }
             } else {
-                approx.guessMin = otOutGuess + 1;
+                approx.guessMin = ptOutGuess + 1;
+            }
+
+            unchecked {
+                ++iter;
             }
         }
         revert("approx fail");
     }
 
     function updateSlope(
-        int256 totalOt,
-        uint256 otInGuess,
+        int256 totalPt,
+        uint256 ptInGuess,
         MarketPreCompute memory comp,
         uint256 largestGoodSlope
     ) internal pure returns (bool isSlopeNonNeg, uint256 newLargestGoodSlop) {
-        if (otInGuess <= largestGoodSlope) {
+        if (ptInGuess <= 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);
+        int256 slope = slopeFactor(totalPt, ptInGuess.neg(), comp);
+        if (slope >= 0) return (true, ptInGuess);
         else return (false, largestGoodSlope);
     }
 
-    // otToMarket < totalAsset && totalOt
+    // ptToMarket < totalAsset && totalPt
     function slopeFactor(
-        int256 totalOt,
-        int256 otToAccount,
+        int256 totalPt,
+        int256 ptToAccount,
         MarketPreCompute memory comp
     ) internal pure returns (int256) {
-        int256 otToMarket = -otToAccount;
-        int256 diffAssetOtToMarket = comp.totalAsset - otToMarket;
-        int256 sumOt = otToMarket + totalOt;
+        int256 ptToMarket = -ptToAccount;
+        int256 diffAssetPtToMarket = comp.totalAsset - ptToMarket;
+        int256 sumPt = ptToMarket + totalPt;
 
-        require(diffAssetOtToMarket > 0 && sumOt > 0, "invalid otToMarket");
+        require(diffAssetPtToMarket > 0 && sumPt > 0, "invalid ptToMarket");
 
-        int256 part1 = (otToMarket * (totalOt + comp.totalAsset)).divDown(
-            sumOt * diffAssetOtToMarket
+        int256 part1 = (ptToMarket * (totalPt + comp.totalAsset)).divDown(
+            sumPt * diffAssetPtToMarket
         );
 
-        int256 part2 = sumOt.divDown(diffAssetOtToMarket).ln();
+        int256 part2 = sumPt.divDown(diffAssetPtToMarket).ln();
         int256 part3 = Math.IONE.divDown(comp.rateScalar);
 
         return comp.rateAnchor - (part1 - part2).mulDown(part3);
     }
 
-    function calcMaxOtOut(int256 totalOt, MarketPreCompute memory comp)
+    function calcMaxPtOut(int256 totalPt, MarketPreCompute memory comp)
         internal
         pure
         returns (uint256)
     {
-        int256 logitP = (Math.IONE.mulDown(comp.feeRate) - comp.rateAnchor)
+        int256 logitP = (Math.IONE.mulDown(comp.lnFeeRate) - 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;
+        int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);
+        int256 maxPtOut = totalPt - numerator;
+        // only get 99.9% of the theoretical max to accommodate some precision issues
+        return (maxPtOut.Uint() * 999) / 1000;
     }
 
-    function calcMaxOtIn(int256 totalOt, int256 totalAsset) internal pure returns (uint256) {
-        return Math.min(totalOt, totalAsset).Uint() - 1;
+    function calcMaxPtIn(int256 totalPt, int256 totalAsset) internal pure returns (uint256) {
+        return Math.min(totalPt, totalAsset).Uint() - 1;
     }
 
     function isValidApproxParams(ApproxParams memory approx) internal pure returns (bool) {
-        return (approx.guessMin <= approx.guessMax &&
-            approx.maxIteration <= 256 &&
-            approx.eps <= Math.ONE);
+        return (approx.guessMin <= approx.guessMax && approx.eps <= Math.ONE);
+    }
+
+    function getCurrentGuess(uint256 iteration, ApproxParams memory approx)
+        internal
+        pure
+        returns (uint256)
+    {
+        if (iteration == 0 && approx.guessOffchain != 0) return approx.guessOffchain;
+        else return (approx.guessMin + approx.guessMax) / 2;
     }
 }

package/contracts/libraries/math/MarketMathAux.sol

@@ -15,7 +15,7 @@ library MarketMathAux {
         MarketState memory market,
         SCYIndex index,
         uint256 scyDesired,
-        uint256 otDesired,
+        uint256 ptDesired,
         bool updateState
     )
         internal
@@ -24,7 +24,7 @@ library MarketMathAux {
             uint256 lpToReserve,
             uint256 lpToAccount,
             uint256 scyUsed,
-            uint256 otUsed
+            uint256 ptUsed
         )
     {
         (
@@ -36,42 +36,42 @@ library MarketMathAux {
                 market,
                 index,
                 scyDesired.Int(),
-                otDesired.Int(),
+                ptDesired.Int(),
                 updateState
             );
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
         scyUsed = _scyUsed.Uint();
-        otUsed = _otUsed.Uint();
+        ptUsed = _otUsed.Uint();
     }
 
     function removeLiquidity(
         MarketState memory market,
         uint256 lpToRemove,
         bool updateState
-    ) internal pure returns (uint256 scyToAccount, uint256 netOtToAccount) {
-        (int256 _scyToAccount, int256 _otToAccount) = MarketMathCore.removeLiquidityCore(
+    ) internal pure returns (uint256 scyToAccount, uint256 netPtToAccount) {
+        (int256 _scyToAccount, int256 _ptToAccount) = MarketMathCore.removeLiquidityCore(
             market,
             lpToRemove.Int(),
             updateState
         );
 
         scyToAccount = _scyToAccount.Uint();
-        netOtToAccount = _otToAccount.Uint();
+        netPtToAccount = _ptToAccount.Uint();
     }
 
-    function swapExactOtForScy(
+    function swapExactPtForScy(
         MarketState memory market,
         SCYIndex index,
-        uint256 exactOtToMarket,
+        uint256 exactPtToMarket,
         uint256 blockTime,
         bool updateState
     ) internal pure returns (uint256 netScyToAccount, uint256 netScyToReserve) {
         (int256 _netScyToAccount, int256 _netScyToReserve) = MarketMathCore.executeTradeCore(
             market,
             index,
-            exactOtToMarket.neg(),
+            exactPtToMarket.neg(),
             blockTime,
             updateState
         );
@@ -80,17 +80,17 @@ library MarketMathAux {
         netScyToReserve = _netScyToReserve.Uint();
     }
 
-    function swapScyForExactOt(
+    function swapScyForExactPt(
         MarketState memory market,
         SCYIndex index,
-        uint256 exactOtToAccount,
+        uint256 exactPtToAccount,
         uint256 blockTime,
         bool updateState
     ) internal pure returns (uint256 netScyToMarket, uint256 netScyToReserve) {
         (int256 _netScyToAccount, int256 _netScyToReserve) = MarketMathCore.executeTradeCore(
             market,
             index,
-            exactOtToAccount.Int(),
+            exactPtToAccount.Int(),
             blockTime,
             updateState
         );