@sundaeswap/math 0.3.0 → 0.4.0

package/dist/cjs/PoolMath/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/PoolMath/index.ts"],"sourcesContent":["export * as ConcentratedLiquidityPool from \"./ConcentratedLiquidityPool.js\";\nexport * as ConstantProductPool from \"./ConstantProductPool.js\";\nexport * as ConstantSumPool from \"./ConstantSumPool.js\";\nexport * as StableSwapsPool from \"./StableSwapsPool.js\";\nexport * as SharedPoolMath from \"./SharedPoolMath.js\";\n"],"mappings":"","ignoreList":[]}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/PoolMath/index.ts"],"sourcesContent":["export * as ConcentratedLiquidityPool from \"./ConcentratedLiquidityPool.js\";\nexport * as ConstantProductPool from \"./ConstantProductPool.js\";\nexport * as ConstantSumPool from \"./ConstantSumPool.js\";\nexport * as StableSwapsPool from \"./StableSwapsPool.js\";\nexport * as V4StableswapPool from \"./V4StableswapPool.js\";\nexport * as SharedPoolMath from \"./SharedPoolMath.js\";\n"],"mappings":"","ignoreList":[]}

package/dist/esm/PoolMath/V4StableswapPool.js

@@ -0,0 +1,495 @@
+import { AssetAmount } from "@sundaeswap/asset";
+import { Fraction } from "@sundaeswap/fraction";
+import { SharedPoolMath } from "./index.js";
+
+/**
+ * THE V4 STABLESWAP INVARIANT MODULE — NOT THE V3 "STABLESWAPS" CONTRACT.
+ *
+ * Two different things in this SDK carry the word "stableswap". Keep them
+ * apart:
+ *
+ * - `StableSwapsPool` / `EContractVersion.Stableswaps` is the **v3** stableswap
+ *   contract. It is a whole contract version with its own datum builder and
+ *   transaction builder. It stores `D` in the pool datum and has no per-asset
+ *   rates.
+ * - `V4StableswapPool` / `EPoolCurve.V4Stableswap` (this file) is a **v4
+ *   invariant module**. It is one curve among several a v4 pool can bind, next
+ *   to constant product, constant sum and concentrated liquidity. It stores no
+ *   `D` and carries per-asset integer `rates`.
+ *
+ * The amplification `A` is the ONE thing they share: the same parameter on the
+ * same scale, carried by the same `linearAmplificationFactor` field, with each
+ * implementation applying its own internal scaling. Everything else is
+ * different — do not pass one's reserves, rates or `D` to the other.
+ *
+ * The curve, on rated and scaled reserves `x = r_a·rate_a·P` and
+ * `y = r_b·rate_b·P` with `P = calc_precision = 10^12` and `A` the linear
+ * amplification:
+ *
+ *   4A(x + y) + D = 4AD + D³ / (4xy)
+ *
+ * `D` is the largest integer that satisfies it. Neither `D` nor a swap output
+ * can be computed on-chain, because both need Newton's method. The scooper
+ * computes them and the module checks that each supplied integer is the unique
+ * one that solves the invariant. This file is the off-chain twin of
+ * `lib/modules/ss_math.ak` and `lib/modules/ss_check.ak` in the sundae-v4
+ * repository — those are the source of truth; keep this in lockstep with them.
+ */
+
+/** `ss_math.calc_precision`: the scale applied to reserves before they enter the invariant. */
+export const CALC_PRECISION = 1_000_000_000_000n;
+
+/** Newton iteration cap, matching the reference implementation. */
+const NEWTON_MAX_ITERATIONS = 255;
+
+/** Bound on the fix-up walk of the reverse swap. The closed form lands within a few units. */
+const CORRECTION_MAX_STEPS = 256;
+
+/**
+ * Holds the calculated outcome of a v4 stableswap swap. Mirrors
+ * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic
+ * swap-outcome consumers.
+ *
+ * `lpFee` is denominated in the **output** asset, not the input asset. The
+ * stableswap fee is taken off the gross output (`fee = ceil(gross · feeRate)`),
+ * unlike constant product and constant sum which take the fee off the input.
+ * The v3 `StableSwapsPool` does the same.
+ */
+
+// ─── Integer helpers ────────────────────────────────────────────────────────
+
+/** Plutus `divideInteger`: floor toward −∞. */
+const floorDiv = (a, b) => {
+  const q = a / b;
+  const r = a % b;
+  return r !== 0n && r < 0n !== b < 0n ? q - 1n : q;
+};
+
+/** ceil(a / b) with the same sign convention as {@link floorDiv}. */
+const ceilDiv = (a, b) => -floorDiv(-a, b);
+const asFeeParts = fee => {
+  const f = Fraction.asFraction(fee);
+  if (f.lt(Fraction.ZERO) || f.gte(Fraction.ONE)) throw new Error("fee must be in [0, 1)");
+  return [BigInt(f.numerator), BigInt(f.denominator)];
+};
+
+// ─── Invariant polynomials (`ss_math.ak`) ───────────────────────────────────
+
+/**
+ * `f(D)` from the on-chain `liquidity_invariant`. It is ≤ 0 when `D` is at or
+ * below the curve. All arguments are rated and scaled.
+ */
+export const invariantF = (x, y, amp, d) => {
+  const sixteenAxy = 16n * amp * x * y;
+  return sixteenAxy * d + d * d * d - (sixteenAxy * (x + y) + 4n * x * y * d);
+};
+
+/**
+ * `g(y)` from the on-chain `exchange_invariant`. It is ≥ 0 when the pool keeps
+ * enough of the taken asset. `g` is symmetric in `x` and `y`, which is what
+ * lets {@link getSwapInput} reuse the same solver in the other direction.
+ */
+export const invariantG = (x, y, amp, d) => {
+  const fourXy = 4n * x * y;
+  return fourXy * (4n * amp * (x + y) + d) - fourXy * 4n * amp * d - d * d * d;
+};
+
+// ─── D ──────────────────────────────────────────────────────────────────────
+
+/** The ±1 fix-up that turns a Newton result into the exact largest `D`. */
+const fixD = (x, y, amp, d0) => {
+  let d = d0;
+  while (invariantF(x, y, amp, d) > 0n) d -= 1n;
+  while (invariantF(x, y, amp, d + 1n) <= 0n) d += 1n;
+  return d;
+};
+
+/**
+ * The sum invariant `D` of a two-asset v4 stableswap pool: the largest integer
+ * that satisfies the curve on the rated, scaled reserves. Newton from
+ * `D = x + y`, then a ±1 fix-up.
+ *
+ * `D` carries the `rate · CALC_PRECISION` scale — it is not a token amount.
+ *
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param aReserve The pool's reserve of asset A, in token units.
+ * @param bReserve The pool's reserve of asset B, in token units.
+ * @param rateA The pool's rate for asset A (from the stableswap config).
+ * @param rateB The pool's rate for asset B.
+ */
+export const getD = (amp, aReserve, bReserve, rateA = 1n, rateB = 1n) => {
+  if (amp <= 0n) throw new Error("amplification must be positive");
+  if (aReserve < 0n || bReserve < 0n) throw new Error("reserves must be non-negative");
+  if (rateA <= 0n || rateB <= 0n) throw new Error("rates must be positive");
+  const xs = aReserve * rateA * CALC_PRECISION;
+  const ys = bReserve * rateB * CALC_PRECISION;
+  const sum = xs + ys;
+  // An empty pool has no invariant to solve; `D` is zero by definition.
+  if (sum === 0n) return 0n;
+  // Exactly one empty reserve is a different case, and it has no answer: the
+  // Newton step divides by `4·xs·ys`, which is zero here. The chain never
+  // reaches this state — Create requires both reserves positive, and the
+  // exchange invariant leaves at least one unit on the output side — but this
+  // is a client library, so it reports the bad input instead of faulting on a
+  // native division by zero.
+  if (xs === 0n || ys === 0n) {
+    throw new Error("getD: a stableswap pool cannot hold exactly one empty reserve; D is undefined there");
+  }
+  const ann = 4n * amp;
+  let d = sum;
+  for (let i = 0; i < NEWTON_MAX_ITERATIONS; i++) {
+    const dP = floorDiv(d * d * d, 4n * xs * ys);
+    const dNext = floorDiv((ann * sum + 2n * dP) * d, (ann - 1n) * d + 3n * dP);
+    const diff = dNext > d ? dNext - d : d - dNext;
+    d = dNext;
+    if (diff <= 1n) return fixD(xs, ys, amp, d);
+  }
+  throw new Error("getD: reached the Newton iteration cap");
+};
+
+// ─── The exchange solver ────────────────────────────────────────────────────
+
+/**
+ * The smallest scaled `y` with `g(xs, y) ≥ 0` at the pre-swap `d`: the least
+ * the pool may keep of the counterparty asset and still sit on the curve.
+ * Newton on `y`, then a walk to the exact integer — the walk leaves `y` with
+ * `g(y) ≥ 0` and `g(y − 1) < 0`, so it is the boundary and not merely a valid
+ * point.
+ *
+ * Read the direction carefully, because the two framings invert. A caller
+ * turning this into an output computes `raw = Y − y`, so the SMALLEST `y` is
+ * the LARGEST output the invariant admits. It is still not generous: `y` is a
+ * ceiling on the exact real-valued requirement, so `raw` is at or below the
+ * exact output. Most the curve allows, never more than it allows.
+ *
+ * Both swap directions use this: `g` is symmetric, so solving for the
+ * counterparty reserve answers "what must the other side hold" whichever side
+ * is given.
+ */
+const solveCounterparty = (amp, d, xs) => {
+  if (xs <= 0n) throw new Error("solveCounterparty: the given side must be positive");
+  const ann = 4n * amp;
+  // n = 2: c = D³ / (4·x·Ann), b = x + D / Ann. Evaluated in the same order as
+  // the Aiken source so the intermediate floors match.
+  const c = floorDiv(floorDiv(d * d, 2n * xs) * d, 2n * ann);
+  const b = xs + floorDiv(d, ann);
+  let y = d;
+  let converged = false;
+  for (let i = 0; i < NEWTON_MAX_ITERATIONS; i++) {
+    const yNext = floorDiv(y * y + c, 2n * y + b - d);
+    const diff = yNext > y ? yNext - y : y - yNext;
+    y = yNext;
+    if (diff <= 1n) {
+      converged = true;
+      break;
+    }
+  }
+  if (!converged) throw new Error("solveCounterparty: reached the Newton iteration cap");
+  while (invariantG(xs, y, amp, d) < 0n) y += 1n;
+  while (invariantG(xs, y - 1n, amp, d) >= 0n) y -= 1n;
+  return y;
+};
+
+/**
+ * The raw swap output: the scaled, pre-fee amount the curve releases when the
+ * given reserve becomes `inAfter` and the taken reserve starts at `outBefore`,
+ * at the pre-swap `d`. It is the largest such amount the exchange invariant
+ * admits — one unit more leaves the pool below the curve — and it is at or
+ * below the exact real-valued output, so it never over-quotes.
+ *
+ * The result carries the `rate · CALC_PRECISION` scale. Divide by
+ * `rateOut · CALC_PRECISION` to get the gross output in token units.
+ *
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param d The pre-swap sum invariant, from {@link getD}.
+ * @param inAfter The given asset's reserve after the input arrives, in token units.
+ * @param outBefore The taken asset's reserve before the swap, in token units.
+ * @param rateIn The pool's rate for the given asset.
+ * @param rateOut The pool's rate for the taken asset.
+ */
+export const getRawSwap = (amp, d, inAfter, outBefore, rateIn = 1n, rateOut = 1n) => {
+  if (amp <= 0n) throw new Error("amplification must be positive");
+  if (d <= 0n) throw new Error("the sum invariant must be positive");
+  if (inAfter <= 0n || outBefore <= 0n) throw new Error("reserves must be positive");
+  if (rateIn <= 0n || rateOut <= 0n) throw new Error("rates must be positive");
+  const xs = inAfter * rateIn * CALC_PRECISION;
+  return outBefore * rateOut * CALC_PRECISION - solveCounterparty(amp, d, xs);
+};
+
+// ─── Marginal price ─────────────────────────────────────────────────────────
+
+/**
+ * The marginal price of the curve at the current reserves, as input units per
+ * output unit. Differentiating the invariant at fixed `D` gives
+ *
+ *   −dy/dx = (16A·x²y² + D³·y) / (16A·x²y² + D³·x)
+ *
+ * in scaled value units, which converts to token units through the rates. At a
+ * balanced pool (`x = y`) it reduces to `rateOut / rateIn`, the par price.
+ */
+const marginalInputPerOutput = (amp, xs, ys, d, rateIn, rateOut) => {
+  const common = 16n * amp * xs * xs * ys * ys;
+  const cube = d * d * d;
+  return new Fraction(rateOut * (common + cube * xs), rateIn * (common + cube * ys));
+};
+
+/**
+ * The pool's marginal price as raw units of asset A per raw unit of asset B.
+ * Use it where a constant-product pool would use the reserve ratio: for a
+ * stableswap pool the reserve ratio is not the price, because the curve holds
+ * the price near par across a wide band of ratios.
+ *
+ * The result is in raw (undecimalized) units. Adjust for the two assets'
+ * decimals before display.
+ */
+export const getPrice = (amp, aReserve, bReserve, rateA = 1n, rateB = 1n) => {
+  if (aReserve <= 0n || bReserve <= 0n) throw new Error("reserves must be positive");
+  const d = getD(amp, aReserve, bReserve, rateA, rateB);
+  const xs = aReserve * rateA * CALC_PRECISION;
+  const ys = bReserve * rateB * CALC_PRECISION;
+  // A per B: asset B is the output side of the derivative.
+  return marginalInputPerOutput(amp, xs, ys, d, rateA, rateB);
+};
+
+// ─── Swap output ────────────────────────────────────────────────────────────
+
+/**
+ * Calculate the swap outcome for a v4 stableswap pool.
+ *
+ * The sequence the chain enforces (`ss_check.ak`, tag 3):
+ *
+ * 1. `D` is derived from the pre-swap reserves at the pool's rates.
+ * 2. `raw` is the LARGEST scaled output the exchange invariant admits at that
+ *    `D`, with the input already added to the given reserve. The solver pins
+ *    the pool's remaining taken reserve `y` to the SMALLEST integer that still
+ *    satisfies the invariant, and `raw = outBefore·rateOut·P − y`, so the two
+ *    statements are the same one: least reserve kept, most output released.
+ * 3. `gross = floor(raw / (rateOut · CALC_PRECISION))` is the output in token units.
+ * 4. `fee = ceil(gross · feeRate)` stays in the pool.
+ * 5. The trader receives `gross − fee`.
+ *
+ * Every rounding step favours the pool, never the trader: `y` is a ceiling on
+ * the exact reserve the curve requires, `gross` floors to whole tokens, and the
+ * fee ceilings. A trader is never quoted more than the chain will pay.
+ *
+ * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.
+ * @param input The amount of the given asset being swapped.
+ * @param inputReserve The pool's reserve of the given asset.
+ * @param outputReserve The pool's reserve of the taken asset.
+ * @param rateIn The pool's rate for the given asset (from the stableswap config).
+ * @param rateOut The pool's rate for the taken asset.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param fee The swap fee rate, applied to the gross output.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export const getSwapOutput = (outputMetadata, input, inputReserve, outputReserve, rateIn, rateOut, amp, fee) => {
+  if (input <= 0n || inputReserve <= 0n || outputReserve <= 0n) throw new Error("Input and reserves must be positive");
+  if (rateIn <= 0n || rateOut <= 0n) throw new Error("Rates must be positive");
+  if (amp <= 0n) throw new Error("Amplification must be positive");
+  const [feeNum, feeDen] = asFeeParts(fee);
+  const d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);
+  const raw = getRawSwap(amp, d, inputReserve + input, outputReserve, rateIn, rateOut);
+  const gross = floorDiv(raw, rateOut * CALC_PRECISION);
+  const lpFee = ceilDiv(gross * feeNum, feeDen);
+  const output = gross - lpFee;
+  if (output <= 0n) throw new Error("Swap yields no output after the fee; raise the input");
+  const nextInputReserve = inputReserve + input;
+  const nextOutputReserve = outputReserve - output;
+
+  // Price impact against the pool's marginal price before the swap, the same
+  // definition concentrated liquidity uses. Constant sum measures against its
+  // par price instead, because a constant-sum pool has no other price. A
+  // stableswap pool does: its marginal price moves with the reserve ratio, so
+  // measuring against par would report the pool's standing imbalance as this
+  // trade's impact. The fee is excluded so the number is curve slippage only.
+  const xs = inputReserve * rateIn * CALC_PRECISION;
+  const ys = outputReserve * rateOut * CALC_PRECISION;
+  const idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);
+  const actualPrice = new Fraction(input, gross);
+  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(lpFee, outputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+// ─── Swap input (the reverse) ───────────────────────────────────────────────
+
+/**
+ * Calculate the minimal input that buys a given output — the inverse of
+ * {@link getSwapOutput}.
+ *
+ * The steps:
+ *
+ * 1. Invert the fee: the smallest gross output that nets `output` after
+ *    `ceil(gross · feeRate)` is `ceil(output · feeDen / (feeDen − feeNum))`.
+ * 2. Turn that gross into the scaled reserve the pool may keep of the taken
+ *    asset.
+ * 3. Solve the exchange invariant in the other direction for the given
+ *    reserve that supports it. `g` is symmetric, so this is the same solver.
+ * 4. Convert to token units and walk down to the minimum, which absorbs the
+ *    integer rounding of step 3.
+ *
+ * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.
+ * @param output The wanted amount of the taken asset.
+ * @param inputReserve The pool's reserve of the given asset.
+ * @param outputReserve The pool's reserve of the taken asset.
+ * @param rateIn The pool's rate for the given asset (from the stableswap config).
+ * @param rateOut The pool's rate for the taken asset.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param fee The swap fee rate, applied to the gross output.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export const getSwapInput = (outputMetadata, output, inputReserve, outputReserve, rateIn, rateOut, amp, fee) => {
+  if (output <= 0n || inputReserve <= 0n || outputReserve <= 0n) throw new Error("Output and reserves must be positive");
+  if (rateIn <= 0n || rateOut <= 0n) throw new Error("Rates must be positive");
+  if (amp <= 0n) throw new Error("Amplification must be positive");
+  if (output >= outputReserve) throw new Error("Output must be below the output reserve");
+  const [feeNum, feeDen] = asFeeParts(fee);
+
+  // 1. Smallest gross whose post-fee remainder reaches `output`.
+  //    gross − ceil(gross·n/d) = floor(gross·(d−n)/d), which is ≥ output
+  //    exactly when gross ≥ ceil(output·d / (d−n)).
+  const grossMin = ceilDiv(output * feeDen, feeDen - feeNum);
+  if (grossMin >= outputReserve) throw new Error("Output is not reachable: the fee pushes it past the reserve");
+  const d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);
+  const scaleIn = rateIn * CALC_PRECISION;
+  const scaleOut = rateOut * CALC_PRECISION;
+
+  // 2. The most the pool may keep of the taken asset and still pay `grossMin`.
+  const yTarget = (outputReserve - grossMin) * scaleOut;
+  if (yTarget <= 0n) throw new Error("Output is not reachable within the pool's reserves");
+
+  // 3. + 4. The scaled given reserve that supports it, then token units.
+  const xNeeded = solveCounterparty(amp, d, yTarget);
+  const xBefore = inputReserve * scaleIn;
+  let input = ceilDiv(xNeeded - xBefore, scaleIn);
+  if (input < 1n) input = 1n;
+  const grossOf = dx => floorDiv(getRawSwap(amp, d, inputReserve + dx, outputReserve, rateIn, rateOut), scaleOut);
+  let steps = 0;
+  while (grossOf(input) < grossMin) {
+    input += 1n;
+    if (++steps > CORRECTION_MAX_STEPS) throw new Error("getSwapInput: the correction walk did not converge");
+  }
+  while (input > 1n && grossOf(input - 1n) >= grossMin) {
+    input -= 1n;
+    if (++steps > CORRECTION_MAX_STEPS) throw new Error("getSwapInput: the correction walk did not converge");
+  }
+  const gross = grossOf(input);
+  const lpFee = ceilDiv(gross * feeNum, feeDen);
+  const nextInputReserve = inputReserve + input;
+  const nextOutputReserve = outputReserve - output;
+  const xs = xBefore;
+  const ys = outputReserve * scaleOut;
+  const idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);
+  const actualPrice = new Fraction(input, gross);
+  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(lpFee, outputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+// ─── Deposits ───────────────────────────────────────────────────────────────
+
+/**
+ * The deposit target a holder of `offered` can cover, and everything pinned to
+ * it. This is the target-pinned rule the v4 module enforces (`ss_check.ak`,
+ * tag 6), and it is the same shape constant sum uses, stated on `D` instead of
+ * on the value sum `V`:
+ *
+ * - the fill declares a `D` delta `t`;
+ * - every reserve moves by `ceil(r_i · t / D_before)`;
+ * - `total_lp` becomes `floor(lp_before · (D_before + t) / D_before)`.
+ *
+ * The largest `t` a holder can cover is capped by the scarcest offered asset,
+ * `t = min_i floor(offered_i · D_before / r_i)`. Anything above the pinned
+ * deltas is refunded. Every pool asset must be offered, or `t` is zero and the
+ * deposit can never fill.
+ *
+ * The rates do not enter the deltas: a proportional move is proportional in
+ * any units. They enter only through `D`.
+ */
+export const calculatePinnedDeposit = (offered, reserves, totalLp, d) => {
+  if (offered.length !== reserves.length) throw new Error("offered and reserves must be aligned");
+  if (totalLp <= 0n) throw new Error("Not enough pool liquidity");
+  if (d <= 0n) throw new Error("Pool sum invariant is zero");
+  if (offered.some(o => o < 0n)) throw new Error("Deposit amounts must be non-negative");
+  let t;
+  for (let i = 0; i < offered.length; i++) {
+    if (reserves[i] <= 0n) continue;
+    const cap = floorDiv(offered[i] * d, reserves[i]);
+    t = t === undefined || cap < t ? cap : t;
+  }
+  if (t === undefined || t <= 0n) throw new Error("A stableswap deposit must offer every pool asset in proportion (asymmetric deposits are disallowed on-chain)");
+  const deltas = reserves.map(r => ceilDiv(r * t, d));
+  const nextTotalLp = floorDiv(totalLp * (d + t), d);
+  const generatedLp = nextTotalLp - totalLp;
+  if (generatedLp <= 0n) throw new Error("Deposit mints zero LP");
+  return {
+    targetDeltaD: t,
+    deltas,
+    generatedLp,
+    nextTotalLp,
+    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp)
+  };
+};
+
+/**
+ * Calculate the deposit parameters for a two-asset v4 stableswap pool through
+ * the target-pinned rule (see {@link calculatePinnedDeposit}). Surplus above
+ * the pinned deltas comes back as `aChange` / `bChange`, the way the scoop
+ * refunds it on-chain.
+ *
+ * @param a The amount of token A to deposit.
+ * @param b The amount of token B to deposit.
+ * @param aReserve The pool's reserve of token A.
+ * @param bReserve The pool's reserve of token B.
+ * @param totalLp The pool's total LP supply before the deposit.
+ * @param rateA The pool's rate for token A (from the stableswap config).
+ * @param rateB The pool's rate for token B.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ */
+export const calculateLiquidity = (a, b, aReserve, bReserve, totalLp, rateA, rateB, amp) => {
+  if (aReserve <= 0n || bReserve <= 0n) throw new Error("Not enough pool liquidity");
+  const d = getD(amp, aReserve, bReserve, rateA, rateB);
+  const {
+    deltas,
+    generatedLp,
+    nextTotalLp,
+    shareAfterDeposit
+  } = calculatePinnedDeposit([a, b], [aReserve, bReserve], totalLp, d);
+  return {
+    nextTotalLp,
+    generatedLp,
+    shareAfterDeposit,
+    aChange: a - deltas[0],
+    bChange: b - deltas[1],
+    actualDepositedA: deltas[0],
+    actualDepositedB: deltas[1]
+  };
+};
+
+/**
+ * The per-asset amounts a pinned deposit needs when the user anchors on one
+ * asset's amount: `t` from the anchor (`floor(anchor · D / r_anchor)`), every
+ * other delta ceil-pinned to it. Drives proportional auto-fill in deposit
+ * forms.
+ */
+export const pinnedDepositFromAnchor = (anchorIndex, anchorAmount, reserves, d) => {
+  if (anchorIndex < 0 || anchorIndex >= reserves.length) throw new Error("anchor index is out of range");
+  if (reserves[anchorIndex] <= 0n) throw new Error("anchor asset has no reserve");
+  if (d <= 0n) throw new Error("Pool sum invariant is zero");
+  if (anchorAmount <= 0n) return reserves.map(() => 0n);
+  const t = floorDiv(anchorAmount * d, reserves[anchorIndex]);
+  return reserves.map((r, i) => i === anchorIndex ? anchorAmount : ceilDiv(r * t, d));
+};
+//# sourceMappingURL=V4StableswapPool.js.map

package/dist/esm/PoolMath/V4StableswapPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"V4StableswapPool.js","names":["AssetAmount","Fraction","SharedPoolMath","CALC_PRECISION","NEWTON_MAX_ITERATIONS","CORRECTION_MAX_STEPS","floorDiv","a","b","q","r","ceilDiv","asFeeParts","fee","f","asFraction","lt","ZERO","gte","ONE","Error","BigInt","numerator","denominator","invariantF","x","y","amp","d","sixteenAxy","invariantG","fourXy","fixD","d0","getD","aReserve","bReserve","rateA","rateB","xs","ys","sum","ann","i","dP","dNext","diff","solveCounterparty","c","converged","yNext","getRawSwap","inAfter","outBefore","rateIn","rateOut","marginalInputPerOutput","common","cube","getPrice","getSwapOutput","outputMetadata","input","inputReserve","outputReserve","feeNum","feeDen","raw","gross","lpFee","output","nextInputReserve","nextOutputReserve","idealPrice","actualPrice","priceImpact","subtract","divide","getSwapInput","grossMin","scaleIn","scaleOut","yTarget","xNeeded","xBefore","grossOf","dx","steps","calculatePinnedDeposit","offered","reserves","totalLp","length","some","o","t","cap","undefined","deltas","map","nextTotalLp","generatedLp","targetDeltaD","shareAfterDeposit","getShare","calculateLiquidity","aChange","bChange","actualDepositedA","actualDepositedB","pinnedDepositFromAnchor","anchorIndex","anchorAmount"],"sources":["../../../src/PoolMath/V4StableswapPool.ts"],"sourcesContent":["import { AssetAmount, IAssetAmountMetadata } from \"@sundaeswap/asset\";\nimport { Fraction, type TFractionLike } from \"@sundaeswap/fraction\";\n\nimport { SharedPoolMath } from \"./index.js\";\n\n/**\n * THE V4 STABLESWAP INVARIANT MODULE — NOT THE V3 \"STABLESWAPS\" CONTRACT.\n *\n * Two different things in this SDK carry the word \"stableswap\". Keep them\n * apart:\n *\n * - `StableSwapsPool` / `EContractVersion.Stableswaps` is the **v3** stableswap\n *   contract. It is a whole contract version with its own datum builder and\n *   transaction builder. It stores `D` in the pool datum and has no per-asset\n *   rates.\n * - `V4StableswapPool` / `EPoolCurve.V4Stableswap` (this file) is a **v4\n *   invariant module**. It is one curve among several a v4 pool can bind, next\n *   to constant product, constant sum and concentrated liquidity. It stores no\n *   `D` and carries per-asset integer `rates`.\n *\n * The amplification `A` is the ONE thing they share: the same parameter on the\n * same scale, carried by the same `linearAmplificationFactor` field, with each\n * implementation applying its own internal scaling. Everything else is\n * different — do not pass one's reserves, rates or `D` to the other.\n *\n * The curve, on rated and scaled reserves `x = r_a·rate_a·P` and\n * `y = r_b·rate_b·P` with `P = calc_precision = 10^12` and `A` the linear\n * amplification:\n *\n *   4A(x + y) + D = 4AD + D³ / (4xy)\n *\n * `D` is the largest integer that satisfies it. Neither `D` nor a swap output\n * can be computed on-chain, because both need Newton's method. The scooper\n * computes them and the module checks that each supplied integer is the unique\n * one that solves the invariant. This file is the off-chain twin of\n * `lib/modules/ss_math.ak` and `lib/modules/ss_check.ak` in the sundae-v4\n * repository — those are the source of truth; keep this in lockstep with them.\n */\n\n/** `ss_math.calc_precision`: the scale applied to reserves before they enter the invariant. */\nexport const CALC_PRECISION = 1_000_000_000_000n;\n\n/** Newton iteration cap, matching the reference implementation. */\nconst NEWTON_MAX_ITERATIONS = 255;\n\n/** Bound on the fix-up walk of the reverse swap. The closed form lands within a few units. */\nconst CORRECTION_MAX_STEPS = 256;\n\n/**\n * Holds the calculated outcome of a v4 stableswap swap. Mirrors\n * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic\n * swap-outcome consumers.\n *\n * `lpFee` is denominated in the **output** asset, not the input asset. The\n * stableswap fee is taken off the gross output (`fee = ceil(gross · feeRate)`),\n * unlike constant product and constant sum which take the fee off the input.\n * The v3 `StableSwapsPool` does the same.\n */\nexport type TSwapOutcome = {\n  input: bigint;\n  output: bigint;\n  lpFee: AssetAmount<IAssetAmountMetadata>;\n  nextInputReserve: bigint;\n  nextOutputReserve: bigint;\n  priceImpact: Fraction;\n};\n\n// ─── Integer helpers ────────────────────────────────────────────────────────\n\n/** Plutus `divideInteger`: floor toward −∞. */\nconst floorDiv = (a: bigint, b: bigint): bigint => {\n  const q = a / b;\n  const r = a % b;\n  return r !== 0n && r < 0n !== b < 0n ? q - 1n : q;\n};\n\n/** ceil(a / b) with the same sign convention as {@link floorDiv}. */\nconst ceilDiv = (a: bigint, b: bigint): bigint => -floorDiv(-a, b);\n\nconst asFeeParts = (fee: TFractionLike): [bigint, bigint] => {\n  const f = Fraction.asFraction(fee);\n  if (f.lt(Fraction.ZERO) || f.gte(Fraction.ONE))\n    throw new Error(\"fee must be in [0, 1)\");\n  return [BigInt(f.numerator), BigInt(f.denominator)];\n};\n\n// ─── Invariant polynomials (`ss_math.ak`) ───────────────────────────────────\n\n/**\n * `f(D)` from the on-chain `liquidity_invariant`. It is ≤ 0 when `D` is at or\n * below the curve. All arguments are rated and scaled.\n */\nexport const invariantF = (\n  x: bigint,\n  y: bigint,\n  amp: bigint,\n  d: bigint,\n): bigint => {\n  const sixteenAxy = 16n * amp * x * y;\n  return sixteenAxy * d + d * d * d - (sixteenAxy * (x + y) + 4n * x * y * d);\n};\n\n/**\n * `g(y)` from the on-chain `exchange_invariant`. It is ≥ 0 when the pool keeps\n * enough of the taken asset. `g` is symmetric in `x` and `y`, which is what\n * lets {@link getSwapInput} reuse the same solver in the other direction.\n */\nexport const invariantG = (\n  x: bigint,\n  y: bigint,\n  amp: bigint,\n  d: bigint,\n): bigint => {\n  const fourXy = 4n * x * y;\n  return fourXy * (4n * amp * (x + y) + d) - fourXy * 4n * amp * d - d * d * d;\n};\n\n// ─── D ──────────────────────────────────────────────────────────────────────\n\n/** The ±1 fix-up that turns a Newton result into the exact largest `D`. */\nconst fixD = (x: bigint, y: bigint, amp: bigint, d0: bigint): bigint => {\n  let d = d0;\n  while (invariantF(x, y, amp, d) > 0n) d -= 1n;\n  while (invariantF(x, y, amp, d + 1n) <= 0n) d += 1n;\n  return d;\n};\n\n/**\n * The sum invariant `D` of a two-asset v4 stableswap pool: the largest integer\n * that satisfies the curve on the rated, scaled reserves. Newton from\n * `D = x + y`, then a ±1 fix-up.\n *\n * `D` carries the `rate · CALC_PRECISION` scale — it is not a token amount.\n *\n * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.\n * @param aReserve The pool's reserve of asset A, in token units.\n * @param bReserve The pool's reserve of asset B, in token units.\n * @param rateA The pool's rate for asset A (from the stableswap config).\n * @param rateB The pool's rate for asset B.\n */\nexport const getD = (\n  amp: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  rateA = 1n,\n  rateB = 1n,\n): bigint => {\n  if (amp <= 0n) throw new Error(\"amplification must be positive\");\n  if (aReserve < 0n || bReserve < 0n)\n    throw new Error(\"reserves must be non-negative\");\n  if (rateA <= 0n || rateB <= 0n) throw new Error(\"rates must be positive\");\n\n  const xs = aReserve * rateA * CALC_PRECISION;\n  const ys = bReserve * rateB * CALC_PRECISION;\n  const sum = xs + ys;\n  // An empty pool has no invariant to solve; `D` is zero by definition.\n  if (sum === 0n) return 0n;\n  // Exactly one empty reserve is a different case, and it has no answer: the\n  // Newton step divides by `4·xs·ys`, which is zero here. The chain never\n  // reaches this state — Create requires both reserves positive, and the\n  // exchange invariant leaves at least one unit on the output side — but this\n  // is a client library, so it reports the bad input instead of faulting on a\n  // native division by zero.\n  if (xs === 0n || ys === 0n) {\n    throw new Error(\n      \"getD: a stableswap pool cannot hold exactly one empty reserve; D is undefined there\",\n    );\n  }\n\n  const ann = 4n * amp;\n  let d = sum;\n  for (let i = 0; i < NEWTON_MAX_ITERATIONS; i++) {\n    const dP = floorDiv(d * d * d, 4n * xs * ys);\n    const dNext = floorDiv((ann * sum + 2n * dP) * d, (ann - 1n) * d + 3n * dP);\n    const diff = dNext > d ? dNext - d : d - dNext;\n    d = dNext;\n    if (diff <= 1n) return fixD(xs, ys, amp, d);\n  }\n  throw new Error(\"getD: reached the Newton iteration cap\");\n};\n\n// ─── The exchange solver ────────────────────────────────────────────────────\n\n/**\n * The smallest scaled `y` with `g(xs, y) ≥ 0` at the pre-swap `d`: the least\n * the pool may keep of the counterparty asset and still sit on the curve.\n * Newton on `y`, then a walk to the exact integer — the walk leaves `y` with\n * `g(y) ≥ 0` and `g(y − 1) < 0`, so it is the boundary and not merely a valid\n * point.\n *\n * Read the direction carefully, because the two framings invert. A caller\n * turning this into an output computes `raw = Y − y`, so the SMALLEST `y` is\n * the LARGEST output the invariant admits. It is still not generous: `y` is a\n * ceiling on the exact real-valued requirement, so `raw` is at or below the\n * exact output. Most the curve allows, never more than it allows.\n *\n * Both swap directions use this: `g` is symmetric, so solving for the\n * counterparty reserve answers \"what must the other side hold\" whichever side\n * is given.\n */\nconst solveCounterparty = (amp: bigint, d: bigint, xs: bigint): bigint => {\n  if (xs <= 0n)\n    throw new Error(\"solveCounterparty: the given side must be positive\");\n  const ann = 4n * amp;\n  // n = 2: c = D³ / (4·x·Ann), b = x + D / Ann. Evaluated in the same order as\n  // the Aiken source so the intermediate floors match.\n  const c = floorDiv(floorDiv(d * d, 2n * xs) * d, 2n * ann);\n  const b = xs + floorDiv(d, ann);\n  let y = d;\n  let converged = false;\n  for (let i = 0; i < NEWTON_MAX_ITERATIONS; i++) {\n    const yNext = floorDiv(y * y + c, 2n * y + b - d);\n    const diff = yNext > y ? yNext - y : y - yNext;\n    y = yNext;\n    if (diff <= 1n) {\n      converged = true;\n      break;\n    }\n  }\n  if (!converged)\n    throw new Error(\"solveCounterparty: reached the Newton iteration cap\");\n  while (invariantG(xs, y, amp, d) < 0n) y += 1n;\n  while (invariantG(xs, y - 1n, amp, d) >= 0n) y -= 1n;\n  return y;\n};\n\n/**\n * The raw swap output: the scaled, pre-fee amount the curve releases when the\n * given reserve becomes `inAfter` and the taken reserve starts at `outBefore`,\n * at the pre-swap `d`. It is the largest such amount the exchange invariant\n * admits — one unit more leaves the pool below the curve — and it is at or\n * below the exact real-valued output, so it never over-quotes.\n *\n * The result carries the `rate · CALC_PRECISION` scale. Divide by\n * `rateOut · CALC_PRECISION` to get the gross output in token units.\n *\n * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.\n * @param d The pre-swap sum invariant, from {@link getD}.\n * @param inAfter The given asset's reserve after the input arrives, in token units.\n * @param outBefore The taken asset's reserve before the swap, in token units.\n * @param rateIn The pool's rate for the given asset.\n * @param rateOut The pool's rate for the taken asset.\n */\nexport const getRawSwap = (\n  amp: bigint,\n  d: bigint,\n  inAfter: bigint,\n  outBefore: bigint,\n  rateIn = 1n,\n  rateOut = 1n,\n): bigint => {\n  if (amp <= 0n) throw new Error(\"amplification must be positive\");\n  if (d <= 0n) throw new Error(\"the sum invariant must be positive\");\n  if (inAfter <= 0n || outBefore <= 0n)\n    throw new Error(\"reserves must be positive\");\n  if (rateIn <= 0n || rateOut <= 0n) throw new Error(\"rates must be positive\");\n  const xs = inAfter * rateIn * CALC_PRECISION;\n  return outBefore * rateOut * CALC_PRECISION - solveCounterparty(amp, d, xs);\n};\n\n// ─── Marginal price ─────────────────────────────────────────────────────────\n\n/**\n * The marginal price of the curve at the current reserves, as input units per\n * output unit. Differentiating the invariant at fixed `D` gives\n *\n *   −dy/dx = (16A·x²y² + D³·y) / (16A·x²y² + D³·x)\n *\n * in scaled value units, which converts to token units through the rates. At a\n * balanced pool (`x = y`) it reduces to `rateOut / rateIn`, the par price.\n */\nconst marginalInputPerOutput = (\n  amp: bigint,\n  xs: bigint,\n  ys: bigint,\n  d: bigint,\n  rateIn: bigint,\n  rateOut: bigint,\n): Fraction => {\n  const common = 16n * amp * xs * xs * ys * ys;\n  const cube = d * d * d;\n  return new Fraction(\n    rateOut * (common + cube * xs),\n    rateIn * (common + cube * ys),\n  );\n};\n\n/**\n * The pool's marginal price as raw units of asset A per raw unit of asset B.\n * Use it where a constant-product pool would use the reserve ratio: for a\n * stableswap pool the reserve ratio is not the price, because the curve holds\n * the price near par across a wide band of ratios.\n *\n * The result is in raw (undecimalized) units. Adjust for the two assets'\n * decimals before display.\n */\nexport const getPrice = (\n  amp: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  rateA = 1n,\n  rateB = 1n,\n): Fraction => {\n  if (aReserve <= 0n || bReserve <= 0n)\n    throw new Error(\"reserves must be positive\");\n  const d = getD(amp, aReserve, bReserve, rateA, rateB);\n  const xs = aReserve * rateA * CALC_PRECISION;\n  const ys = bReserve * rateB * CALC_PRECISION;\n  // A per B: asset B is the output side of the derivative.\n  return marginalInputPerOutput(amp, xs, ys, d, rateA, rateB);\n};\n\n// ─── Swap output ────────────────────────────────────────────────────────────\n\n/**\n * Calculate the swap outcome for a v4 stableswap pool.\n *\n * The sequence the chain enforces (`ss_check.ak`, tag 3):\n *\n * 1. `D` is derived from the pre-swap reserves at the pool's rates.\n * 2. `raw` is the LARGEST scaled output the exchange invariant admits at that\n *    `D`, with the input already added to the given reserve. The solver pins\n *    the pool's remaining taken reserve `y` to the SMALLEST integer that still\n *    satisfies the invariant, and `raw = outBefore·rateOut·P − y`, so the two\n *    statements are the same one: least reserve kept, most output released.\n * 3. `gross = floor(raw / (rateOut · CALC_PRECISION))` is the output in token units.\n * 4. `fee = ceil(gross · feeRate)` stays in the pool.\n * 5. The trader receives `gross − fee`.\n *\n * Every rounding step favours the pool, never the trader: `y` is a ceiling on\n * the exact reserve the curve requires, `gross` floors to whole tokens, and the\n * fee ceilings. A trader is never quoted more than the chain will pay.\n *\n * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.\n * @param input The amount of the given asset being swapped.\n * @param inputReserve The pool's reserve of the given asset.\n * @param outputReserve The pool's reserve of the taken asset.\n * @param rateIn The pool's rate for the given asset (from the stableswap config).\n * @param rateOut The pool's rate for the taken asset.\n * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.\n * @param fee The swap fee rate, applied to the gross output.\n * @returns The swap details in the shared {@link TSwapOutcome} shape.\n */\nexport const getSwapOutput = (\n  outputMetadata: IAssetAmountMetadata,\n  input: bigint,\n  inputReserve: bigint,\n  outputReserve: bigint,\n  rateIn: bigint,\n  rateOut: bigint,\n  amp: bigint,\n  fee: TFractionLike,\n): TSwapOutcome => {\n  if (input <= 0n || inputReserve <= 0n || outputReserve <= 0n)\n    throw new Error(\"Input and reserves must be positive\");\n  if (rateIn <= 0n || rateOut <= 0n) throw new Error(\"Rates must be positive\");\n  if (amp <= 0n) throw new Error(\"Amplification must be positive\");\n  const [feeNum, feeDen] = asFeeParts(fee);\n\n  const d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);\n  const raw = getRawSwap(\n    amp,\n    d,\n    inputReserve + input,\n    outputReserve,\n    rateIn,\n    rateOut,\n  );\n  const gross = floorDiv(raw, rateOut * CALC_PRECISION);\n  const lpFee = ceilDiv(gross * feeNum, feeDen);\n  const output = gross - lpFee;\n  if (output <= 0n)\n    throw new Error(\"Swap yields no output after the fee; raise the input\");\n\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  // Price impact against the pool's marginal price before the swap, the same\n  // definition concentrated liquidity uses. Constant sum measures against its\n  // par price instead, because a constant-sum pool has no other price. A\n  // stableswap pool does: its marginal price moves with the reserve ratio, so\n  // measuring against par would report the pool's standing imbalance as this\n  // trade's impact. The fee is excluded so the number is curve slippage only.\n  const xs = inputReserve * rateIn * CALC_PRECISION;\n  const ys = outputReserve * rateOut * CALC_PRECISION;\n  const idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);\n  const actualPrice = new Fraction(input, gross);\n  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(lpFee, outputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n// ─── Swap input (the reverse) ───────────────────────────────────────────────\n\n/**\n * Calculate the minimal input that buys a given output — the inverse of\n * {@link getSwapOutput}.\n *\n * The steps:\n *\n * 1. Invert the fee: the smallest gross output that nets `output` after\n *    `ceil(gross · feeRate)` is `ceil(output · feeDen / (feeDen − feeNum))`.\n * 2. Turn that gross into the scaled reserve the pool may keep of the taken\n *    asset.\n * 3. Solve the exchange invariant in the other direction for the given\n *    reserve that supports it. `g` is symmetric, so this is the same solver.\n * 4. Convert to token units and walk down to the minimum, which absorbs the\n *    integer rounding of step 3.\n *\n * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.\n * @param output The wanted amount of the taken asset.\n * @param inputReserve The pool's reserve of the given asset.\n * @param outputReserve The pool's reserve of the taken asset.\n * @param rateIn The pool's rate for the given asset (from the stableswap config).\n * @param rateOut The pool's rate for the taken asset.\n * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.\n * @param fee The swap fee rate, applied to the gross output.\n * @returns The swap details in the shared {@link TSwapOutcome} shape.\n */\nexport const getSwapInput = (\n  outputMetadata: IAssetAmountMetadata,\n  output: bigint,\n  inputReserve: bigint,\n  outputReserve: bigint,\n  rateIn: bigint,\n  rateOut: bigint,\n  amp: bigint,\n  fee: TFractionLike,\n): TSwapOutcome => {\n  if (output <= 0n || inputReserve <= 0n || outputReserve <= 0n)\n    throw new Error(\"Output and reserves must be positive\");\n  if (rateIn <= 0n || rateOut <= 0n) throw new Error(\"Rates must be positive\");\n  if (amp <= 0n) throw new Error(\"Amplification must be positive\");\n  if (output >= outputReserve)\n    throw new Error(\"Output must be below the output reserve\");\n  const [feeNum, feeDen] = asFeeParts(fee);\n\n  // 1. Smallest gross whose post-fee remainder reaches `output`.\n  //    gross − ceil(gross·n/d) = floor(gross·(d−n)/d), which is ≥ output\n  //    exactly when gross ≥ ceil(output·d / (d−n)).\n  const grossMin = ceilDiv(output * feeDen, feeDen - feeNum);\n  if (grossMin >= outputReserve)\n    throw new Error(\n      \"Output is not reachable: the fee pushes it past the reserve\",\n    );\n\n  const d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);\n  const scaleIn = rateIn * CALC_PRECISION;\n  const scaleOut = rateOut * CALC_PRECISION;\n\n  // 2. The most the pool may keep of the taken asset and still pay `grossMin`.\n  const yTarget = (outputReserve - grossMin) * scaleOut;\n  if (yTarget <= 0n)\n    throw new Error(\"Output is not reachable within the pool's reserves\");\n\n  // 3. + 4. The scaled given reserve that supports it, then token units.\n  const xNeeded = solveCounterparty(amp, d, yTarget);\n  const xBefore = inputReserve * scaleIn;\n  let input = ceilDiv(xNeeded - xBefore, scaleIn);\n  if (input < 1n) input = 1n;\n\n  const grossOf = (dx: bigint): bigint =>\n    floorDiv(\n      getRawSwap(amp, d, inputReserve + dx, outputReserve, rateIn, rateOut),\n      scaleOut,\n    );\n\n  let steps = 0;\n  while (grossOf(input) < grossMin) {\n    input += 1n;\n    if (++steps > CORRECTION_MAX_STEPS)\n      throw new Error(\"getSwapInput: the correction walk did not converge\");\n  }\n  while (input > 1n && grossOf(input - 1n) >= grossMin) {\n    input -= 1n;\n    if (++steps > CORRECTION_MAX_STEPS)\n      throw new Error(\"getSwapInput: the correction walk did not converge\");\n  }\n\n  const gross = grossOf(input);\n  const lpFee = ceilDiv(gross * feeNum, feeDen);\n\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  const xs = xBefore;\n  const ys = outputReserve * scaleOut;\n  const idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);\n  const actualPrice = new Fraction(input, gross);\n  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(lpFee, outputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n// ─── Deposits ───────────────────────────────────────────────────────────────\n\n/**\n * The deposit target a holder of `offered` can cover, and everything pinned to\n * it. This is the target-pinned rule the v4 module enforces (`ss_check.ak`,\n * tag 6), and it is the same shape constant sum uses, stated on `D` instead of\n * on the value sum `V`:\n *\n * - the fill declares a `D` delta `t`;\n * - every reserve moves by `ceil(r_i · t / D_before)`;\n * - `total_lp` becomes `floor(lp_before · (D_before + t) / D_before)`.\n *\n * The largest `t` a holder can cover is capped by the scarcest offered asset,\n * `t = min_i floor(offered_i · D_before / r_i)`. Anything above the pinned\n * deltas is refunded. Every pool asset must be offered, or `t` is zero and the\n * deposit can never fill.\n *\n * The rates do not enter the deltas: a proportional move is proportional in\n * any units. They enter only through `D`.\n */\nexport const calculatePinnedDeposit = (\n  offered: bigint[],\n  reserves: bigint[],\n  totalLp: bigint,\n  d: bigint,\n): {\n  targetDeltaD: bigint;\n  deltas: bigint[];\n  generatedLp: bigint;\n  nextTotalLp: bigint;\n  shareAfterDeposit: Fraction;\n} => {\n  if (offered.length !== reserves.length)\n    throw new Error(\"offered and reserves must be aligned\");\n  if (totalLp <= 0n) throw new Error(\"Not enough pool liquidity\");\n  if (d <= 0n) throw new Error(\"Pool sum invariant is zero\");\n  if (offered.some((o) => o < 0n))\n    throw new Error(\"Deposit amounts must be non-negative\");\n\n  let t: bigint | undefined;\n  for (let i = 0; i < offered.length; i++) {\n    if (reserves[i] <= 0n) continue;\n    const cap = floorDiv(offered[i] * d, reserves[i]);\n    t = t === undefined || cap < t ? cap : t;\n  }\n  if (t === undefined || t <= 0n)\n    throw new Error(\n      \"A stableswap deposit must offer every pool asset in proportion (asymmetric deposits are disallowed on-chain)\",\n    );\n\n  const deltas = reserves.map((r) => ceilDiv(r * t, d));\n  const nextTotalLp = floorDiv(totalLp * (d + t), d);\n  const generatedLp = nextTotalLp - totalLp;\n  if (generatedLp <= 0n) throw new Error(\"Deposit mints zero LP\");\n\n  return {\n    targetDeltaD: t,\n    deltas,\n    generatedLp,\n    nextTotalLp,\n    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp),\n  };\n};\n\n/**\n * Calculate the deposit parameters for a two-asset v4 stableswap pool through\n * the target-pinned rule (see {@link calculatePinnedDeposit}). Surplus above\n * the pinned deltas comes back as `aChange` / `bChange`, the way the scoop\n * refunds it on-chain.\n *\n * @param a The amount of token A to deposit.\n * @param b The amount of token B to deposit.\n * @param aReserve The pool's reserve of token A.\n * @param bReserve The pool's reserve of token B.\n * @param totalLp The pool's total LP supply before the deposit.\n * @param rateA The pool's rate for token A (from the stableswap config).\n * @param rateB The pool's rate for token B.\n * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.\n */\nexport const calculateLiquidity = (\n  a: bigint,\n  b: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n  rateA: bigint,\n  rateB: bigint,\n  amp: bigint,\n) => {\n  if (aReserve <= 0n || bReserve <= 0n)\n    throw new Error(\"Not enough pool liquidity\");\n  const d = getD(amp, aReserve, bReserve, rateA, rateB);\n  const { deltas, generatedLp, nextTotalLp, shareAfterDeposit } =\n    calculatePinnedDeposit([a, b], [aReserve, bReserve], totalLp, d);\n\n  return {\n    nextTotalLp,\n    generatedLp,\n    shareAfterDeposit,\n    aChange: a - deltas[0],\n    bChange: b - deltas[1],\n    actualDepositedA: deltas[0],\n    actualDepositedB: deltas[1],\n  };\n};\n\n/**\n * The per-asset amounts a pinned deposit needs when the user anchors on one\n * asset's amount: `t` from the anchor (`floor(anchor · D / r_anchor)`), every\n * other delta ceil-pinned to it. Drives proportional auto-fill in deposit\n * forms.\n */\nexport const pinnedDepositFromAnchor = (\n  anchorIndex: number,\n  anchorAmount: bigint,\n  reserves: bigint[],\n  d: bigint,\n): bigint[] => {\n  if (anchorIndex < 0 || anchorIndex >= reserves.length)\n    throw new Error(\"anchor index is out of range\");\n  if (reserves[anchorIndex] <= 0n)\n    throw new Error(\"anchor asset has no reserve\");\n  if (d <= 0n) throw new Error(\"Pool sum invariant is zero\");\n  if (anchorAmount <= 0n) return reserves.map(() => 0n);\n\n  const t = floorDiv(anchorAmount * d, reserves[anchorIndex]);\n  return reserves.map((r, i) =>\n    i === anchorIndex ? anchorAmount : ceilDiv(r * t, d),\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/PoolMath/index.js

@@ -2,5 +2,6 @@ export * as ConcentratedLiquidityPool from "./ConcentratedLiquidityPool.js";
 export * as ConstantProductPool from "./ConstantProductPool.js";
 export * as ConstantSumPool from "./ConstantSumPool.js";
 export * as StableSwapsPool from "./StableSwapsPool.js";
+export * as V4StableswapPool from "./V4StableswapPool.js";
 export * as SharedPoolMath from "./SharedPoolMath.js";
 //# sourceMappingURL=index.js.map

package/dist/esm/PoolMath/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ConcentratedLiquidityPool","ConstantProductPool","ConstantSumPool","StableSwapsPool","SharedPoolMath"],"sources":["../../../src/PoolMath/index.ts"],"sourcesContent":["export * as ConcentratedLiquidityPool from \"./ConcentratedLiquidityPool.js\";\nexport * as ConstantProductPool from \"./ConstantProductPool.js\";\nexport * as ConstantSumPool from \"./ConstantSumPool.js\";\nexport * as StableSwapsPool from \"./StableSwapsPool.js\";\nexport * as SharedPoolMath from \"./SharedPoolMath.js\";\n"],"mappings":"AAAA,OAAO,KAAKA,yBAAyB,MAAM,gCAAgC;AAC3E,OAAO,KAAKC,mBAAmB,MAAM,0BAA0B;AAC/D,OAAO,KAAKC,eAAe,MAAM,sBAAsB;AACvD,OAAO,KAAKC,eAAe,MAAM,sBAAsB;AACvD,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["ConcentratedLiquidityPool","ConstantProductPool","ConstantSumPool","StableSwapsPool","V4StableswapPool","SharedPoolMath"],"sources":["../../../src/PoolMath/index.ts"],"sourcesContent":["export * as ConcentratedLiquidityPool from \"./ConcentratedLiquidityPool.js\";\nexport * as ConstantProductPool from \"./ConstantProductPool.js\";\nexport * as ConstantSumPool from \"./ConstantSumPool.js\";\nexport * as StableSwapsPool from \"./StableSwapsPool.js\";\nexport * as V4StableswapPool from \"./V4StableswapPool.js\";\nexport * as SharedPoolMath from \"./SharedPoolMath.js\";\n"],"mappings":"AAAA,OAAO,KAAKA,yBAAyB,MAAM,gCAAgC;AAC3E,OAAO,KAAKC,mBAAmB,MAAM,0BAA0B;AAC/D,OAAO,KAAKC,eAAe,MAAM,sBAAsB;AACvD,OAAO,KAAKC,eAAe,MAAM,sBAAsB;AACvD,OAAO,KAAKC,gBAAgB,MAAM,uBAAuB;AACzD,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}