@sundaeswap/math 0.2.2 → 0.4.0

package/dist/cjs/PoolMath/V4StableswapPool.js

@@ -0,0 +1,529 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pinnedDepositFromAnchor = exports.invariantG = exports.invariantF = exports.getSwapOutput = exports.getSwapInput = exports.getRawSwap = exports.getPrice = exports.getD = exports.calculatePinnedDeposit = exports.calculateLiquidity = exports.CALC_PRECISION = void 0;
+var _asset = require("@sundaeswap/asset");
+var _fraction = require("@sundaeswap/fraction");
+var _index = require("./index.js");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * 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. */
+var CALC_PRECISION = exports.CALC_PRECISION = 1000000000000n;
+
+/** Newton iteration cap, matching the reference implementation. */
+var NEWTON_MAX_ITERATIONS = 255;
+
+/** Bound on the fix-up walk of the reverse swap. The closed form lands within a few units. */
+var 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 −∞. */
+var floorDiv = function floorDiv(a, b) {
+  var q = a / b;
+  var r = a % b;
+  return r !== 0n && r < 0n !== b < 0n ? q - 1n : q;
+};
+
+/** ceil(a / b) with the same sign convention as {@link floorDiv}. */
+var ceilDiv = function ceilDiv(a, b) {
+  return -floorDiv(-a, b);
+};
+var asFeeParts = function asFeeParts(fee) {
+  var f = _fraction.Fraction.asFraction(fee);
+  if (f.lt(_fraction.Fraction.ZERO) || f.gte(_fraction.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.
+ */
+var invariantF = exports.invariantF = function invariantF(x, y, amp, d) {
+  var 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.
+ */
+var invariantG = exports.invariantG = function invariantG(x, y, amp, d) {
+  var 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`. */
+var fixD = function fixD(x, y, amp, d0) {
+  var 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.
+ */
+var getD = exports.getD = function getD(amp, aReserve, bReserve) {
+  var rateA = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1n;
+  var rateB = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 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");
+  var xs = aReserve * rateA * CALC_PRECISION;
+  var ys = bReserve * rateB * CALC_PRECISION;
+  var 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");
+  }
+  var ann = 4n * amp;
+  var d = sum;
+  for (var i = 0; i < NEWTON_MAX_ITERATIONS; i++) {
+    var dP = floorDiv(d * d * d, 4n * xs * ys);
+    var dNext = floorDiv((ann * sum + 2n * dP) * d, (ann - 1n) * d + 3n * dP);
+    var 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.
+ */
+var solveCounterparty = function solveCounterparty(amp, d, xs) {
+  if (xs <= 0n) throw new Error("solveCounterparty: the given side must be positive");
+  var 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.
+  var c = floorDiv(floorDiv(d * d, 2n * xs) * d, 2n * ann);
+  var b = xs + floorDiv(d, ann);
+  var y = d;
+  var converged = false;
+  for (var i = 0; i < NEWTON_MAX_ITERATIONS; i++) {
+    var yNext = floorDiv(y * y + c, 2n * y + b - d);
+    var 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.
+ */
+var getRawSwap = exports.getRawSwap = function getRawSwap(amp, d, inAfter, outBefore) {
+  var rateIn = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1n;
+  var rateOut = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 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");
+  var 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.
+ */
+var marginalInputPerOutput = function marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut) {
+  var common = 16n * amp * xs * xs * ys * ys;
+  var cube = d * d * d;
+  return new _fraction.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.
+ */
+var getPrice = exports.getPrice = function getPrice(amp, aReserve, bReserve) {
+  var rateA = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1n;
+  var rateB = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1n;
+  if (aReserve <= 0n || bReserve <= 0n) throw new Error("reserves must be positive");
+  var d = getD(amp, aReserve, bReserve, rateA, rateB);
+  var xs = aReserve * rateA * CALC_PRECISION;
+  var 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.
+ */
+var getSwapOutput = exports.getSwapOutput = function 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");
+  var _asFeeParts = asFeeParts(fee),
+    _asFeeParts2 = _slicedToArray(_asFeeParts, 2),
+    feeNum = _asFeeParts2[0],
+    feeDen = _asFeeParts2[1];
+  var d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);
+  var raw = getRawSwap(amp, d, inputReserve + input, outputReserve, rateIn, rateOut);
+  var gross = floorDiv(raw, rateOut * CALC_PRECISION);
+  var lpFee = ceilDiv(gross * feeNum, feeDen);
+  var output = gross - lpFee;
+  if (output <= 0n) throw new Error("Swap yields no output after the fee; raise the input");
+  var nextInputReserve = inputReserve + input;
+  var 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.
+  var xs = inputReserve * rateIn * CALC_PRECISION;
+  var ys = outputReserve * rateOut * CALC_PRECISION;
+  var idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);
+  var actualPrice = new _fraction.Fraction(input, gross);
+  var priceImpact = _fraction.Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  return {
+    input: input,
+    output: output,
+    lpFee: new _asset.AssetAmount(lpFee, outputMetadata),
+    nextInputReserve: nextInputReserve,
+    nextOutputReserve: nextOutputReserve,
+    priceImpact: 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.
+ */
+var getSwapInput = exports.getSwapInput = function 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");
+  var _asFeeParts3 = asFeeParts(fee),
+    _asFeeParts4 = _slicedToArray(_asFeeParts3, 2),
+    feeNum = _asFeeParts4[0],
+    feeDen = _asFeeParts4[1];
+
+  // 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)).
+  var grossMin = ceilDiv(output * feeDen, feeDen - feeNum);
+  if (grossMin >= outputReserve) throw new Error("Output is not reachable: the fee pushes it past the reserve");
+  var d = getD(amp, inputReserve, outputReserve, rateIn, rateOut);
+  var scaleIn = rateIn * CALC_PRECISION;
+  var scaleOut = rateOut * CALC_PRECISION;
+
+  // 2. The most the pool may keep of the taken asset and still pay `grossMin`.
+  var 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.
+  var xNeeded = solveCounterparty(amp, d, yTarget);
+  var xBefore = inputReserve * scaleIn;
+  var input = ceilDiv(xNeeded - xBefore, scaleIn);
+  if (input < 1n) input = 1n;
+  var grossOf = function grossOf(dx) {
+    return floorDiv(getRawSwap(amp, d, inputReserve + dx, outputReserve, rateIn, rateOut), scaleOut);
+  };
+  var 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");
+  }
+  var gross = grossOf(input);
+  var lpFee = ceilDiv(gross * feeNum, feeDen);
+  var nextInputReserve = inputReserve + input;
+  var nextOutputReserve = outputReserve - output;
+  var xs = xBefore;
+  var ys = outputReserve * scaleOut;
+  var idealPrice = marginalInputPerOutput(amp, xs, ys, d, rateIn, rateOut);
+  var actualPrice = new _fraction.Fraction(input, gross);
+  var priceImpact = _fraction.Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  return {
+    input: input,
+    output: output,
+    lpFee: new _asset.AssetAmount(lpFee, outputMetadata),
+    nextInputReserve: nextInputReserve,
+    nextOutputReserve: nextOutputReserve,
+    priceImpact: 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`.
+ */
+var calculatePinnedDeposit = exports.calculatePinnedDeposit = function 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(function (o) {
+    return o < 0n;
+  })) throw new Error("Deposit amounts must be non-negative");
+  var t;
+  for (var i = 0; i < offered.length; i++) {
+    if (reserves[i] <= 0n) continue;
+    var 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)");
+  var deltas = reserves.map(function (r) {
+    return ceilDiv(r * t, d);
+  });
+  var nextTotalLp = floorDiv(totalLp * (d + t), d);
+  var generatedLp = nextTotalLp - totalLp;
+  if (generatedLp <= 0n) throw new Error("Deposit mints zero LP");
+  return {
+    targetDeltaD: t,
+    deltas: deltas,
+    generatedLp: generatedLp,
+    nextTotalLp: nextTotalLp,
+    shareAfterDeposit: _index.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.
+ */
+var calculateLiquidity = exports.calculateLiquidity = function calculateLiquidity(a, b, aReserve, bReserve, totalLp, rateA, rateB, amp) {
+  if (aReserve <= 0n || bReserve <= 0n) throw new Error("Not enough pool liquidity");
+  var d = getD(amp, aReserve, bReserve, rateA, rateB);
+  var _calculatePinnedDepos = calculatePinnedDeposit([a, b], [aReserve, bReserve], totalLp, d),
+    deltas = _calculatePinnedDepos.deltas,
+    generatedLp = _calculatePinnedDepos.generatedLp,
+    nextTotalLp = _calculatePinnedDepos.nextTotalLp,
+    shareAfterDeposit = _calculatePinnedDepos.shareAfterDeposit;
+  return {
+    nextTotalLp: nextTotalLp,
+    generatedLp: generatedLp,
+    shareAfterDeposit: 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.
+ */
+var pinnedDepositFromAnchor = exports.pinnedDepositFromAnchor = function 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(function () {
+    return 0n;
+  });
+  var t = floorDiv(anchorAmount * d, reserves[anchorIndex]);
+  return reserves.map(function (r, i) {
+    return i === anchorIndex ? anchorAmount : ceilDiv(r * t, d);
+  });
+};
+//# sourceMappingURL=V4StableswapPool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"V4StableswapPool.js","names":["_asset","require","_fraction","_index","_slicedToArray","r","e","_arrayWithHoles","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","TypeError","a","_arrayLikeToArray","t","toString","call","slice","constructor","name","Array","from","test","length","n","l","Symbol","iterator","i","u","f","o","next","Object","done","push","value","isArray","CALC_PRECISION","exports","NEWTON_MAX_ITERATIONS","CORRECTION_MAX_STEPS","floorDiv","b","q","ceilDiv","asFeeParts","fee","Fraction","asFraction","lt","ZERO","gte","ONE","Error","BigInt","numerator","denominator","invariantF","x","y","amp","d","sixteenAxy","invariantG","fourXy","fixD","d0","getD","aReserve","bReserve","rateA","arguments","undefined","rateB","xs","ys","sum","ann","dP","dNext","diff","solveCounterparty","c","converged","yNext","getRawSwap","inAfter","outBefore","rateIn","rateOut","marginalInputPerOutput","common","cube","getPrice","getSwapOutput","outputMetadata","input","inputReserve","outputReserve","_asFeeParts","_asFeeParts2","feeNum","feeDen","raw","gross","lpFee","output","nextInputReserve","nextOutputReserve","idealPrice","actualPrice","priceImpact","subtract","divide","AssetAmount","getSwapInput","_asFeeParts3","_asFeeParts4","grossMin","scaleIn","scaleOut","yTarget","xNeeded","xBefore","grossOf","dx","steps","calculatePinnedDeposit","offered","reserves","totalLp","some","cap","deltas","map","nextTotalLp","generatedLp","targetDeltaD","shareAfterDeposit","SharedPoolMath","getShare","calculateLiquidity","_calculatePinnedDepos","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/cjs/PoolMath/index.js

@@ -4,11 +4,17 @@ function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" ==
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.StableSwapsPool = exports.SharedPoolMath = exports.ConstantProductPool = void 0;
+exports.V4StableswapPool = exports.StableSwapsPool = exports.SharedPoolMath = exports.ConstantSumPool = exports.ConstantProductPool = exports.ConcentratedLiquidityPool = void 0;
+var _ConcentratedLiquidityPool = _interopRequireWildcard(require("./ConcentratedLiquidityPool.js"));
+exports.ConcentratedLiquidityPool = _ConcentratedLiquidityPool;
 var _ConstantProductPool = _interopRequireWildcard(require("./ConstantProductPool.js"));
 exports.ConstantProductPool = _ConstantProductPool;
+var _ConstantSumPool = _interopRequireWildcard(require("./ConstantSumPool.js"));
+exports.ConstantSumPool = _ConstantSumPool;
 var _StableSwapsPool = _interopRequireWildcard(require("./StableSwapsPool.js"));
 exports.StableSwapsPool = _StableSwapsPool;
+var _V4StableswapPool = _interopRequireWildcard(require("./V4StableswapPool.js"));
+exports.V4StableswapPool = _V4StableswapPool;
 var _SharedPoolMath = _interopRequireWildcard(require("./SharedPoolMath.js"));
 exports.SharedPoolMath = _SharedPoolMath;
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }