@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/libraries/helpers/TokenHelper.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract TokenHelper {
+    using SafeERC20 for IERC20;
+    address internal constant NATIVE = address(0);
+
+    function _transferIn(
+        address token,
+        address from,
+        uint256 amount
+    ) internal {
+        if (amount == 0 || token == NATIVE) return;
+        IERC20(token).safeTransferFrom(from, address(this), amount);
+    }
+
+    function _transferOut(
+        address token,
+        address to,
+        uint256 amount
+    ) internal {
+        if (amount == 0) return;
+        if (token == NATIVE) {
+            (bool success, ) = to.call{ value: amount }("");
+            require(success, "eth send failed");
+        } else {
+            IERC20(token).safeTransfer(to, amount);
+        }
+    }
+
+    function _transferOut(
+        address[] memory tokens,
+        address to,
+        uint256[] memory amounts
+    ) internal {
+        uint256 numTokens = tokens.length;
+        require(numTokens == amounts.length, "length mismatch");
+        for (uint256 i = 0; i < numTokens; ) {
+            _transferOut(tokens[i], to, amounts[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function _transferOutMaxMulti(
+        address token,
+        uint256 totalAmount,
+        address[] memory tos,
+        uint256[] memory maxAmounts
+    ) internal {
+        uint256 numTos = tos.length;
+        require(numTos == maxAmounts.length, "invalid length");
+
+        uint256 remaining = totalAmount;
+        for (uint256 i = 0; i < numTos; ) {
+            uint256 maxAmount = maxAmounts[i];
+            if (maxAmount > remaining) {
+                maxAmount = remaining;
+            }
+            _transferOut(token, tos[i], maxAmount);
+            unchecked {
+                remaining -= maxAmount;
+                i++;
+            }
+        }
+    }
+
+    function _selfBalance(address token) internal view returns (uint256) {
+        return (token == NATIVE) ? address(this).balance : IERC20(token).balanceOf(address(this));
+    }
+
+    function _selfBalances(address[] memory tokens)
+        internal
+        view
+        returns (uint256[] memory balances)
+    {
+        uint256 length = tokens.length;
+        balances = new uint256[](length);
+        for (uint256 i = 0; i < length; ) {
+            balances[i] = _selfBalance(tokens[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /// @notice Approves the stipulated contract to spend the given allowance in the given token
+    /// @dev Errors with 'SA' if transfer fails
+    /// @param token The contract address of the token to be approved
+    /// @param to The target of the approval
+    /// @param value The amount of the given token the target will be allowed to spend
+    function _safeApprove(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) = token.call(
+            abi.encodeWithSelector(IERC20.approve.selector, to, value)
+        );
+        require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
+    }
+}

package/contracts/libraries/math/LogExpMath.sol

@@ -12,7 +12,7 @@
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 /* solhint-disable */
 
@@ -53,6 +53,8 @@ library LogExpMath {
     int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
     int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
 
+    uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);
+
     // 18 decimal constants
     int256 constant x0 = 128000000000000000000; // 2ˆ7
     int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)
@@ -240,6 +242,62 @@ library LogExpMath {
         }
     }
 
+    /**
+     * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.
+     *
+     * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
+     */
+    function pow(uint256 x, uint256 y) internal pure returns (uint256) {
+        if (y == 0) {
+            // We solve the 0^0 indetermination by making it equal one.
+            return uint256(ONE_18);
+        }
+
+        if (x == 0) {
+            return 0;
+        }
+
+        // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
+        // arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
+        // x^y = exp(y * ln(x)).
+
+        // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
+        require(x < 2**255, "x out of bounds");
+        int256 x_int256 = int256(x);
+
+        // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
+        // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
+
+        // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
+        require(y < MILD_EXPONENT_BOUND, "y out of bounds");
+        int256 y_int256 = int256(y);
+
+        int256 logx_times_y;
+        if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
+            int256 ln_36_x = _ln_36(x_int256);
+
+            // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
+            // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
+            // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
+            // (downscaled) last 18 decimals.
+            logx_times_y = ((ln_36_x / ONE_18) *
+                y_int256 +
+                ((ln_36_x % ONE_18) * y_int256) /
+                ONE_18);
+        } else {
+            logx_times_y = _ln(x_int256) * y_int256;
+        }
+        logx_times_y /= ONE_18;
+
+        // Finally, we compute exp(y * ln(x)) to arrive at x^y
+        require(
+            MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
+            "product out of bounds"
+        );
+
+        return uint256(exp(logx_times_y));
+    }
+
     /**
      * @dev Internal natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
      */

package/contracts/libraries/math/MarketApproxLib.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "./Math.sol";
 import "./MarketMathCore.sol";
@@ -36,12 +36,17 @@ library MarketApproxLib {
     using SCYIndexLib for SCYIndex;
     using MarketMathCore for MarketState;
 
-    struct SlotSwapPtForExactScy {
-        uint256 ptInGuess;
-        int256 _assetToAccount;
+    struct VarsSwapPtForExactScy {
+        uint256 netPtInGuess;
+        int256 assetToAccount;
         uint256 netAssetOut;
+        uint256 minAssetOut;
+        uint256 largestGoodSlope;
+        bool isSlopeNonNeg;
     }
 
+    /// `guessMin` & `guessMax` is to guess the `netPtIn`
+
     function approxSwapPtForExactScy(
         MarketState memory market,
         SCYIndex index,
@@ -56,65 +61,59 @@ library MarketApproxLib {
             uint256 /*netScyOut*/
         )
     {
-        /// ------------------------------------------------------------
-        /// CHECKS
-        /// ------------------------------------------------------------
-        require(minScyOut > 0, "invalid minScyOut");
-        require(isValidApproxParams(approx), "invalid approx approx");
+        /*
+        the algorithm is essentially to:
+        1. binary search netPtIn
+        2. if netScyOut is greater & approx minScyOut => answer found
+
+        Psuedo code:
+        binary search netPtIn:
+            netAssetOut = calcTrade(netPtIn)
+            if (netScyOut >= minScyOut):
+                guessMax = netPtIn;
+                if (netScyOut `greaterApprox` minScyOut) => answer found
+            else:
+                guessMin = netPtIn;
+        */
 
-        /// ------------------------------------------------------------
-        /// SET UP VARIABLES
-        /// ------------------------------------------------------------
-        uint256 minAssetOut = index.scyToAsset(minScyOut);
-        uint256 largestGoodSlope;
-        bool isSlopeNonNeg;
+        require(isValidApproxParams(approx), "invalid approx approx");
 
+        VarsSwapPtForExactScy memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
             approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
         }
-
-        /// ------------------------------------------------------------
-        /// BINARY SEARCH
-        /// ------------------------------------------------------------
+        vars.minAssetOut = index.scyToAsset(minScyOut);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
-            // ++iter at end of loop
-
-            SlotSwapPtForExactScy memory slot;
-            slot.ptInGuess = getCurrentGuess(iter, approx);
+            vars.netPtInGuess = getCurrentGuess(iter, approx);
 
-            /// ------------------------------------------------------------
-            /// CHECK SLOPE
-            /// ------------------------------------------------------------
-            (isSlopeNonNeg, largestGoodSlope) = updateSlope(
-                market.totalPt,
-                slot.ptInGuess,
+            (vars.isSlopeNonNeg, vars.largestGoodSlope) = updateSlope(
                 comp,
-                largestGoodSlope
+                market.totalPt,
+                vars.netPtInGuess,
+                vars.largestGoodSlope
             );
-            if (!isSlopeNonNeg) {
-                approx.guessMax = slot.ptInGuess;
+            if (!vars.isSlopeNonNeg) {
+                approx.guessMax = vars.netPtInGuess;
                 continue;
             }
 
-            /// ------------------------------------------------------------
-            /// CHECK ASSET
-            /// ------------------------------------------------------------
-            (slot._assetToAccount, ) = market.calcTrade(comp, slot.ptInGuess.neg());
-            slot.netAssetOut = slot._assetToAccount.Uint();
-
-            if (slot.netAssetOut >= minAssetOut) {
-                approx.guessMax = slot.ptInGuess;
-                /// ------------------------------------------------------------
-                /// CHECK IF ANSWER FOUND
-                /// ------------------------------------------------------------
-                if (Math.isAGreaterApproxB(slot.netAssetOut, minAssetOut, approx.eps)) {
-                    return (slot.ptInGuess, index.assetToScy(slot.netAssetOut));
-                }
+            (vars.assetToAccount, ) = market.calcTrade(comp, vars.netPtInGuess.neg());
+            vars.netAssetOut = vars.assetToAccount.Uint();
+
+            if (vars.netAssetOut >= vars.minAssetOut) {
+                approx.guessMax = vars.netPtInGuess;
+                bool isAnswerAccepted = Math.isAGreaterApproxB(
+                    vars.netAssetOut,
+                    vars.minAssetOut,
+                    approx.eps
+                );
+                if (isAnswerAccepted)
+                    return (vars.netPtInGuess, index.assetToScy(vars.netAssetOut));
             } else {
-                approx.guessMin = slot.ptInGuess + 1;
+                approx.guessMin = vars.netPtInGuess;
             }
 
             unchecked {
@@ -124,7 +123,18 @@ library MarketApproxLib {
         revert("approx fail");
     }
 
-    function approxSwapExactScyForPt(
+    struct VarsSwapExactScyForYt {
+        uint256 ptInGuess;
+        int256 assetToAccount;
+        uint256 netAssetOut;
+        uint256 amountAssetNeedMore;
+        uint256 largestGoodSlope;
+        bool isSlopeNonNeg;
+        uint256 maxAssetIn;
+    }
+
+    /// `guessMin` & `guessMax` is to guess the `netPtIn` == `netYtOut`
+    function approxSwapExactScyForYt(
         MarketState memory market,
         SCYIndex index,
         uint256 maxScyIn,
@@ -134,50 +144,72 @@ library MarketApproxLib {
         internal
         pure
         returns (
-            uint256, /*netPtOut*/
+            uint256, /*netYtOut*/
             uint256 /*netScyIn*/
         )
     {
-        /// ------------------------------------------------------------
-        /// CHECKS
-        /// ------------------------------------------------------------
-        require(maxScyIn > 0, "invalid maxScyIn");
-        require(isValidApproxParams(approx), "invalid approx approx");
+        /*
+        the algorithm is essentially to:
+        1. Binary search netPtIn (therefore netScyOut)
+        2. flashswap some netScyOut (now we owe netPtIn)
+        3. Use netScyOut + additional SCY from user => convert to PT + YT
+        4. Pay back PT & give user YT.
+        5. If the PT loan can be successfully & amount of additional SCY is smallerApprox maxScyIn
+        => answer found
+
+        Psuedo code:
+        maxAssetIn = maxScyIn -> asset
+        binary search netPtIn:
+            netAssetOut = calcTrade(netPtIn)
+            totalAssetNeedMoreToConvertPt = netPtIn - netAssetOut
+            if (totalAssetNeedMoreToConvertPt <= maxAssetIn):
+                guessMin = netPtIn;
+                if (totalAssetNeedMoreToConvertPt `smallerApprox` maxAssetIn) => answer found
+            else:
+                guessMax = netPtOut;
+        */
 
-        /// ------------------------------------------------------------
-        /// SET UP VAIRBALES
-        /// ------------------------------------------------------------
-        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
+        require(isValidApproxParams(approx), "invalid approx approx");
 
+        VarsSwapExactScyForYt memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxPtOut(market.totalPt, comp);
+            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
         }
 
-        /// ------------------------------------------------------------
-        /// BINARY SEARCH
-        /// ------------------------------------------------------------
+        vars.maxAssetIn = index.scyToAsset(maxScyIn);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
-            uint256 ptOutGuess = getCurrentGuess(iter, approx);
+            // ytOutGuess = ptInGuess
+            vars.ptInGuess = getCurrentGuess(iter, approx);
 
-            /// ------------------------------------------------------------
-            /// CHECK ASSET
-            /// ------------------------------------------------------------
-            (int256 _assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
-            uint256 netAssetIn = _assetToAccount.neg().Uint();
+            (vars.isSlopeNonNeg, vars.largestGoodSlope) = updateSlope(
+                comp,
+                market.totalPt,
+                vars.ptInGuess,
+                vars.largestGoodSlope
+            );
+            if (!vars.isSlopeNonNeg) {
+                approx.guessMax = vars.ptInGuess - 1;
+                continue;
+            }
 
-            if (netAssetIn <= maxAssetIn) {
-                approx.guessMin = ptOutGuess;
-                /// ------------------------------------------------------------
-                /// CHECK IF ANSWER FOUND
-                /// ------------------------------------------------------------
-                if (Math.isASmallerApproxB(netAssetIn, maxAssetIn, approx.eps)) {
-                    return (ptOutGuess, index.assetToScy(netAssetIn));
-                }
+            (vars.assetToAccount, ) = market.calcTrade(comp, vars.ptInGuess.neg());
+            vars.netAssetOut = vars.assetToAccount.Uint();
+            vars.amountAssetNeedMore = vars.ptInGuess - vars.netAssetOut;
+
+            if (vars.amountAssetNeedMore <= vars.maxAssetIn) {
+                approx.guessMin = vars.ptInGuess;
+                bool isAnswerAccepted = Math.isASmallerApproxB(
+                    vars.amountAssetNeedMore,
+                    vars.maxAssetIn,
+                    approx.eps
+                );
+                if (isAnswerAccepted)
+                    return (vars.ptInGuess, index.assetToScy(vars.amountAssetNeedMore));
             } else {
-                approx.guessMax = ptOutGuess - 1;
+                approx.guessMax = vars.ptInGuess - 1;
             }
 
             unchecked {
@@ -187,14 +219,7 @@ library MarketApproxLib {
         revert("approx fail");
     }
 
-    struct SlotSwapExactScyForYt {
-        uint256 ptInGuess;
-        int256 _assetToAccount;
-        uint256 netAssetOut;
-        uint256 amountAssetNeedMore;
-    }
-
-    function approxSwapExactScyForYt(
+    function approxSwapExactScyForPt(
         MarketState memory market,
         SCYIndex index,
         uint256 maxScyIn,
@@ -204,72 +229,46 @@ library MarketApproxLib {
         internal
         pure
         returns (
-            uint256, /*netYtOut*/
+            uint256, /*netPtOut*/
             uint256 /*netScyIn*/
         )
     {
-        /// ------------------------------------------------------------
-        /// CHECKS
-        /// ------------------------------------------------------------
-        require(maxScyIn > 0, "invalid maxScyIn");
-        require(isValidApproxParams(approx), "invalid approx approx");
+        /*
+        the algorithm is essentially to:
+        1. binary search netPtOut
+        2. if netScyIn smaller & approx maxScyIn => answer found
+
+        Psuedo code:
+        maxAssetIn = maxScyIn -> asset
+        binary search netPtOut:
+            netAssetIn = calcTrade(netPtOut)
+            if (netAssetIn <= maxAssetIn):
+                guessMin = netPtOut
+                if (netAssetIn `smallerApprox` maxAssetIn) => answer found
+            else:
+                guessMax = netPtOut;
+        */
 
-        /// ------------------------------------------------------------
-        /// SET UP VAIRBALES
-        /// ------------------------------------------------------------
-        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
-        uint256 largestGoodSlope;
-        bool isSlopeNonNeg;
+        require(isValidApproxParams(approx), "invalid approx approx");
 
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
-
         if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
+            approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
-        /// ------------------------------------------------------------
-        /// BINARY SEARCH
-        /// ------------------------------------------------------------
+        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
-            // iter++ at end of loop
-
-            SlotSwapExactScyForYt memory slot;
-            // ytOutGuess = ptInGuess
-
-            slot.ptInGuess = getCurrentGuess(iter, approx);
-
-            /// ------------------------------------------------------------
-            /// CHECK SLOPE
-            /// ------------------------------------------------------------
-            (isSlopeNonNeg, largestGoodSlope) = updateSlope(
-                market.totalPt,
-                slot.ptInGuess,
-                comp,
-                largestGoodSlope
-            );
-            if (!isSlopeNonNeg) {
-                approx.guessMax = slot.ptInGuess - 1;
-                continue;
-            }
+            uint256 ptOutGuess = getCurrentGuess(iter, approx);
+            (int256 assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
+            uint256 netAssetIn = assetToAccount.abs();
 
-            /// ------------------------------------------------------------
-            /// CHECK ASSET
-            /// ------------------------------------------------------------
-            (slot._assetToAccount, ) = market.calcTrade(comp, slot.ptInGuess.neg());
-            slot.netAssetOut = slot._assetToAccount.Uint();
-            slot.amountAssetNeedMore = slot.ptInGuess - slot.netAssetOut;
-
-            if (slot.amountAssetNeedMore <= maxAssetIn) {
-                approx.guessMin = slot.ptInGuess;
-                /// ------------------------------------------------------------
-                /// CHECK IF ANSWER FOUND
-                /// ------------------------------------------------------------
-                if (Math.isASmallerApproxB(slot.amountAssetNeedMore, maxAssetIn, approx.eps)) {
-                    return (slot.ptInGuess, index.assetToScy(slot.amountAssetNeedMore));
-                }
+            if (netAssetIn <= maxAssetIn) {
+                approx.guessMin = ptOutGuess;
+                bool isAnswerAccepted = Math.isASmallerApproxB(netAssetIn, maxAssetIn, approx.eps);
+                if (isAnswerAccepted) return (ptOutGuess, index.assetToScy(netAssetIn));
             } else {
-                approx.guessMax = slot.ptInGuess - 1;
+                approx.guessMax = ptOutGuess;
             }
 
             unchecked {
@@ -293,38 +292,42 @@ library MarketApproxLib {
             uint256 /*netScyOut*/
         )
     {
-        /// ------------------------------------------------------------
-        /// CHECKS
-        /// ------------------------------------------------------------
-        require(minScyOut > 0, "invalid maxScyIn");
-        require(isValidApproxParams(approx), "invalid approx approx");
+        /*
+        the algorithm is essentially to:
+        1. Binary search netPtOut (therefore netScyIn) (netYtIn == netPtOut)
+        2. flashswap netPtOut (now we owe netScyIn)
+        3. Pair netPtOut with the corresponding amount of Yt => redeem Scy
+        4. Pay back Scy & the exceed amount of Scy (netScyOut) is transferred out to user
+        5. If netScyOut is greater approx minScyOut => answer found
+
+        Psuedo code:
+        minAssetOut = minScyOut -> asset
+        binary search netPtOut:
+            netAssetIn = calcTrade(netPtOut)
+            netAssetFromPtYt = netPtOut
+            netAssetOut = netAssetFromPtYt - netAssetIn
+            if (netAssetOut >= minAssetOut):
+                guessMax = netPtOut
+                if (netAssetOut `greaterApprox` minAssetOut) => answer found
+            else:
+                guessMin = netPtOut;
+        */
 
-        /// ------------------------------------------------------------
-        /// SET UP VAIRBALES
-        /// ------------------------------------------------------------
-        uint256 minAssetOut = index.scyToAsset(minScyOut);
+        require(isValidApproxParams(approx), "invalid approx approx");
 
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
-
         if (approx.guessMax == type(uint256).max) {
             approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
-        /// ------------------------------------------------------------
-        /// BINARY SEARCH
-        /// ------------------------------------------------------------
+        uint256 minAssetOut = index.scyToAsset(minScyOut);
 
         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, ptOutGuess.Int());
-            uint256 netAssetOwed = _assetToAccount.neg().Uint();
+            (int256 assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
+            uint256 netAssetOwed = assetToAccount.abs();
 
             // since ptOutGuess is between guessMin & guessMax, it's guaranteed that
             // there are enough Yt to pair with ptOut
@@ -333,9 +336,6 @@ library MarketApproxLib {
 
             if (netAssetOut >= minAssetOut) {
                 approx.guessMax = ptOutGuess;
-                /// ------------------------------------------------------------
-                /// CHECK IF ANSWER FOUND
-                /// ------------------------------------------------------------
                 if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
                     return (ptOutGuess, index.assetToScy(netAssetOut));
                 }
@@ -351,9 +351,9 @@ library MarketApproxLib {
     }
 
     function updateSlope(
+        MarketPreCompute memory comp,
         int256 totalPt,
         uint256 ptInGuess,
-        MarketPreCompute memory comp,
         uint256 largestGoodSlope
     ) internal pure returns (bool isSlopeNonNeg, uint256 newLargestGoodSlop) {
         if (ptInGuess <= largestGoodSlope) {
@@ -393,7 +393,7 @@ library MarketApproxLib {
         pure
         returns (uint256)
     {
-        int256 logitP = (Math.IONE.mulDown(comp.lnFeeRate) - comp.rateAnchor)
+        int256 logitP = (Math.IONE.mulDown(comp.feeRate) - comp.rateAnchor)
             .mulDown(comp.rateScalar)
             .exp();
         int256 proportion = logitP.divDown(logitP + Math.IONE);
@@ -417,6 +417,9 @@ library MarketApproxLib {
         returns (uint256)
     {
         if (iteration == 0 && approx.guessOffchain != 0) return approx.guessOffchain;
-        else return (approx.guessMin + approx.guessMax) / 2;
+        else {
+            if (approx.guessMin > approx.guessMax) return approx.guessMax;
+            return (approx.guessMin + approx.guessMax) / 2;
+        }
     }
 }