aftermath-ts-sdk 0.0.136 → 0.0.138

package/dist/packages/pools/utils/cmmmCalculations.js

@@ -2,11 +2,38 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CmmmCalculations = void 0;
-const coin_1 = require("../../coin/coin");
 const utils_1 = require("../../../general/utils");
+const fixed_1 = require("../../../general/utils/fixed");
 // This file is the typescript version of on-chain calculations. See the .move file for license info.
 // These calculations are useful for estimating values on-chain but the JS number format is LESS PRECISE!
 // Do not expect these values to be identical to their on-chain counterparts.
+// The formula used here differs from that of Curve/Balancer. Our stables allow custom price pegs as opposed to
+// the constant 1:1 equal-weight peg. Also our pools do not have an upper coin type limit (practically).
+// Here is our construction:
+// Start with a pool with balances b1,...,bn > 0. Call the tuple B = (b1,...,bn).
+// Take weights w1,...,wn with 0 < wi < 1 and w1 + ... + wn = 1.
+// Let X stand for the tuple (x1,...,xn) in Rn.
+// For normalization we need the tuple T = (h,h,...,h) for some h > 0, solved for later.
+// The invariant is defined as the value of this h.
+// -- TODO: generalize this reference point T to lie on a chosen ray like (w1*h, w2*h, ..., wn*h).
+// -- This would allow setting the swap price to be centered at a chosen balance distribution instead
+// -- of the 1:1:...:1 diagonal balance distribution currently in use.
+// Define the sum function S: Rn -> R as S(X) = w1*x1 + ... + wn*xn.
+// Define the product function P: Rn -> R as P(X) = x1^w1 * ... * xn^wn.
+// Note P(T) = S(T) = h.
+// We want the sum to vanish on the coordinate hyperplanes too so instead use L where
+// L(X) = [2P(X) / (P(X) + P(T))] * S(X)
+// Then 0 <= L(X) < 2S(X) and L(T) = h.
+// The constant price surface is defined by the equation L(X) = L(B) and the product curve by
+// P(X) = P(B). Equivilantly by L(X) - L(B) = 0, P(X) - P(B) = 0.
+// Take a flatness parameter A, 0 <= A <= 1. Then (1-A) is the dual parameter:
+// 0 <= (1-A) <= 1 and A + (1-A) = 1. Take the linear combination of the defining functions
+// C(X) = A * L(X) + (1-A) * P(X). The stable curve is defined as the solution to C(X) = C(B).
+// Moreover we can solve for T from the equation C(T) = C(B), making all the following equal:
+// C(B) = L(T) = S(T) = P(T) = h.
+// The defining equation C(X) = C(B) can be rewritten in a computationally simpler form as
+// P(X) * (2A * S(X) + (1-A) * P(X)) = h * (A * P(X) + h).
+// To see these functions/equations in action check out https://www.desmos.com/calculator/eu5mfckuk9
 class CmmmCalculations {
 }
 exports.CmmmCalculations = CmmmCalculations;
@@ -26,21 +53,15 @@ CmmmCalculations.minInvariantRatio = 0.7;
 CmmmCalculations.maxInvariantRatio = 3;
 CmmmCalculations.maxNewtonAttempts = 255;
 CmmmCalculations.convergenceBound = 1e-9;
-CmmmCalculations.withdrawConvergenceBound = 0.000001;
-// pools assume coins are stored in raw integer format
-// every other fixed point nubmer is in 18 point format
-// these terms come from their on chain equivalents where direct cast means (x: u64 as u256)
-CmmmCalculations.convertFromInt = (n) => Number(n);
-CmmmCalculations.convertToInt = (n) => BigInt(Math.floor(n));
-CmmmCalculations.directCast = (n) => coin_1.Coin.balanceWithDecimals(n, 18);
-CmmmCalculations.directUncast = (n) => coin_1.Coin.normalizeBalance(n, 18);
+CmmmCalculations.tolerance = 1e-13;
+CmmmCalculations.validityTolerance = 0.000001;
 // Invariant is used to govern pool behavior. Swaps are operations which change the pool balances without changing
 // the invariant (ignoring fees) and investments change the invariant without changing the distribution of balances.
 // Invariant and pool lp are almost in 1:1 correspondence -- e.g. burning lp in a withdraw proportionally lowers the pool invariant.
 // The difference is as swap fees are absorbed they increase the invariant without incrasing total lp, increasing lp worth.
 // Every pool operation either explicitly or implicity calls this function.
 CmmmCalculations.calcInvariant = (pool) => {
-    let flatness = CmmmCalculations.directCast(pool.flatness);
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
     // The value for h which we want is the one for which the balances vector B lies on the curve through T.
     // That is, C(T) = C(B). This turns out to be a quadratic equation which can be solved with
     // h = [sqrt[P(B) * (P(B) * (A*A + 4*(1-A)) + 8*A*S(B))] - A*P(B)] / 2.
@@ -49,8 +70,8 @@ CmmmCalculations.calcInvariant = (pool) => {
     let balance;
     let weight;
     for (let coin of Object.values(pool.coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        weight = CmmmCalculations.directCast(coin.weight);
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
         sum += weight * balance;
         prod += weight * Math.log(balance);
     }
@@ -73,7 +94,7 @@ CmmmCalculations.calcInvariantQuadratic = (prod, sum, flatness) => (Math.sqrt(pr
 // s0 = w1*b1 + ... + [wi*bi] + ... + wn*bn (remove bi from sum)
 // h is the invariant
 CmmmCalculations.calcInvariantComponents = (pool, index) => {
-    let flatness = CmmmCalculations.directCast(pool.flatness);
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
     let prod = 0;
     let sum = 0;
     let p0 = 0;
@@ -83,8 +104,8 @@ CmmmCalculations.calcInvariantComponents = (pool, index) => {
     let p;
     let s;
     for (let [coinType, coin] of Object.entries(pool.coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        weight = CmmmCalculations.directCast(coin.weight);
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
         p = weight * Math.log(balance);
         s = weight * balance;
         prod = prod + p;
@@ -104,106 +125,20 @@ CmmmCalculations.calcInvariantComponents = (pool, index) => {
         CmmmCalculations.calcInvariantQuadratic(prod, sum, flatness),
     ];
 };
-// This function calculates the balance of a given token (index) given all the other balances (combined in p0, s0)
-// and the invariant along with an initial estimate. It is useful for 1d optimization.
-CmmmCalculations.getTokenBalanceGivenInvariantAndAllOtherBalances = (flatness, w, h, xi, // initial estimate -- default can be (P(X) / p0)^n
-p0, // P(B) / xi^(1/n) (everything but the missing part)
-s0 // S(B) - xi / n (everything but the missing part)
-) => {
-    // Standard Newton method used here
-    // ---------------- setting constants ----------------
-    // c1 = 2*A*w*w
-    // c2 = 2*(1-A)*w*p0
-    // c3 = A*(2*w*s0+t)
-    // c4 = t*t/p0
-    // c5 = (1-A)*p0
-    // c6 = A*(2*s0+w*t)
-    // c7 = 2*A*w*(w+1)
-    // c8 = 2*(1-A)*p0
-    // c9 = 2*A*w*s0
-    // c10= A*w*t
-    let ac = 1 - flatness;
-    let aw = flatness * w;
-    let acw = ac * w;
-    let as0 = flatness * s0;
-    let ah = flatness * h;
-    let c1 = 2 * aw * w;
-    let c2 = 2 * acw * p0;
-    let c3 = 2 * w * as0 + ah;
-    let c4 = (h * h) / p0;
-    let c5 = ac * p0;
-    let c6 = 2 * as0 + w * ah;
-    let c7 = 2 * aw * (w + 1);
-    let c8 = 2 * acw * p0;
-    let c9 = 2 * aw * s0;
-    let c10 = aw * h;
-    // ---------------- iterating ----------------
-    //x = (
-    //    x * (
-    //        (
-    //            x^w * (
-    //                c1 * x + c2 * x^w + c3
-    //            ) + c4
-    //        ) - x^w * (
-    //            c5 * x^w + c6
-    //        )
-    //    )
-    //) / (
-    //    x^w * (
-    //        (
-    //            c7 * x + c8 * x^w + c9
-    //        ) - c10
-    //    )
-    //)
-    let x = xi;
-    let xw; // x^w
-    let topPos;
-    let topNeg;
-    let bottomPos;
-    //let bottomNeg;
-    let prevX = x;
-    let i = 0;
-    while (i < CmmmCalculations.maxNewtonAttempts) {
-        xw = Math.pow(x, w);
-        topPos = x * (xw * (c1 * x + c2 * xw + c3) + c4);
-        topNeg = x * (xw * (c5 * xw + c6));
-        bottomPos = c7 * x + c8 * xw + c9;
-        //bottomNeg = c10;
-        // If x jumps too much (bad initial estimate) then g(x) might overshoot into a negative number.
-        // This only happens if x is supposed to be small. In this case, replace x with a small number and try again.
-        // Once x is close enough to the true value g(x) won't overshoot anymore and this test will be skipped from then on.
-        if (topPos < topNeg || bottomPos < c10) {
-            x = 1 / Math.pow(2, i);
-            i = i + 1;
-            continue;
-        }
-        x = (topPos - topNeg) / (xw * (bottomPos - c10));
-        // using relative error here (easier to pass) because js numbers are less precise
-        if (utils_1.Helpers.closeEnough(x, prevX, CmmmCalculations.convergenceBound)) {
-            return x;
-        }
-        prevX = x;
-        i = i + 1;
-    }
-    throw Error("Newton diverged");
-};
+// spot price is given in units of Bin / Bout
 CmmmCalculations.calcSpotPrice = (pool, coinTypeIn, coinTypeOut) => CmmmCalculations.calcSpotPriceWithFees(pool, coinTypeIn, coinTypeOut, true);
 // spot price is given in units of Bin / Bout
 CmmmCalculations.calcSpotPriceWithFees = (pool, coinTypeIn, coinTypeOut, ignoreFees) => {
-    let a = CmmmCalculations.directCast(pool.flatness);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
     let part1 = CmmmCalculations.calcSpotPriceBody(pool);
     let coinIn = pool.coins[coinTypeIn];
     let coinOut = pool.coins[coinTypeOut];
-    let balanceIn = CmmmCalculations.convertFromInt(coinIn.balance);
-    let balanceOut = CmmmCalculations.convertFromInt(coinOut.balance);
-    let weightIn = CmmmCalculations.directCast(coinIn.weight);
-    let weightOut = CmmmCalculations.directCast(coinOut.weight);
-    let swapFeeIn = ignoreFees
-        ? 0
-        : CmmmCalculations.directCast(coinIn.tradeFeeIn);
-    let swapFeeOut = ignoreFees
-        ? 0
-        : CmmmCalculations.directCast(coinIn.tradeFeeOut);
+    let balanceIn = fixed_1.Fixed.convertFromInt(coinIn.balance);
+    let balanceOut = fixed_1.Fixed.convertFromInt(coinOut.balance);
+    let weightIn = fixed_1.Fixed.directCast(coinIn.weight);
+    let weightOut = fixed_1.Fixed.directCast(coinOut.weight);
+    let swapFeeIn = ignoreFees ? 0 : fixed_1.Fixed.directCast(coinIn.tradeFeeIn);
+    let swapFeeOut = ignoreFees ? 0 : fixed_1.Fixed.directCast(coinIn.tradeFeeOut);
     let sbi = weightOut * balanceIn;
     // this is the only place where fee values are used
     let sbo = (1 - swapFeeIn) * (1 - swapFeeOut) * weightIn * balanceOut;
@@ -213,7 +148,7 @@ CmmmCalculations.calcSpotPriceWithFees = (pool, coinTypeIn, coinTypeOut, ignoreF
 // The spot price formula contains a factor of C0^2 / P(B0) + (1-A)P(B0), this returns that
 CmmmCalculations.calcSpotPriceBody = (pool) => {
     // The spot price formula comes from the partial derivatives of Cf, specifically -(dCf / dxOut) / (dCf / dxIn)
-    let a = CmmmCalculations.directCast(pool.flatness);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
     let ac = 1 - a;
     let prod = 0;
     let sum = 0;
@@ -222,8 +157,8 @@ CmmmCalculations.calcSpotPriceBody = (pool) => {
     // The spot price formula requires knowing the value of the invariant. We need the prod and sum parts
     // also later on so no need to compute them twice by calling calcInvariant, just evaluate here.
     for (let coin of Object.values(pool.coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        weight = CmmmCalculations.directCast(coin.weight);
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
         prod += weight * Math.log(balance);
         sum += weight * balance;
     }
@@ -237,31 +172,33 @@ CmmmCalculations.calcOutGivenIn = (pool, coinTypeIn, coinTypeOut, amountIn) => {
         throw Error("in and out must be different coins");
     let coinIn = pool.coins[coinTypeIn];
     let coinOut = pool.coins[coinTypeOut];
-    let swapFeeIn = CmmmCalculations.directCast(coinIn.tradeFeeIn);
-    let swapFeeOut = CmmmCalculations.directCast(coinOut.tradeFeeOut);
+    let swapFeeIn = fixed_1.Fixed.directCast(coinIn.tradeFeeIn);
+    let swapFeeOut = fixed_1.Fixed.directCast(coinOut.tradeFeeOut);
     if (swapFeeIn >= 1 || swapFeeOut >= 1) {
         // this swap is disabled
         return BigInt(0);
     }
-    let flatness = CmmmCalculations.directCast(pool.flatness);
-    let oldIn = CmmmCalculations.convertFromInt(coinIn.balance);
-    let oldOut = CmmmCalculations.convertFromInt(coinOut.balance);
-    let wIn = CmmmCalculations.directCast(coinIn.weight);
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    let oldIn = fixed_1.Fixed.convertFromInt(coinIn.balance);
+    let oldOut = fixed_1.Fixed.convertFromInt(coinOut.balance);
+    let wIn = fixed_1.Fixed.directCast(coinIn.weight);
     let [prod, _sum, p0, s0, h] = CmmmCalculations.calcInvariantComponents(pool, coinTypeOut);
-    let feedAmountIn = (1 - swapFeeIn) * CmmmCalculations.convertFromInt(amountIn);
+    let feedAmountIn = (1 - swapFeeIn) * fixed_1.Fixed.convertFromInt(amountIn);
     let newIn = oldIn + feedAmountIn;
     let prodRatio = Math.pow(newIn / oldIn, wIn);
     let newP0 = p0 * prodRatio;
     // the initial estimate (xi) is from if there were only the product part of the curve
     let xi = Math.pow(prod / newP0, 1 / wIn);
     let newS0 = s0 + wIn * feedAmountIn;
-    let wOut = CmmmCalculations.directCast(coinOut.weight);
+    let wOut = fixed_1.Fixed.directCast(coinOut.weight);
     let tokenAmountOut = CmmmCalculations.getTokenBalanceGivenInvariantAndAllOtherBalances(flatness, wOut, h, xi, // initial estimate -- default can be (P(X) / p0)^n
     newP0, // P(B) / xi^(1/n) (everything but the missing part)
     newS0 // S(B) - xi / n (everything but the missing part)
     );
-    let amountOut = (oldOut - tokenAmountOut) * (1 - swapFeeOut);
-    return CmmmCalculations.convertToInt(amountOut);
+    let amountOut = fixed_1.Fixed.convertToInt((oldOut - tokenAmountOut) * (1 - swapFeeOut));
+    if (!CmmmCalculations.checkValid1dSwap(pool, coinTypeIn, coinTypeOut, amountIn, amountOut))
+        throw Error("invalid 1d swap");
+    return amountOut;
 };
 // 1d optimized swap function for finding in given out. Returns the amount in.
 CmmmCalculations.calcInGivenOut = (pool, coinTypeIn, coinTypeOut, amountOut) => {
@@ -269,51 +206,293 @@ CmmmCalculations.calcInGivenOut = (pool, coinTypeIn, coinTypeOut, amountOut) =>
         throw Error("in and out must be different coins");
     let coinIn = pool.coins[coinTypeIn];
     let coinOut = pool.coins[coinTypeOut];
-    let swapFeeIn = CmmmCalculations.directCast(coinIn.tradeFeeIn);
-    let swapFeeOut = CmmmCalculations.directCast(coinOut.tradeFeeOut);
+    let swapFeeIn = fixed_1.Fixed.directCast(coinIn.tradeFeeIn);
+    let swapFeeOut = fixed_1.Fixed.directCast(coinOut.tradeFeeOut);
     if (swapFeeIn >= 1 || swapFeeOut >= 1) {
         // this swap is disabled
         if (amountOut == BigInt(0))
             return BigInt(0);
         throw Error("this swap is disabled");
     }
-    let flatness = CmmmCalculations.directCast(pool.flatness);
-    let oldIn = CmmmCalculations.convertFromInt(coinIn.balance);
-    let oldOut = CmmmCalculations.convertFromInt(coinOut.balance);
-    let wOut = CmmmCalculations.directCast(coinOut.weight);
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    let oldIn = fixed_1.Fixed.convertFromInt(coinIn.balance);
+    let oldOut = fixed_1.Fixed.convertFromInt(coinOut.balance);
+    let wOut = fixed_1.Fixed.directCast(coinOut.weight);
     let [prod, _sum, p0, s0, h] = CmmmCalculations.calcInvariantComponents(pool, coinTypeIn);
-    let feedAmountOut = CmmmCalculations.convertFromInt(amountOut) / (1 - swapFeeOut);
+    let feedAmountOut = fixed_1.Fixed.convertFromInt(amountOut) / (1 - swapFeeOut);
     let newOut = oldOut - feedAmountOut;
     let prodRatio = Math.pow(newOut / oldOut, wOut);
     let newP0 = p0 * prodRatio;
     // the initial estimate (xi) is from if there were only the product part of the curve
     let xi = Math.pow(prod / newP0, 1 / wOut);
     let newS0 = s0 - wOut * feedAmountOut;
-    let wIn = CmmmCalculations.directCast(coinIn.weight);
+    let wIn = fixed_1.Fixed.directCast(coinIn.weight);
     let tokenAmountIn = CmmmCalculations.getTokenBalanceGivenInvariantAndAllOtherBalances(flatness, wIn, h, xi, // initial estimate -- default can be (P(X) / p0)^n
     newP0, // P(B) / xi^(1/n) (everything but the missing part)
     newS0 // S(B) - xi / n (everything but the missing part)
     );
-    let amountIn = (tokenAmountIn - oldIn) / (1 - swapFeeIn);
-    return CmmmCalculations.convertToInt(amountIn);
+    let amountIn = fixed_1.Fixed.convertToInt((tokenAmountIn - oldIn) / (1 - swapFeeIn));
+    if (!CmmmCalculations.checkValid1dSwap(pool, coinTypeIn, coinTypeOut, amountIn, amountOut))
+        throw Error("invalid 1d swap");
+    return amountIn;
+};
+// For computing swap amounts. Given the current balances (and any other parameters) and an amounts in vector,
+// and a expected amounts out vector, determine the value of t > 0 such that t*expected_amounts_out
+// is a valid swap from balances corresponding to adding amounts_in to the pool. The correct value of t is the one for which
+// calc_swap_invariant(balances, ...parameters, amounts_in, t*expected_amounts_out) == calc_invariant_full(balances, ...parameters).
+CmmmCalculations.calcSwapFixedIn = (pool, amountsIn, amountsOutDirection) => {
+    let coins = pool.coins;
+    let invariant = CmmmCalculations.calcInvariant(pool);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let ac = 1 - a;
+    let t = 1; // assume that the expected amounts out are close to the true amounts out
+    // this allows faster convergence if the caller chooses expected_amounts_out well
+    let prevT = t;
+    let balance;
+    let weight;
+    let amountIn;
+    let amountOut;
+    let feeIn;
+    let feeOut;
+    let prod;
+    let prod1;
+    let sum;
+    let sum1;
+    let part1;
+    let part2;
+    let part3;
+    let part4;
+    let skip;
+    let drainT = Number.POSITIVE_INFINITY;
+    let shifter = 1;
+    // make sure no disabled coin type is expected
+    for (let [coinType, coin] of Object.entries(coins)) {
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+        feeOut = fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut));
+        if (amountOut > 0) {
+            if (feeOut == 0) {
+                throw Error("this trade is disabled");
+            }
+            else {
+                // pool is drained when b + Ain * (1 - Sin) - t * Aout / (1 - Sout) = 0, or t = (b + Ain * (1 - Sin)) * (1 - So) / Aout
+                t =
+                    ((fixed_1.Fixed.convertFromInt(coin.balance) +
+                        fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0)) *
+                            fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeIn))) /
+                        amountOut) *
+                        feeOut;
+                drainT = Math.min(drainT, t);
+            }
+        }
+    }
+    // drain_t is the maximum t can possibly be. It will be 0 if expected amounts out is way too high.
+    if (drainT == 0)
+        return BigInt(0);
+    while (shifter >= drainT)
+        shifter /= 2;
+    t = 1;
+    for (let i = 0; i < CmmmCalculations.maxNewtonAttempts; ++i) {
+        prod = 0;
+        prod1 = 0;
+        sum = 0;
+        sum1 = 0;
+        skip = false;
+        for (let [coinType, coin] of Object.entries(coins)) {
+            balance = fixed_1.Fixed.convertFromInt(coin.balance);
+            weight = fixed_1.Fixed.directCast(coin.weight);
+            amountIn = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+            amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+            feeIn = fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeIn));
+            feeOut = fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut));
+            // pseudoin
+            part1 = feeIn * amountIn;
+            // pseudoout
+            part2 = (t * amountOut) / feeOut;
+            // pseudobalance
+            if (part2 >= balance + part1 + 1) {
+                skip = true;
+                break;
+            }
+            part3 = balance + part1 - part2;
+            // for derivatives: weight * expected_amounts_out / fee_out
+            part4 = (weight * amountOut) / feeOut;
+            prod += weight * Math.log(part3);
+            prod1 += part4 / part3;
+            sum += weight * part3;
+            sum1 += part4;
+        }
+        prod = Math.exp(prod);
+        part1 = a * sum;
+        part2 = ac * prod;
+        part3 = part1 + part2;
+        part4 = a * invariant * prod1;
+        t =
+            (a * (sum + 2 * t * sum1) +
+                part3 +
+                2 * prod1 * t * part3 -
+                (t * part4 + invariant * (a + invariant / prod))) /
+                (2 * (prod1 * part3 + a * sum1) - part4);
+        if (utils_1.Helpers.closeEnough(t, prevT, CmmmCalculations.convergenceBound)) {
+            if (!CmmmCalculations.checkValidSwap(pool, amountsIn, 1, amountsOutDirection, t))
+                throw Error("invalid swap");
+            return fixed_1.Fixed.directUncast(t);
+        }
+        prevT = t;
+    }
+    throw Error("Newton diverged");
+};
+// Swaps but fixed amounts out. Given the pool's current state and a guaranteed out vector, and a expected in vector,
+// scale expected_amounts_in by t > 0 so that this swap is valid and return the correct value for t
+CmmmCalculations.calcSwapFixedOut = (pool, amountsInDirection, amountsOut) => {
+    let coins = pool.coins;
+    let invariant = CmmmCalculations.calcInvariant(pool);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let ac = 1 - a;
+    let t = 1; // assume that the expected amounts out are close to the true amounts out
+    // this allows faster convergence if the caller chooses expected_amounts_out well
+    let prevT = 0;
+    let balance;
+    let weight;
+    let amountIn;
+    let amountOut;
+    let feeIn;
+    let feeOut;
+    let prod;
+    let prod1;
+    let sum;
+    let sum1;
+    let part1;
+    let part2;
+    let part3;
+    let part4;
+    // make sure no disabled coin type is expected
+    for (let [coinType, coin] of Object.entries(coins)) {
+        if (coin.tradeFeeOut >= fixed_1.Fixed.fixedOneB &&
+            (amountsOut[coinType] || BigInt(0)) > BigInt(0))
+            throw Error("this trade is disabled");
+    }
+    for (let i = 0; i < CmmmCalculations.maxNewtonAttempts; ++i) {
+        prod = 0;
+        prod1 = 0;
+        sum = 0;
+        sum1 = 0;
+        for (let [coinType, coin] of Object.entries(coins)) {
+            balance = fixed_1.Fixed.convertFromInt(coin.balance);
+            weight = fixed_1.Fixed.directCast(coin.weight);
+            amountIn = fixed_1.Fixed.convertFromInt(amountsInDirection[coinType] || BigInt(0));
+            amountOut = fixed_1.Fixed.convertFromInt(amountsOut[coinType] || BigInt(0));
+            feeIn = 1 - fixed_1.Fixed.directCast(coin.tradeFeeIn);
+            feeOut = 1 - fixed_1.Fixed.directCast(coin.tradeFeeOut);
+            // pseudoin expected
+            part1 = feeIn * amountIn;
+            // pseudoout
+            part2 = amountOut == 0 ? 0 : amountOut / feeOut;
+            // pseudobalance
+            part3 = balance + t * part1 - part2;
+            // for derivatives: weight * fee_in * expected_amounts_in
+            part4 = weight * part1;
+            prod += weight * Math.log(part3);
+            prod1 += part4 / part3;
+            sum += weight * part3;
+            sum1 += part4;
+        }
+        prod = Math.exp(prod);
+        part1 = 2 * a * sum;
+        part2 = ac * prod;
+        part3 = part1 + part2;
+        part4 =
+            (part3 + part2) * prod1 + 2 * a * sum1 - a * invariant * prod1;
+        t =
+            (t * part4 + invariant * (a + invariant / prod) - part3) /
+                part4;
+        if (utils_1.Helpers.closeEnough(t, prevT, CmmmCalculations.convergenceBound)) {
+            if (!CmmmCalculations.checkValidSwap(pool, amountsInDirection, 1, amountsOut, t))
+                throw Error("invalid swap");
+            return fixed_1.Fixed.directUncast(t);
+        }
+        prevT = t;
+    }
+    throw Error("Newton diverged");
 };
 // Return the expected lp ratio for this deposit
 CmmmCalculations.calcDepositFixedAmounts = (pool, amountsIn) => {
-    if (Object.keys(amountsIn).length === 0)
-        return utils_1.Casting.fixedOneBigInt;
     let invariant = CmmmCalculations.calcInvariant(pool);
     let coins = pool.coins;
-    let a = CmmmCalculations.directCast(pool.flatness);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let ac = 1 - a;
+    let balance;
+    let weight;
+    let amount;
+    let prod = 0;
+    let sum = 0;
+    let r = CmmmCalculations.calcDepositFixedAmountsInitialEstimate(pool, amountsIn);
+    let prevR = r;
+    let fees = {};
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amount = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+        fees[coinType] =
+            r * (balance + amount) >= balance
+                ? 1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)
+                : 1 / (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut));
+    }
+    let i = 0;
+    let prod1;
+    let sum1;
+    let fee;
+    let part1;
+    let part2;
+    let part3;
+    let part4;
+    while (i < CmmmCalculations.maxNewtonAttempts) {
+        prod = 0;
+        prod1 = 0;
+        sum = 0;
+        sum1 = 0;
+        for (let [coinType, coin] of Object.entries(coins)) {
+            balance = fixed_1.Fixed.convertFromInt(coin.balance);
+            weight = fixed_1.Fixed.directCast(coin.weight);
+            amount = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+            fee = fees[coinType];
+            part1 = balance + amount;
+            part2 = fee * r * part1 + balance - fee * balance;
+            part3 = weight * fee * part1;
+            prod += weight * Math.log(part2);
+            prod1 += part3 / part2;
+            sum += weight * part2;
+            sum1 += part3;
+        }
+        prod = Math.exp(prod);
+        part3 = a * invariant * prod1;
+        part4 = 2 * prod1 * (a * sum + ac * prod) + 2 * a * sum1;
+        r =
+            (r * part4 +
+                invariant * (1 + invariant / prod) -
+                (r * part3 + 2 * a * sum + ac * (prod + invariant))) /
+                (part4 - part3);
+        if (utils_1.Helpers.closeEnough(r, prevR, CmmmCalculations.convergenceBound)) {
+            let scalar = fixed_1.Fixed.directUncast(r);
+            if (!CmmmCalculations.checkValidDeposit(pool, amountsIn, scalar))
+                throw Error("invalid deposit");
+            return scalar;
+        }
+        prevR = r;
+        i += 1;
+    }
+    throw Error("Newton diverged");
+};
+CmmmCalculations.calcDepositFixedAmountsInitialEstimate = (pool, amountsIn) => {
+    let invariant = CmmmCalculations.calcInvariant(pool);
+    let coins = pool.coins;
+    let a = fixed_1.Fixed.directCast(pool.flatness);
     let ac = 1 - a;
     let balance;
     let weight;
     let prod = 0;
     let sum = 0;
     for (let [coinType, coin] of Object.entries(coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance + coinType in amountsIn
-            ? amountsIn[coinType]
-            : BigInt(0));
-        weight = CmmmCalculations.directCast(coin.weight);
+        balance = fixed_1.Fixed.convertFromInt(coin.balance + (amountsIn[coinType] || BigInt(0)));
+        weight = fixed_1.Fixed.directCast(coin.weight);
         prod += weight * Math.log(balance);
         sum += weight * balance;
     }
@@ -326,36 +505,47 @@ CmmmCalculations.calcDepositFixedAmounts = (pool, amountsIn) => {
     let part1;
     let cf;
     let cfMin = 0;
+    let skip;
     for (let [coinType, coin] of Object.entries(coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        weight = CmmmCalculations.directCast(coin.weight);
-        amount = CmmmCalculations.convertFromInt(coinType in amountsIn ? amountsIn[coinType] : BigInt(0));
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amount = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
         r = balance / (balance + amount);
         prod = 0;
         sum = 0;
+        skip = false;
         for (let [coinType2, coin2] of Object.entries(coins)) {
-            balance = CmmmCalculations.convertFromInt(coin2.balance);
-            weight = CmmmCalculations.directCast(coin2.weight);
-            amount = CmmmCalculations.convertFromInt(coinType2 in amountsIn ? amountsIn[coinType2] : BigInt(0));
+            balance = fixed_1.Fixed.convertFromInt(coin2.balance);
+            weight = fixed_1.Fixed.directCast(coin2.weight);
+            amount = fixed_1.Fixed.convertFromInt(amountsIn[coinType2]);
             part1 = r * (balance + amount);
             if (part1 >= balance) {
                 // r * (B0 + Din) >= B0 so use fees in
                 part1 =
                     balance +
-                        (1 - CmmmCalculations.directCast(coin2.tradeFeeIn)) *
+                        (1 - fixed_1.Fixed.directCast(coin2.tradeFeeIn)) *
                             (part1 - balance);
             }
             else {
                 // r * (B0 + Din) < B0 so use fees out
                 part1 =
-                    balance -
-                        (balance - part1) /
-                            (1 -
-                                CmmmCalculations.directCast(coin2.tradeFeeOut));
+                    (balance - part1) /
+                        fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut));
+                if (part1 + 1 >= balance) {
+                    skip = true;
+                    break;
+                }
+                else {
+                    part1 = balance - part1;
+                }
             }
             prod += weight * Math.log(part1);
             sum += weight * part1;
         }
+        if (skip) {
+            // this discontinuity occurs beyond draining the pool
+            continue;
+        }
         prod = Math.exp(prod);
         cf = (2 * a * prod * sum) / (prod + invariant) + ac * prod;
         if (cf <= invariant) {
@@ -378,72 +568,117 @@ CmmmCalculations.calcDepositFixedAmounts = (pool, amountsIn) => {
             ? rMin
             : (rMin * cfMax + (rMax - rMin) * invariant - rMax * cfMin) /
                 (cfMax - cfMin);
-    let prevR = r;
-    let fees = {};
-    for (let [coinType, coin] of Object.entries(coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        amount = CmmmCalculations.convertFromInt(coinType in amountsIn ? amountsIn[coinType] : BigInt(0));
-        fees[coinType] =
-            r * (balance + amount) >= balance
-                ? 1 - CmmmCalculations.directCast(coin.tradeFeeIn)
-                : 1 / (1 - CmmmCalculations.directCast(coin.tradeFeeOut));
-    }
-    let i = 0;
+    return r;
+};
+// Return the expected amounts out for this withdrawal
+CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio) => {
+    let invariant = CmmmCalculations.calcInvariant(pool);
+    let coins = pool.coins;
+    let lpr = lpRatio;
+    let lpc = 1 - lpr;
+    let scaledInvariant = invariant * lpr;
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let ac = 1 - a;
+    let i;
+    let prevR = 0;
+    let balance;
+    let weight;
+    let amountOut;
+    let fee;
+    let prod;
     let prod1;
+    let sum;
     let sum1;
-    let fee;
+    let part1;
     let part2;
     let part3;
     let part4;
+    let skip;
+    let shrinker = 1;
+    let [r, rDrain] = CmmmCalculations.calcWithdrawFlpAmountsOutInitialEstimate(pool, amountsOutDirection, lpRatio);
+    while (shrinker >= rDrain)
+        shrinker /= 2;
+    let fees = {};
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+        fees[coinType] =
+            balance * lpc >= r * amountOut
+                ? 1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)
+                : 1 / (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut));
+    }
+    i = 0;
     while (i < CmmmCalculations.maxNewtonAttempts) {
         prod = 0;
         prod1 = 0;
         sum = 0;
         sum1 = 0;
+        skip = false;
         for (let [coinType, coin] of Object.entries(coins)) {
-            balance = CmmmCalculations.convertFromInt(coin.balance);
-            weight = CmmmCalculations.directCast(coin.weight);
-            amount = CmmmCalculations.convertFromInt(coinType in amountsIn ? amountsIn[coinType] : BigInt(0));
+            balance = fixed_1.Fixed.convertFromInt(coin.balance);
+            weight = fixed_1.Fixed.directCast(coin.weight);
+            amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
             fee = fees[coinType];
-            part1 = balance + amount;
-            part2 = fee * r * part1 + balance - fee * balance;
-            part3 = weight * fee * part1;
-            prod += weight * Math.log(part2);
-            prod1 += part3 / part2;
-            sum += weight * part2;
-            sum1 += part3;
+            part1 = balance * (lpr + lpc * fee);
+            part2 = fee * r * amountOut;
+            if (part2 + 1 >= part1) {
+                // Overshot and drained pool. Set t to be closer to t_max and try again.
+                skip = true;
+                break;
+            }
+            else {
+                part1 -= part2;
+            }
+            part2 = weight * fee * amountOut;
+            prod += weight * Math.log(part1);
+            prod1 += part2 / part1;
+            sum += weight * part1;
+            sum1 += part2;
+        }
+        if (skip) {
+            r = rDrain - shrinker / Math.pow(2, i);
+            i += 1;
+            continue;
         }
         prod = Math.exp(prod);
-        part3 = a * invariant * prod1;
-        part4 = 2 * prod1 * (a * sum + ac * prod) + 2 * a * sum1;
+        part1 = prod / scaledInvariant;
+        part2 = 2 * a * sum;
+        part3 = ac * (prod * part1 + 2 * prod + scaledInvariant) + part2;
+        part4 = part3 * prod1 + 2 * a * (part1 + 1) * sum1;
         r =
             (r * part4 +
-                invariant * (1 + invariant / prod) -
-                (r * part3 + 2 * a * sum + ac * (prod + invariant))) /
-                (part4 - part3);
-        if (utils_1.Helpers.closeEnough(r, prevR, CmmmCalculations.convergenceBound)) {
-            return utils_1.Casting.numberToFixedBigInt(r);
+                part3 +
+                part1 * part2 -
+                prod -
+                scaledInvariant * (2 + scaledInvariant / prod)) /
+                part4;
+        if (i > 15 &&
+            utils_1.Helpers.closeEnough(r, prevR, CmmmCalculations.convergenceBound)) {
+            let returner = {};
+            for (let coinType of Object.keys(coins)) {
+                returner[coinType] = fixed_1.Fixed.convertToInt(r *
+                    fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0)));
+            }
+            if (!CmmmCalculations.checkValidWithdraw(pool, returner, lpRatio))
+                throw Error("invalid withdraw");
+            return returner;
         }
         prevR = r;
         i += 1;
     }
     throw Error("Newton diverged");
 };
-// Return the expected amounts out for this withdrawal
-CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio) => {
-    if (Object.keys(amountsOutDirection).length === 0)
-        return {};
+CmmmCalculations.calcWithdrawFlpAmountsOutInitialEstimate = (pool, amountsOutDirection, lpRatio) => {
     let invariant = CmmmCalculations.calcInvariant(pool);
     let coins = pool.coins;
     let lpr = lpRatio;
     let lpc = 1 - lpr;
     let scaledInvariant = invariant * lpr;
-    let a = CmmmCalculations.directCast(pool.flatness);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
     let ac = 1 - a;
-    let i;
     let keepT;
+    let tDrain;
     let t;
-    let prevT = 0;
     let cf;
     let tMin;
     let cfMin;
@@ -454,21 +689,18 @@ CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio
     let amountOut;
     let fee;
     let prod;
-    let prod1;
     let sum;
-    let sum1;
     let part1;
     let part2;
     let part3;
-    let part4;
     // the biggest cfMax can possibly be is f(0) which is this:
     tMax = 0;
     prod = 0;
     sum = 0;
     for (let coin of Object.values(coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        weight = CmmmCalculations.directCast(coin.weight);
-        fee = CmmmCalculations.directCast(coin.tradeFeeIn);
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        fee = fixed_1.Fixed.directCast(coin.tradeFeeIn);
         part1 = balance * (1 + lpr * fee - fee);
         prod += weight * Math.log(part1);
         sum += weight * part1;
@@ -479,33 +711,31 @@ CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio
     cfMin = 0;
     tMin = Number.POSITIVE_INFINITY;
     for (let [coinType, coin] of Object.entries(coins)) {
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+        if (amountOut == 0)
+            continue;
         t =
-            (CmmmCalculations.convertFromInt(coin.balance) *
-                (1 - CmmmCalculations.directCast(coin.tradeFeeOut) * lpr)) /
-                CmmmCalculations.convertFromInt(coinType in amountsOutDirection
-                    ? amountsOutDirection[coinType]
-                    : BigInt(0));
+            (fixed_1.Fixed.convertFromInt(coin.balance) *
+                fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut) * lpRatio)) /
+                amountOut;
         if (t < tMin)
             tMin = t;
     }
+    tDrain = tMin;
     // remaining test points are the CF discontinuities: where B0 - t*D = R*B0
     for (let [coinTypeT, coinT] of Object.entries(coins)) {
-        amountOut = CmmmCalculations.convertFromInt(coinTypeT in amountsOutDirection
-            ? amountsOutDirection[coinTypeT]
-            : BigInt(0));
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinTypeT] || BigInt(0));
         if (amountOut == 0)
             continue;
-        balance = CmmmCalculations.convertFromInt(coinT.balance);
+        balance = fixed_1.Fixed.convertFromInt(coinT.balance);
         t = (balance * lpc) / amountOut;
         prod = 0;
         sum = 0;
         keepT = true;
         for (let [coinType, coin] of Object.entries(coins)) {
-            balance = CmmmCalculations.convertFromInt(coin.balance);
-            weight = CmmmCalculations.directCast(coin.weight);
-            amountOut = CmmmCalculations.convertFromInt(coinType in amountsOutDirection
-                ? amountsOutDirection[coinType]
-                : BigInt(0));
+            balance = fixed_1.Fixed.convertFromInt(coin.balance);
+            weight = fixed_1.Fixed.directCast(coin.weight);
+            amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
             part1 = t * amountOut;
             if (part1 >= balance) {
                 // this t is too large to be a bound because B0 - t*D overdraws the pool
@@ -517,12 +747,11 @@ CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio
             part3 =
                 part1 >= part2
                     ? part2 +
-                        (1 - CmmmCalculations.directCast(coin.tradeFeeIn)) *
+                        fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeIn)) *
                             (part1 - part2)
                     : part2 -
-                        (part1 - part1) /
-                            (1 -
-                                CmmmCalculations.directCast(coin.tradeFeeOut));
+                        (part2 - part1) /
+                            fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut));
             prod += weight * Math.log(part3);
             sum += weight * part3;
         }
@@ -554,62 +783,581 @@ CmmmCalculations.calcWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio
                 tMax * scaledInvariant -
                 tMax * cfMin -
                 tMin * scaledInvariant) /
-                cfMax -
-                cfMin;
-    let fees = {};
+                (cfMax - cfMin);
+    return [t, tDrain];
+};
+// Dusty direct all-coin deposit, returns the number s >= 0 so that amounts_in = s*B0 + dust.
+// When performing an all-coin deposit, call this function to get t then split amounts_in into s*B0 + dust.
+// At least one coordinate of dust will be 0. Send the s*B0 balances into the pool and mint s*total_lp.
+// The caller keeps the dust.
+CmmmCalculations.calcAllCoinDeposit = (pool, amountsIn) => {
+    let coins = pool.coins;
+    let balance;
+    let amountIn;
+    let s;
+    let sMin = Number.POSITIVE_INFINITY;
     for (let [coinType, coin] of Object.entries(coins)) {
-        balance = CmmmCalculations.convertFromInt(coin.balance);
-        amountOut = CmmmCalculations.convertFromInt(coinType in amountsOutDirection
-            ? amountsOutDirection[coinType]
-            : BigInt(0));
-        fees[coinType] =
-            balance * lpc >= t * amountOut
-                ? 1 - CmmmCalculations.directCast(coin.tradeFeeIn)
-                : 1 / (1 - CmmmCalculations.directCast(coin.tradeFeeOut));
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amountIn = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+        s = amountIn / balance;
+        if (s < sMin)
+            sMin = s;
     }
-    i = 0;
+    let returner = {};
+    for (let coinType of Object.keys(coins))
+        returner[coinType] = utils_1.Helpers.blendedOperations.mulNBB(sMin, amountsIn[coinType] || BigInt(0));
+    return returner;
+};
+// Dusty direct all-coin withdraw, returns the number s >= 0 so that amounts_out + dust = s*B0.
+// The normal all-coin withdraw (take this exact amount of lp and give however much balances out)
+// should be done directly without this function -- just burn the lp and give the user
+// lp/total_lp * balance_i in each coordinate. This function is for finding how much lp it takes to
+// ensure that at least amounts_out comes out.
+CmmmCalculations.calcAllCoinWithdraw = (pool, amountsOut) => {
+    let coins = pool.coins;
+    let balance;
+    let amountOut;
+    let s;
+    let sMax = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOut[coinType] || BigInt(0));
+        s = amountOut / balance;
+        if (s > sMax)
+            sMax = s;
+    }
+    let returner = {};
+    for (let coinType of Object.keys(coins))
+        returner[coinType] = utils_1.Helpers.blendedOperations.mulNBB(sMax, amountsOut[coinType] || BigInt(0));
+    return returner;
+};
+// This function calculates the balance of a given token (index) given all the other balances (combined in p0, s0)
+// and the invariant along with an initial estimate. It is useful for 1d optimization.
+CmmmCalculations.getTokenBalanceGivenInvariantAndAllOtherBalances = (flatness, w, h, xi, // initial estimate -- default can be (P(X) / p0)^n
+p0, // P(B) / xi^(1/n) (everything but the missing part)
+s0 // S(B) - xi / n (everything but the missing part)
+) => {
+    // Standard Newton method used here
+    // ---------------- setting constants ----------------
+    // c1 = 2*A*w*w
+    // c2 = 2*(1-A)*w*p0
+    // c3 = A*(2*w*s0+t)
+    // c4 = t*t/p0
+    // c5 = (1-A)*p0
+    // c6 = A*(2*s0+w*t)
+    // c7 = 2*A*w*(w+1)
+    // c8 = 2*(1-A)*p0
+    // c9 = 2*A*w*s0
+    // c10= A*w*t
+    let ac = 1 - flatness;
+    let aw = flatness * w;
+    let acw = ac * w;
+    let as0 = flatness * s0;
+    let ah = flatness * h;
+    let c1 = 2 * aw * w;
+    let c2 = 2 * acw * p0;
+    let c3 = 2 * w * as0 + ah;
+    let c4 = (h * h) / p0;
+    let c5 = ac * p0;
+    let c6 = 2 * as0 + w * ah;
+    let c7 = 2 * aw * (w + 1);
+    let c8 = 2 * acw * p0;
+    let c9 = 2 * aw * s0;
+    let c10 = aw * h;
+    // ---------------- iterating ----------------
+    //x = (
+    //    x * (
+    //        (
+    //            x^w * (
+    //                c1 * x + c2 * x^w + c3
+    //            ) + c4
+    //        ) - x^w * (
+    //            c5 * x^w + c6
+    //        )
+    //    )
+    //) / (
+    //    x^w * (
+    //        (
+    //            c7 * x + c8 * x^w + c9
+    //        ) - c10
+    //    )
+    //)
+    let x = xi;
+    let xw; // x^w
+    let topPos;
+    let topNeg;
+    let bottomPos;
+    //let bottomNeg;
+    let prevX = x;
+    let i = 0;
     while (i < CmmmCalculations.maxNewtonAttempts) {
-        prod = 0;
-        prod1 = 0;
-        sum = 0;
-        sum1 = 0;
-        for (let [coinType, coin] of Object.entries(coins)) {
-            balance = CmmmCalculations.convertFromInt(coin.balance);
-            weight = CmmmCalculations.directCast(coin.weight);
-            amountOut = CmmmCalculations.convertFromInt(coinType in amountsOutDirection
-                ? amountsOutDirection[coinType]
-                : BigInt(0));
-            fee = fees[coinType];
-            part1 = balance * (lpr + lpc * fee) - fee * t * amountOut;
-            part2 = weight * fee * amountOut;
-            prod += weight * Math.log(part1);
-            prod1 += part2 / part1;
-            sum += weight * part1;
-            sum1 += part2;
+        xw = Math.pow(x, w);
+        topPos = x * (xw * (c1 * x + c2 * xw + c3) + c4);
+        topNeg = x * (xw * (c5 * xw + c6));
+        bottomPos = c7 * x + c8 * xw + c9;
+        //bottomNeg = c10;
+        // If x jumps too much (bad initial estimate) then g(x) might overshoot into a negative number.
+        // This only happens if x is supposed to be small. In this case, replace x with a small number and try again.
+        // Once x is close enough to the true value g(x) won't overshoot anymore and this test will be skipped from then on.
+        if (topPos < topNeg || bottomPos < c10) {
+            x = 1 / Math.pow(2, i);
+            i = i + 1;
+            continue;
         }
-        prod = Math.exp(prod);
-        part1 = prod / scaledInvariant;
-        part2 = 2 * a * sum;
-        part3 = ac * (prod * part1 + 2 * prod + scaledInvariant) + part2;
-        part4 = part3 * prod1 + 2 * a * (part1 + 1) * sum1;
-        t =
-            (t * part4 +
-                part3 +
-                part1 * part2 -
-                prod -
-                scaledInvariant * (2 + scaledInvariant / prod)) /
-                part4;
-        if (utils_1.Helpers.closeEnough(t, prevT, CmmmCalculations.withdrawConvergenceBound)) {
-            let returner = {};
-            for (let coinType of Object.keys(coins)) {
-                returner[coinType] = utils_1.Casting.scaleNumberByBigInt(t, coinType in amountsOutDirection
-                    ? amountsOutDirection[coinType]
-                    : BigInt(0));
-            }
-            return returner;
+        x = (topPos - topNeg) / (xw * (bottomPos - c10));
+        // using relative error here (easier to pass) because js numbers are less precise
+        if (utils_1.Helpers.closeEnough(x, prevX, CmmmCalculations.convergenceBound)) {
+            return x;
         }
-        prevT = t;
-        i += 1;
+        prevX = x;
+        i = i + 1;
     }
     throw Error("Newton diverged");
 };
+// Compute the invariant before swap and pseudoinvariant (invariant considering fees)
+// after the swap and see if they are the same up to a tolerance.
+// It also checks that this balance does not drain the pool i.e. the final balance is at least 1.
+// The scalars are here to avoid unnecessary vector creation. In most calls one scalar will be 10^18 (1).
+CmmmCalculations.checkValidSwap = (pool, amountsIn, amountsInScalar, amountsOut, amountsOutScalar) => {
+    let coins = pool.coins;
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    // balance = balances[i]
+    let balance;
+    // pseudobalance = balance + feedAmountIn - feedAmountOut
+    let pseudobalance;
+    // postbalance = balance + amountIn - amountOut
+    let postbalance;
+    let weight;
+    let amountIn;
+    let amountOut;
+    let feedAmountIn;
+    let feedAmountOut;
+    let preprod = 0;
+    let presum = 0;
+    let pseudoprod = 0;
+    let pseudosum = 0;
+    let postprod = 0;
+    let postsum = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amountIn =
+            fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0)) *
+                amountsInScalar;
+        amountOut =
+            fixed_1.Fixed.convertFromInt(amountsOut[coinType] || BigInt(0)) *
+                amountsOutScalar;
+        if (amountIn > 0 && amountOut > 0)
+            return false;
+        feedAmountIn = amountIn * (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn));
+        feedAmountOut =
+            amountOut == 0
+                ? 0
+                : amountOut / (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut));
+        postbalance = balance + amountIn;
+        if (amountOut > postbalance + 1)
+            return false;
+        postbalance -= -amountOut;
+        pseudobalance = balance + feedAmountIn;
+        if (feedAmountOut > pseudobalance + 1)
+            return false;
+        pseudobalance -= -feedAmountOut;
+        preprod += weight * Math.log(balance);
+        presum += weight * balance;
+        postprod += weight * Math.log(postbalance);
+        postsum += weight * postbalance;
+        pseudoprod += weight * Math.log(pseudobalance);
+        pseudosum += weight * pseudobalance;
+    }
+    preprod = Math.exp(preprod);
+    postprod = Math.exp(postprod);
+    pseudoprod = Math.exp(pseudoprod);
+    let preinvariant = CmmmCalculations.calcInvariantQuadratic(preprod, presum, flatness);
+    let postinvariant = CmmmCalculations.calcInvariantQuadratic(postprod, postsum, flatness);
+    let pseudoinvariant = CmmmCalculations.calcInvariantQuadratic(pseudoprod, pseudosum, flatness);
+    return (postinvariant >= preinvariant &&
+        (utils_1.Helpers.veryCloseInt(preinvariant, pseudoinvariant, fixed_1.Fixed.fixedOneN) ||
+            utils_1.Helpers.closeEnough(preinvariant, pseudoinvariant, CmmmCalculations.validityTolerance)));
+};
+// Compute the invariant before swap and pseudoinvariant (invariant considering fees)
+// after the swap and see if they are the same up to a tolerance.
+// It also checks that this balance does not drain the pool i.e. the final balance is at least 1.
+CmmmCalculations.checkValid1dSwap = (pool, coinTypeIn, coinTypeOut, amountInB, amountOutB) => {
+    if (coinTypeIn == coinTypeOut)
+        return false;
+    let coins = pool.coins;
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    // balance = balances[i]
+    let balance;
+    // pseudobalance = balance + feed amount in - feed amount out
+    let pseudobalance;
+    // postbalance = balance + amount in - amount out
+    let postbalance;
+    let weight;
+    let amountIn = fixed_1.Fixed.convertFromInt(amountInB);
+    let amountOut = fixed_1.Fixed.convertFromInt(amountOutB);
+    let feedAmountIn = amountIn * (1 - fixed_1.Fixed.directCast(coins[coinTypeIn].tradeFeeIn));
+    let feedAmountOut = amountOut == 0
+        ? 0
+        : amountOut /
+            (1 - fixed_1.Fixed.directCast(coins[coinTypeOut].tradeFeeOut));
+    let preprod = 0;
+    let presum = 0;
+    let pseudoprod = 0;
+    let pseudosum = 0;
+    let postprod = 0;
+    let postsum = 0;
+    let p;
+    let s;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        p = weight * Math.log(balance);
+        s = weight * balance;
+        preprod += p;
+        presum += s;
+        if (coinType == coinTypeIn) {
+            pseudobalance = balance + feedAmountIn;
+            postbalance = balance + amountIn;
+            pseudoprod += weight * Math.log(pseudobalance);
+            pseudosum += weight * pseudobalance;
+            postprod += weight * Math.log(postbalance);
+            postsum += weight * postbalance;
+        }
+        else {
+            if (coinType == coinTypeOut) {
+                if (feedAmountOut > balance + 1 || amountOut > balance + 1)
+                    return false;
+                pseudobalance = balance - feedAmountOut;
+                postbalance = balance - amountOut;
+                pseudoprod += weight * Math.log(pseudobalance);
+                pseudosum += weight * pseudobalance;
+                postprod += weight * Math.log(postbalance);
+                postsum += weight * postbalance;
+            }
+            else {
+                pseudoprod += p;
+                pseudosum += s;
+                postprod += p;
+                postsum += s;
+            }
+        }
+    }
+    preprod = Math.exp(preprod);
+    postprod = Math.exp(postprod);
+    pseudoprod = Math.exp(pseudoprod);
+    let preinvariant = CmmmCalculations.calcInvariantQuadratic(preprod, presum, flatness);
+    let postinvariant = CmmmCalculations.calcInvariantQuadratic(postprod, postsum, flatness);
+    let pseudoinvariant = CmmmCalculations.calcInvariantQuadratic(pseudoprod, pseudosum, flatness);
+    return (postinvariant >= preinvariant &&
+        (utils_1.Helpers.veryCloseInt(preinvariant, pseudoinvariant, fixed_1.Fixed.fixedOneN) ||
+            utils_1.Helpers.closeEnough(preinvariant, pseudoinvariant, CmmmCalculations.validityTolerance)));
+};
+// A fixed amount investment is a swap followed by an all coin investment. This function checks that the
+// intermediate swap is allowed and corresponds to the claimed lp ratio.
+CmmmCalculations.checkValidDeposit = (pool, amountsIn, lpRatioRaw) => {
+    // The supposed swap is from B0 to R*(B0 + Din)
+    // This test is check_valid_swap for those data
+    let coins = pool.coins;
+    let lpRatio = fixed_1.Fixed.directCast(lpRatioRaw);
+    if (lpRatio > 1)
+        return false;
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    // balance = balances[i]
+    let balance;
+    let weight;
+    // amount = amountsIn[i]
+    let amount;
+    // postbalance = lpRatio * (balance + amount)
+    let postbalance;
+    // pseudobalance = fee(postbalance - balance) + balance
+    let pseudobalance;
+    // diff = postbalance - balance
+    let diff;
+    // pseudodiff = fee(diff)
+    let pseudodiff;
+    let preprod = 0;
+    let presum = 0;
+    let pseudoprod = 0;
+    let pseudosum = 0;
+    let postprod = 0;
+    let postsum = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amount = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+        postbalance = lpRatio * (balance + amount);
+        if (postbalance >= balance) {
+            // use fee in
+            diff = postbalance - balance;
+            pseudodiff = diff * (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn));
+            pseudobalance = balance + pseudodiff;
+        }
+        else {
+            // use fee out
+            diff = balance - postbalance;
+            pseudodiff =
+                diff == 0
+                    ? 0
+                    : diff / (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut));
+            if (pseudodiff >= balance + 1)
+                return false;
+            pseudobalance = balance - pseudodiff;
+        }
+        preprod += weight * Math.log(balance);
+        presum += weight * balance;
+        postprod += weight * Math.log(postbalance);
+        postsum += weight * postbalance;
+        pseudoprod += weight * Math.log(pseudobalance);
+        pseudosum += weight * pseudobalance;
+    }
+    preprod = Math.exp(preprod);
+    postprod = Math.exp(postprod);
+    pseudoprod = Math.exp(pseudoprod);
+    let preinvariant = CmmmCalculations.calcInvariantQuadratic(preprod, presum, flatness);
+    let postinvariant = CmmmCalculations.calcInvariantQuadratic(postprod, postsum, flatness);
+    let pseudoinvariant = CmmmCalculations.calcInvariantQuadratic(pseudoprod, pseudosum, flatness);
+    return (postinvariant >= preinvariant &&
+        (utils_1.Helpers.veryCloseInt(preinvariant, pseudoinvariant, fixed_1.Fixed.fixedOneN) ||
+            utils_1.Helpers.closeEnough(preinvariant, pseudoinvariant, CmmmCalculations.validityTolerance)));
+};
+// A fixed lp withdraw is an all coin withdraw followed by a swap.
+// This function checks that the swap is valid.
+CmmmCalculations.checkValidWithdraw = (pool, amountsOutSrc, lpRatio) => {
+    // Check that the swap from R*B0 to B0 - Dout is valid
+    let coins = pool.coins;
+    if (lpRatio > 1)
+        return false;
+    let flatness = fixed_1.Fixed.directCast(pool.flatness);
+    // balance = balances[i]
+    let balance;
+    let weight;
+    // amount is scaled amounts out at i
+    let amount;
+    // scaledBalance = lpRatio * balance
+    let scaledBalance;
+    // postbalance = balance - amount
+    let postbalance;
+    // pseudobalance is postbalance but considering fees
+    let pseudobalance;
+    let diff;
+    let pseudodiff;
+    let preprod = 0;
+    let presum = 0;
+    let pseudoprod = 0;
+    let pseudosum = 0;
+    let postprod = 0;
+    let postsum = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        scaledBalance = lpRatio * balance;
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amount = fixed_1.Fixed.convertFromInt(amountsOutSrc[coinType] || BigInt(0));
+        if (amount > scaledBalance + 1)
+            return false;
+        postbalance = balance - amount;
+        if (postbalance >= scaledBalance) {
+            // use fee in
+            diff = postbalance - scaledBalance;
+            pseudodiff =
+                diff * fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeIn));
+            pseudobalance = scaledBalance + pseudodiff;
+        }
+        else {
+            // use fee out
+            diff = scaledBalance - postbalance;
+            pseudodiff =
+                diff == 0
+                    ? 0
+                    : diff /
+                        fixed_1.Fixed.complement(fixed_1.Fixed.directCast(coin.tradeFeeOut));
+            if (pseudodiff > scaledBalance + 1)
+                return false;
+            pseudobalance = scaledBalance - pseudodiff;
+        }
+        preprod += weight * Math.log(scaledBalance);
+        presum += weight * scaledBalance;
+        postprod += weight * Math.log(postbalance);
+        postsum += weight * postbalance;
+        pseudoprod += weight * Math.log(pseudobalance);
+        pseudosum += weight * pseudobalance;
+    }
+    preprod = Math.exp(preprod);
+    postprod = Math.exp(postprod);
+    pseudoprod = Math.exp(pseudoprod);
+    let preinvariant = CmmmCalculations.calcInvariantQuadratic(preprod, presum, flatness);
+    let postinvariant = CmmmCalculations.calcInvariantQuadratic(postprod, postsum, flatness);
+    let pseudoinvariant = CmmmCalculations.calcInvariantQuadratic(pseudoprod, pseudosum, flatness);
+    return (postinvariant >= preinvariant &&
+        (utils_1.Helpers.veryCloseInt(preinvariant, pseudoinvariant, fixed_1.Fixed.fixedOneN) ||
+            utils_1.Helpers.closeEnough(preinvariant, pseudoinvariant, CmmmCalculations.validityTolerance)));
+};
+// get an estimate for outGivenIn based on the spot price
+CmmmCalculations.getEstimateOutGivenIn = (pool, coinTypeIn, coinTypeOut, amountIn) => utils_1.Helpers.blendedOperations.mulNBB(CmmmCalculations.calcSpotPriceWithFees(pool, coinTypeIn, coinTypeOut), amountIn);
+// get an estimate for inGivenOut based on the spot price
+CmmmCalculations.getEstimateInGivenOut = (pool, coinTypeIn, coinTypeOut, amountOut) => utils_1.Helpers.blendedOperations.mulNBB(1 /
+    CmmmCalculations.calcSpotPriceWithFees(pool, coinTypeIn, coinTypeOut), amountOut);
+// get an estimate for swapFixedIn using the spot prices
+// returns t > 0 such that t*amountsOutDirection agrees with amountsIn wrt spot prices
+CmmmCalculations.getEstimateSwapFixedIn = (pool, amountsIn, amountsOutDirection) => {
+    // find t such that Ain + t*Aout lies in the tangent plane to the swap surface at balances in the given directions
+    // the gradient of the invariant function with fees is (with spot body E)
+    // Win * (1 - Sin) * (E + 2*A * Bin) / Bin or
+    // Wout * (E + 2*A * Bout) / (1-Sout) * Bout
+    // depending on whether the balance is coming in or going out
+    let coins = pool.coins;
+    let spotBody = CmmmCalculations.calcSpotPriceBody(pool);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let balance;
+    let grad;
+    let amountIn;
+    let amountOut;
+    let inDotGrad = 0;
+    let outDotGrad = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amountIn = fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+        grad =
+            amountIn == 0
+                ? (fixed_1.Fixed.directCast(coin.weight) *
+                    (spotBody + 2 * a * balance)) /
+                    (balance * (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut)))
+                : (fixed_1.Fixed.directCast(coin.weight) *
+                    (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)) *
+                    (spotBody + 2 * a * balance)) /
+                    balance;
+        inDotGrad += amountIn * grad;
+        outDotGrad += amountOut * grad;
+    }
+    return inDotGrad / outDotGrad;
+};
+// get an estimate for swapFixedOut using the spot prices
+// returns t > 0 such that t*amountsInDirection agrees with amountsOut wrt spot prices
+CmmmCalculations.getEstimateSwapFixedOut = (pool, amountsInDirection, amountsOut) => {
+    // find t such that Ain + t*Aout lies in the tangent plane to the swap surface at balances in the given directions
+    // the gradient of the invariant function with fees is (with spot body E)
+    // Win * (1 - Sin) * (E + 2*A * Bin) / Bin or
+    // Wout * (E + 2*A * Bout) / (1-Sout) * Bout
+    // depending on whether the balance is coming in or going out
+    let coins = pool.coins;
+    let spotBody = CmmmCalculations.calcSpotPriceBody(pool);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    let balance;
+    let grad;
+    let amountIn;
+    let amountOut;
+    let inDotGrad = 0;
+    let outDotGrad = 0;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        amountIn = fixed_1.Fixed.convertFromInt(amountsInDirection[coinType] || BigInt(0));
+        amountOut = fixed_1.Fixed.convertFromInt(amountsOut[coinType] || BigInt(0));
+        grad =
+            amountIn == 0
+                ? (fixed_1.Fixed.directCast(coin.weight) *
+                    (spotBody + 2 * a * balance)) /
+                    (balance * (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut)))
+                : (fixed_1.Fixed.directCast(coin.weight) *
+                    (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)) *
+                    (spotBody + 2 * a * balance)) /
+                    balance;
+        inDotGrad += amountIn * grad;
+        outDotGrad += amountOut * grad;
+    }
+    return outDotGrad / inDotGrad;
+};
+// Calculate an estimate for lpRatio using the spot price (linear estiamtion)
+// This estimation will be very good for small values in amountsIn
+CmmmCalculations.getEstimateDepositFixedAmounts = (pool, amountsIn) => {
+    // Initial estimate comes from testing the discontinuities and doing a linear
+    // approximation off the two closest test points. We use it to get the correct fees.
+    let r0 = CmmmCalculations.calcDepositFixedAmountsInitialEstimate(pool, amountsIn);
+    // Now r0 is on the correct side of B0 as the final t*(B0+Din). This tells us which fees apply.
+    // All we have to do is find the value of r for which r*(B0+Din) lies on the feed tangent plane at B0.
+    // the gradient of the invariant function with fees is (with spot body E)
+    // Win * (1 - Sin) * (E + 2*A * Bin) / Bin or
+    // Wout * (E + 2*A * Bout) / (1-Sout) * Bout
+    // depending on whether the balance is coming in or going out
+    let coins = pool.coins;
+    let spotBody = CmmmCalculations.calcSpotPriceBody(pool);
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    // dot(B0, g)
+    let d1 = 0;
+    // dot(B0 + Din, g)
+    let d2 = 0;
+    let balance;
+    let weight;
+    let amount;
+    let grad;
+    let scaledAmount;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amount =
+            balance +
+                fixed_1.Fixed.convertFromInt(amountsIn[coinType] || BigInt(0));
+        scaledAmount = amount * r0;
+        grad =
+            scaledAmount < balance
+                ? // use amount out
+                    (weight * (spotBody + 2 * a * balance)) /
+                        (balance * (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut)))
+                : // use amount in
+                    (weight *
+                        (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)) *
+                        (spotBody + 2 * a * balance)) /
+                        balance;
+        d1 += balance * grad;
+        d2 += amount * grad;
+    }
+    return d1 / d2;
+};
+// Calculate an estimate for amountsOut using the spot price (linear estiamtion)
+// This estimation will be very good for lpRatios close to 1
+// Since we still need the out vector for its direction we return t s.t. t*amountsOutDirection is the estimate.
+CmmmCalculations.getEstimateWithdrawFlpAmountsOut = (pool, amountsOutDirection, lpRatio) => {
+    // Initial estimate comes from testing the discontinuities and doing a linear
+    // approximation off the two closest test points. We use it to get the correct fees.
+    let [r0, _rDrain] = CmmmCalculations.calcWithdrawFlpAmountsOutInitialEstimate(pool, amountsOutDirection, lpRatio);
+    // Now r0 is on the correct side of R*B0 as the final B0-t*Deout. This tells us which fees apply.
+    // All we have to do is find the value of t for which B0-t*Deout lies on the feed tangent plane at R*B0.
+    // the gradient of the invariant function with fees is (with spot body E)
+    // Win * (1 - Sin) * (E + 2*A * Bin) / Bin or
+    // Wout * (E + 2*A * Bout) / (1-Sout) * Bout
+    // depending on whether the balance is coming in or going out
+    let coins = pool.coins;
+    // Swap center is R*B0, not B0. Luckily the spot body formula is homogeneous.
+    let spotBody = CmmmCalculations.calcSpotPriceBody(pool) * lpRatio;
+    let a = fixed_1.Fixed.directCast(pool.flatness);
+    // dot(B0, g)
+    let d1 = 0;
+    // dot(Deout, g)
+    let d2 = 0;
+    let balance;
+    let scaledAmount;
+    let weight;
+    let amount;
+    let grad;
+    for (let [coinType, coin] of Object.entries(coins)) {
+        balance = fixed_1.Fixed.convertFromInt(coin.balance);
+        weight = fixed_1.Fixed.directCast(coin.weight);
+        amount =
+            balance +
+                fixed_1.Fixed.convertFromInt(amountsOutDirection[coinType] || BigInt(0));
+        scaledAmount = amount * r0;
+        grad =
+            scaledAmount < balance
+                ? // use amount out
+                    (weight * (spotBody + 2 * a * balance)) /
+                        (balance * (1 - fixed_1.Fixed.directCast(coin.tradeFeeOut)))
+                : // use amount in
+                    (weight *
+                        (1 - fixed_1.Fixed.directCast(coin.tradeFeeIn)) *
+                        (spotBody + 2 * a * balance)) /
+                        balance;
+        d1 += balance * grad;
+        d2 += amount * grad;
+    }
+    return ((1 - lpRatio) * d1) / d2;
+};