@sundaeswap/math 0.5.1 → 0.6.0

package/dist/cjs/PoolMath/ConcentratedLiquidityPool.js

@@ -1,214 +1,709 @@
 "use strict";
 
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSwapOutput = exports.getSwapInput = exports.calculateLiquidity = void 0;
+exports.upperEdge = exports.uniformLadder = exports.swapSteps = exports.shapedLadder = exports.reservesAt = exports.prefixes = exports.nextBand = exports.minCreateCounter = exports.maxDxInBand = exports.liquidityOf = exports.indexLadder = exports.getSwapOutput = exports.findWitnessInBand = exports.findWitness = exports.feeFor = exports.delta = exports.coeffB = exports.coeffA = exports.buildIndex = exports.bandWeights = exports.bandView = exports.bandStates = exports.bandProof = exports.bandOutput = exports.bandOf = exports.bandFee = exports.bandCapacity = exports.bSat = exports.aSat = exports.MIN_COUNTER_PER_WEIGHT = exports.FIXED_ONE = void 0;
 var _asset = require("@sundaeswap/asset");
 var _fraction = require("@sundaeswap/fraction");
-var ConstantProductPool = _interopRequireWildcard(require("./ConstantProductPool.js"));
-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); }
-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 _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /**
- * Holds the calculated outcome of a concentrated-liquidity swap. Mirrors
- * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic
- * swap-outcome consumers.
+ * Holds the calculated outcome of a concentrated-liquidity swap. It has the
+ * same shape as `ConstantProductPool.TSwapOutcome`, so the generic
+ * swap-outcome consumers accept it.
  */
 
-/** A sqrt-price bound from the CL config, as an exact rational `[num, den]`. */
-
 /**
- * Concentrated liquidity is Sundae v4's single-range invariant. Unlike Uniswap
- * v3 there are no per-position ranges or ticks: the whole pool shares ONE
- * immutable price range `[sqrtPriceA, sqrtPriceB]` (a < b) set at creation, and
- * LP is a single fungible token. Swaps run on *virtual* reserves that fold the
- * pool's liquidity `L` (its total LP supply) into each side:
+ * Concentrated liquidity: Sundae v4's ladder invariant.
+ *
+ * A pool is a ladder of bands in ascending sqrt-price order. Each band is a
+ * concentrated-liquidity arc (`curve` 0) or a constant-sum bin (`curve` 1)
+ * with its own share of the pool's liquidity (`weight / weightTotal`) and
+ * its own two fees. LP is one fungible token for the whole ladder; a
+ * deposit or withdrawal scales every band.
  *
- *   VA = a·spbNum + L·spbDen
- *   VB = b·spaDen + L·spaNum
+ * The chain never stores the price. It stores reserves, and the state is a
+ * WITNESS `(X, k)`: the ladder counter `X` (the pool's `total_lp`, spec V12)
+ * and the active band `k`, which the reserves must prove. Everything here
+ * mirrors `lib/modules/cl_check.ak` and the scooper's ladder
+ * math, rounding included; where they disagree the chain wins
+ * and the transaction fails. The rounding is not negotiable:
  *
- * where `a`/`b` are the raw assetA/assetB reserves. This is a direct port of the
- * scooper's `cl_swap_result` (scooper-v2/src/sundaev4/swap_math.rs) and the
- * on-chain `cl_check_swap` (sundae-v4/lib/modules/cl_check.ak) — those are the
- * source of truth; keep this in lockstep with them.
+ *   - `L_k` floors; saturation ceils, in ONE division;
+ *   - the band fee ceils, per step, on the step's real input;
+ *   - the prefix sums come from the LADDER INDEX (cumulative coefficients
+ *     in fixed point at 2^64, spec §2.3), multiplied by the counter and
+ *     ceiled ONCE. A per-band sum of ceilings is a different number and the
+ *     chain rejects it.
+ */
+
+/** An exact rational `num / den`. */
+
+/** One band of the ladder. */
+
+/** A ladder: bands, the top edge, and the sum of the weights. */
+
+/** The witness the chain checks: the ladder counter and the active band. */
+
+/** 2^64, the fixed-point scale of the ladder index. */
+var FIXED_ONE = exports.FIXED_ONE = 1n << 64n;
+
+/**
+ * The least counter per unit of weight a ladder may be created with.
+ * Mirrors `cl_check.min_counter_per_weight` (sundae-v4 #229, SV4-007):
+ * Create requires `total_lp >= MIN_COUNTER_PER_WEIGHT * weightTotal`.
+ */
+var MIN_COUNTER_PER_WEIGHT = exports.MIN_COUNTER_PER_WEIGHT = 1000n;
+
+/** The least counter (initial `total_lp`) the chain accepts at Create for `ladder`. */
+var minCreateCounter = exports.minCreateCounter = function minCreateCounter(ladder) {
+  return MIN_COUNTER_PER_WEIGHT * ladder.weightTotal;
+};
+var ceilDiv = function ceilDiv(n, d) {
+  return (n + d - 1n) / d;
+};
+
+/** Band i's upper sqrt-price edge. */
+var upperEdge = exports.upperEdge = function upperEdge(l, i) {
+  return i + 1 < l.bands.length ? l.bands[i + 1].start : l.closing;
+};
+
+/** `D_i = hi.num·lo.den − lo.num·hi.den`: positive exactly when the edges increase. */
+var delta = exports.delta = function delta(lo, hi) {
+  return hi.num * lo.den - lo.num * hi.den;
+};
+
+/** `a_sat_i = ceil(w_i·X·D_i / (W·lo.num·hi.num))`: the A a band above the price holds. */
+var aSat = exports.aSat = function aSat(l, x, i) {
+  var lo = l.bands[i].start;
+  var hi = upperEdge(l, i);
+  return ceilDiv(l.bands[i].weight * x * delta(lo, hi), l.weightTotal * lo.num * hi.num);
+};
+
+/** `b_sat_i = ceil(w_i·X·D_i / (W·lo.den·hi.den))`: the B a band below the price holds. */
+var bSat = exports.bSat = function bSat(l, x, i) {
+  var lo = l.bands[i].start;
+  var hi = upperEdge(l, i);
+  return ceilDiv(l.bands[i].weight * x * delta(lo, hi), l.weightTotal * lo.den * hi.den);
+};
+
+/** `L_k = floor(w_k·X / W)`. */
+var liquidityOf = exports.liquidityOf = function liquidityOf(l, x, k) {
+  return l.bands[k].weight * x / l.weightTotal;
+};
+
+/** Band i's A-side saturation coefficient: the part of `a_sat_i` independent of X, rounded up. */
+var coeffA = exports.coeffA = function coeffA(l, i) {
+  var lo = l.bands[i].start;
+  var hi = upperEdge(l, i);
+  return ceilDiv(l.bands[i].weight * delta(lo, hi) * FIXED_ONE, l.weightTotal * lo.num * hi.num);
+};
+
+/** The same on the B side. */
+var coeffB = exports.coeffB = function coeffB(l, i) {
+  var lo = l.bands[i].start;
+  var hi = upperEdge(l, i);
+  return ceilDiv(l.bands[i].weight * delta(lo, hi) * FIXED_ONE, l.weightTotal * lo.den * hi.den);
+};
+
+/** One index entry: the cumulative coefficients above and below band k. */
+
+/**
+ * The ladder index `Create` pins and every spend reads: entry k is the pair
+ * of cumulative coefficients for the bands strictly above and strictly
+ * below band k. `cl_check.build_index`, to the digit.
  */
+var buildIndex = exports.buildIndex = function buildIndex(l) {
+  var n = l.bands.length;
+  var a = Array.from({
+    length: n
+  }, function (_, i) {
+    return coeffA(l, i);
+  });
+  var b = Array.from({
+    length: n
+  }, function (_, i) {
+    return coeffB(l, i);
+  });
+  var out = [];
+  for (var k = 0; k < n; k++) {
+    var ca = 0n;
+    var cb = 0n;
+    for (var i = 0; i < n; i++) {
+      if (i > k) ca += a[i];
+      if (i < k) cb += b[i];
+    }
+    out.push({
+      ca: ca,
+      cb: cb
+    });
+  }
+  return out;
+};
+
+/**
+ * A ladder with its index built once. Every probe of the witness search
+ * reads the index for every band, and rebuilding it per probe is most of
+ * the cost of a quote.
+ */
+
+var indexLadder = exports.indexLadder = function indexLadder(l) {
+  return "index" in l && Array.isArray(l.index) ? l : _objectSpread(_objectSpread({}, l), {}, {
+    index: buildIndex(l)
+  });
+};
+
+/** `C_A`, `C_B` at (X, k) from the index: one ceiling after the multiply by X. */
+var prefixes = exports.prefixes = function prefixes(l, x, k) {
+  var e = l.index[k];
+  return {
+    ca: ceilDiv(e.ca * x, FIXED_ONE),
+    cb: ceilDiv(e.cb * x, FIXED_ONE)
+  };
+};
 
-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)];
+/** `cl_check.f_at_raw`: the CL arc, cross-multiplied. */
+var fAt = function fAt(a, b, L, lo, hi) {
+  return (a * hi.num + L * hi.den) * (b * lo.den + L * lo.num) - L * L * hi.num * lo.den;
 };
 
+/** G at a witness, on whichever curve the active band carries. */
+var gAt = function gAt(l, A, B, x, k) {
+  var _prefixes = prefixes(l, x, k),
+    ca = _prefixes.ca,
+    cb = _prefixes.cb;
+  var lo = l.bands[k].start;
+  var hi = upperEdge(l, k);
+  var ra = A - ca;
+  var rb = B - cb;
+  var L = liquidityOf(l, x, k);
+  return l.bands[k].curve === 0 ? fAt(ra, rb, L, lo, hi) : ra * (lo.num * hi.num) + rb * (lo.den * hi.den) - L * delta(lo, hi);
+};
+
+/** The band proof, P1 through P7. The chain runs exactly this. */
+var bandProof = exports.bandProof = function bandProof(l, A, B, x, k) {
+  if (x < l.weightTotal) return false; // P1
+  var _prefixes2 = prefixes(l, x, k),
+    ca = _prefixes2.ca,
+    cb = _prefixes2.cb;
+  var ra = A - ca;
+  var rb = B - cb;
+  if (ra < 0n || rb < 0n) return false; // P2, P3
+  if (ra > aSat(l, x, k) || rb > bSat(l, x, k)) return false; // P4, P5
+  if (gAt(l, A, B, x, k) < 0n) return false; // P6
+  return gAt(l, A, B, x + 1n, k) < 0n; // P7
+};
+var SCAN = 400n;
+var CAP = 1n << 80n;
+
 /**
- * The raw forward swap: given a pre-fee input `dx`, return the output amount.
- * A→B and B→A use different virtual-reserve scalings (see `cl_check_swap`).
- * All quantities are non-negative so integer division floors, matching chain.
+ * The witness in band k, seeded at `hint` when given: the counter only
+ * grows along a swap, so the doubling search starts from the previous
+ * witness. `lo` is the largest x with non-negative residuals and G ≥ 0,
+ * and a witness is such an x whose successor fails G, so the scan walks
+ * DOWN from `lo` first. Mirrors the scooper's `find_witness_in_band_from`.
  */
-var rawSwapOutput = function rawSwapOutput(dx, aReserve, bReserve, totalLp, spaNum, spaDen, spbNum, spbDen, feeNum, feeDen, isAInput) {
-  var fee = dx * feeNum / feeDen;
-  var dxEff = dx - fee;
-  var va0 = aReserve * spbNum + totalLp * spbDen;
-  var vb0 = bReserve * spaDen + totalLp * spaNum;
-  if (isAInput) {
-    var dvaEff = dxEff * spbNum;
-    var _denom = (va0 + dvaEff) * spaDen;
-    if (_denom <= 0n) return 0n;
-    return vb0 * dvaEff / _denom;
+var findWitnessInBand = exports.findWitnessInBand = function findWitnessInBand(l, A, B, k, hint) {
+  var ok = function ok(x) {
+    var _prefixes3 = prefixes(l, x, k),
+      ca = _prefixes3.ca,
+      cb = _prefixes3.cb;
+    return A - ca >= 0n && B - cb >= 0n && gAt(l, A, B, x, k) >= 0n;
+  };
+  var search = function search(start) {
+    var lo = start;
+    var span = 1n;
+    var hi = lo + span;
+    while (ok(hi) && hi < CAP) {
+      lo = hi;
+      span *= 2n;
+      hi = lo + span;
+    }
+    while (lo + 1n < hi) {
+      var m = (lo + hi) / 2n;
+      if (ok(m)) lo = m;else hi = m;
+    }
+    var from = lo > SCAN ? lo - SCAN : 1n;
+    for (var x = lo; x >= from; x--) {
+      if (bandProof(l, A, B, x, k)) return {
+        x: x,
+        k: k
+      };
+    }
+    for (var _x = lo + 1n; _x <= lo + SCAN; _x++) {
+      if (bandProof(l, A, B, _x, k)) return {
+        x: _x,
+        k: k
+      };
+    }
+    return null;
+  };
+  if (hint !== undefined && hint > 0n && ok(hint)) {
+    var w = search(hint);
+    if (w) return w;
   }
-  var dvbEff = dxEff * spaNum;
-  var denom = (vb0 + dvbEff) * spbNum;
-  if (denom <= 0n) return 0n;
-  return va0 * dvbEff / denom;
+  if (!ok(1n)) return null;
+  return search(1n);
 };
 
 /**
- * Calculate the swap outcome for a concentrated-liquidity pool.
+ * The witness `(X, k)` for a pool's reserves. A hint (the indexed
+ * `bandCounter` / `activeBand`) is checked first and seeds the search in
+ * its band; a stale hint falls back to every band. Null when the reserves
+ * sit on no point of the ladder — the chain would reject them too.
+ */
+var findWitness = exports.findWitness = function findWitness(ladder, A, B, hint) {
+  var l = indexLadder(ladder);
+  if (hint && hint.k >= 0 && hint.k < l.bands.length) {
+    if (bandProof(l, A, B, hint.x, hint.k)) return hint;
+    var w = findWitnessInBand(l, A, B, hint.k, hint.x);
+    if (w) return w;
+  }
+  for (var k = 0; k < l.bands.length; k++) {
+    var _w = findWitnessInBand(l, A, B, k);
+    if (_w) return _w;
+  }
+  return null;
+};
+
+/** The active band's view at a witness: its residual reserves and liquidity. */
+
+var bandView = exports.bandView = function bandView(l, A, B, w) {
+  var _prefixes4 = prefixes(l, w.x, w.k),
+    ca = _prefixes4.ca,
+    cb = _prefixes4.cb;
+  var band = l.bands[w.k];
+  return {
+    ra: A - ca,
+    rb: B - cb,
+    l: liquidityOf(l, w.x, w.k),
+    lo: band.start,
+    hi: upperEdge(l, w.k),
+    curve: band.curve,
+    feeBuy: band.feeBuy,
+    feeSell: band.feeSell
+  };
+};
+
+/** The band's fee for a direction: `feeSell` when A is sold, `feeBuy` when A is bought. */
+var feeFor = exports.feeFor = function feeFor(v, isAInput) {
+  return isAInput ? v.feeSell : v.feeBuy;
+};
+
+/**
+ * The band fee on a step's real input `dx`: `ceil(dx * num / den)`.
+ * Mirrors `cl_check.band_fee` (sundae-v4 #228, SV4-006). The chain charges
+ * it per transcript step and rounds it UP, so a step below `den / num`
+ * units still pays one unit. A zero rate charges nothing.
+ */
+var bandFee = exports.bandFee = function bandFee(dx, fee) {
+  return (dx * fee.num + fee.den - 1n) / fee.den;
+};
+
+/** The output one band pays for `dx` within itself. Mirrors the scooper's `band_output`. */
+var bandOutput = exports.bandOutput = function bandOutput(v, isAInput, dx) {
+  var fee = feeFor(v, isAInput);
+  if (fee.den <= 0n) return 0n;
+  var dxEff = dx - bandFee(dx, fee);
+  if (dxEff <= 0n) return 0n;
+  if (v.curve === 0) {
+    var va0 = v.ra * v.hi.num + v.l * v.hi.den;
+    var vb0 = v.rb * v.lo.den + v.l * v.lo.num;
+    if (isAInput) {
+      var dva = dxEff * v.hi.num;
+      var _den = (va0 + dva) * v.lo.den;
+      return _den === 0n ? 0n : vb0 * dva / _den;
+    }
+    var dvb = dxEff * v.lo.den;
+    var den = (vb0 + dvb) * v.hi.num;
+    return den === 0n ? 0n : va0 * dvb / den;
+  }
+  var pn = v.lo.num * v.hi.num;
+  var pd = v.lo.den * v.hi.den;
+  return isAInput ? dxEff * pn / pd : dxEff * pd / pn;
+};
+
+/** What the band can pay out in a direction: its residual of the output asset. */
+var bandCapacity = exports.bandCapacity = function bandCapacity(v, isAInput) {
+  return isAInput ? v.rb : v.ra;
+};
+
+/** The largest input whose output stays within the band. */
+var maxDxInBand = exports.maxDxInBand = function maxDxInBand(v, isAInput) {
+  var cap = bandCapacity(v, isAInput);
+  if (cap <= 0n) return 0n;
+  var fits = function fits(dx) {
+    return bandOutput(v, isAInput, dx) <= cap;
+  };
+  var hi = 1n;
+  for (var guard = 0; fits(hi); guard++) {
+    hi *= 2n;
+    if (guard > 200) return hi;
+  }
+  var lo = 0n;
+  while (lo + 1n < hi) {
+    var m = (lo + hi) / 2n;
+    if (fits(m)) lo = m;else hi = m;
+  }
+  return lo;
+};
+
+/** The next band a fill enters: selling A walks down the ladder, buying A walks up. */
+var nextBand = exports.nextBand = function nextBand(k, isAInput, n) {
+  return isAInput ? k === 0 ? null : k - 1 : k + 1 >= n ? null : k + 1;
+};
+
+/** One band of a fill: what it paid, and the state it left. */
+
+/**
+ * Price `dx` across as many bands as it takes, as the scooper's
+ * `swap_steps` does: fill the active band, cross to the next, repeat.
+ * Returns the steps, or null when the ladder cannot absorb `dx` (the
+ * direction is exhausted, or the remainder pays nothing).
+ */
+var swapSteps = exports.swapSteps = function swapSteps(ladder, A, B, isAInput, dx, hint) {
+  var l = indexLadder(ladder);
+  var n = l.bands.length;
+  var ca = A;
+  var cb = B;
+  var remaining = dx;
+  var steps = [];
+  var known = findWitness(l, A, B, hint);
+  if (!known) return null;
+  var prefer = null;
+  var hintX;
+  for (var guard = 0; remaining > 0n; guard++) {
+    if (guard > 2 * n + 2) return null;
+    var before = known;
+    known = null;
+    if (!before) {
+      if (prefer !== null) before = findWitnessInBand(l, ca, cb, prefer, hintX);
+      if (!before) before = findWitness(l, ca, cb);
+      if (!before) return null;
+    }
+    var view = bandView(l, ca, cb, before);
+    var capDx = maxDxInBand(view, isAInput);
+    var stepDx = capDx < remaining ? capDx : remaining;
+    var dy = stepDx > 0n ? bandOutput(view, isAInput, stepDx) : 0n;
+    if (dy <= 0n) {
+      var kNext = nextBand(before.k, isAInput, n);
+      if (kNext === null || prefer === kNext) return null;
+      prefer = kNext;
+      continue;
+    }
+    var na = isAInput ? ca + stepDx : ca - dy;
+    var nb = isAInput ? cb - dy : cb + stepDx;
+    var crossing = stepDx < remaining;
+    var after = null;
+    if (crossing) {
+      var _kNext = nextBand(before.k, isAInput, n);
+      if (_kNext !== null) after = findWitnessInBand(l, na, nb, _kNext, before.x);
+    } else {
+      after = findWitnessInBand(l, na, nb, before.k, before.x);
+    }
+    if (!after) after = findWitness(l, na, nb);
+    if (!after || after.x < before.x) return null;
+    steps.push({
+      band: before.k,
+      input: stepDx,
+      output: dy,
+      after: after
+    });
+    remaining -= stepDx;
+    ca = na;
+    cb = nb;
+    prefer = after.k;
+    hintX = after.x;
+    known = after;
+  }
+  return steps;
+};
+
+/**
+ * The swap output of a concentrated-liquidity pool for `input` of one asset, crossing
+ * bands as needed. `aReserve`/`bReserve` are the pool's reserves in
+ * canonical order; `hint` is the indexed `bandCounter` / `activeBand`,
+ * which seeds the witness search and may be stale.
  *
- * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.
- * @param input The pre-fee amount of the input asset being swapped.
- * @param aReserve The pool's raw reserve of asset A.
- * @param bReserve The pool's raw reserve of asset B.
- * @param totalLp The pool's total LP supply (the virtual liquidity `L`).
- * @param sqrtPriceA The lower sqrt-price bound `[num, den]` from the CL config.
- * @param sqrtPriceB The upper sqrt-price bound `[num, den]` from the CL config.
- * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.
- * @param isAInput True when asset A is the supplied asset (A→B swap).
- * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ * The `lpFee` is the fee the bands kept of the input, summed across the
+ * steps. `priceImpact` is against the active band's opening marginal
+ * price. Throws when the ladder cannot absorb the input.
  */
-var getSwapOutput = exports.getSwapOutput = function getSwapOutput(inputMetadata, input, aReserve, bReserve, totalLp, sqrtPriceA, sqrtPriceB, fee, isAInput) {
-  if (input <= 0n || aReserve <= 0n || bReserve <= 0n || totalLp <= 0n) throw new Error("Input, reserves and liquidity must be positive");
-  var _sqrtPriceA = _slicedToArray(sqrtPriceA, 2),
-    spaNum = _sqrtPriceA[0],
-    spaDen = _sqrtPriceA[1];
-  var _sqrtPriceB = _slicedToArray(sqrtPriceB, 2),
-    spbNum = _sqrtPriceB[0],
-    spbDen = _sqrtPriceB[1];
-  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n) throw new Error("sqrt prices must be positive");
-  var _asFeeParts = asFeeParts(fee),
-    _asFeeParts2 = _slicedToArray(_asFeeParts, 2),
-    feeNum = _asFeeParts2[0],
-    feeDen = _asFeeParts2[1];
+var getSwapOutput = exports.getSwapOutput = function getSwapOutput(inputMetadata, input, aReserve, bReserve, ladder, isAInput, hint) {
+  if (input <= 0n || aReserve < 0n || bReserve < 0n) throw new Error("Input must be positive and reserves non-negative");
+  if (ladder.bands.length === 0 || ladder.weightTotal <= 0n) throw new Error("The ladder has no bands");
+  var l = indexLadder(ladder);
+  var steps = swapSteps(l, aReserve, bReserve, isAInput, input, hint);
+  if (!steps || steps.length === 0) throw new Error("The ladder cannot absorb this input in this direction");
+  var output = 0n;
+  var lpFee = 0n;
+  var _iterator = _createForOfIteratorHelper(steps),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var s = _step.value;
+      output += s.output;
+      var band = l.bands[s.band];
+      var fee = isAInput ? band.feeSell : band.feeBuy;
+      lpFee += bandFee(s.input, fee);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
   var inputReserve = isAInput ? aReserve : bReserve;
   var outputReserve = isAInput ? bReserve : aReserve;
-  var output = rawSwapOutput(input, aReserve, bReserve, totalLp, spaNum, spaDen, spbNum, spbDen, feeNum, feeDen, isAInput);
-  // Can't take more than the pool actually holds (virtual reserves can
-  // otherwise let the formula exceed the real reserve near the boundary).
   if (output > outputReserve) output = outputReserve;
-  var inputLpFee = input * feeNum / feeDen;
-  var nextInputReserve = inputReserve + input;
-  var nextOutputReserve = outputReserve - output;
-
-  // Price impact vs the marginal (dx→0) rate. Marginal output-per-effective-
-  // input is vb0·spbNum/(va0·spaDen) for A→B (symmetric for B→A), so the ideal
-  // input-per-output is its reciprocal. Display-only.
-  var va0 = aReserve * spbNum + totalLp * spbDen;
-  var vb0 = bReserve * spaDen + totalLp * spaNum;
+  // Price impact against the opening marginal of the first band traded.
+  var w0 = findWitness(l, aReserve, bReserve, hint);
+  var v0 = bandView(l, aReserve, bReserve, w0);
   var priceImpact = _fraction.Fraction.ZERO;
   if (output > 0n) {
-    var idealPrice = isAInput ? new _fraction.Fraction(va0 * spaDen, vb0 * spbNum) : new _fraction.Fraction(vb0 * spbNum, va0 * spaDen);
-    var actualPrice = new _fraction.Fraction(input - inputLpFee, output);
-    priceImpact = _fraction.Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+    var ideal;
+    if (v0.curve === 1) {
+      var pn = v0.lo.num * v0.hi.num;
+      var pd = v0.lo.den * v0.hi.den;
+      ideal = isAInput ? new _fraction.Fraction(pd, pn) : new _fraction.Fraction(pn, pd);
+    } else {
+      var va0 = v0.ra * v0.hi.num + v0.l * v0.hi.den;
+      var vb0 = v0.rb * v0.lo.den + v0.l * v0.lo.num;
+      ideal = isAInput ? new _fraction.Fraction(va0 * v0.lo.den, vb0 * v0.hi.num) : new _fraction.Fraction(vb0 * v0.hi.num, va0 * v0.lo.den);
+    }
+    var actual = new _fraction.Fraction(input - lpFee, output);
+    priceImpact = _fraction.Fraction.ONE.subtract(ideal.divide(actual));
   }
   return {
     input: input,
     output: output,
-    lpFee: new _asset.AssetAmount(inputLpFee, inputMetadata),
-    nextInputReserve: nextInputReserve,
-    nextOutputReserve: nextOutputReserve,
-    priceImpact: priceImpact
+    lpFee: new _asset.AssetAmount(lpFee, inputMetadata),
+    nextInputReserve: inputReserve + input,
+    nextOutputReserve: outputReserve - output,
+    priceImpact: priceImpact,
+    steps: steps
   };
 };
 
+/** What each band holds at the pool's reserves. */
+
 /**
- * Calculate the minimal input required to receive a given output — the inverse
- * of {@link getSwapOutput}. The forward swap is linear-fractional in the
- * effective input, so it inverts in closed form; a short correction loop
- * absorbs the fee floor and integer rounding so the result is the exact minimal
- * input whose forward swap yields at least `output`.
+ * Every band's state at the pool's reserves: a band below the price holds
+ * only B, a band above it only A, the active band some of both. Null when
+ * the reserves sit on no point of the ladder.
  */
-var getSwapInput = exports.getSwapInput = function getSwapInput(inputMetadata, output, aReserve, bReserve, totalLp, sqrtPriceA, sqrtPriceB, fee, isAInput) {
-  if (output <= 0n || aReserve <= 0n || bReserve <= 0n || totalLp <= 0n) throw new Error("Output, reserves and liquidity must be positive");
-  var _sqrtPriceA2 = _slicedToArray(sqrtPriceA, 2),
-    spaNum = _sqrtPriceA2[0],
-    spaDen = _sqrtPriceA2[1];
-  var _sqrtPriceB2 = _slicedToArray(sqrtPriceB, 2),
-    spbNum = _sqrtPriceB2[0],
-    spbDen = _sqrtPriceB2[1];
-  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n) throw new Error("sqrt prices must be positive");
-  var outputReserve = isAInput ? bReserve : aReserve;
-  if (output > outputReserve) throw new Error("Output must not exceed the output reserve");
-  var _asFeeParts3 = asFeeParts(fee),
-    _asFeeParts4 = _slicedToArray(_asFeeParts3, 2),
-    feeNum = _asFeeParts4[0],
-    feeDen = _asFeeParts4[1];
-  var feeDiff = feeDen - feeNum;
-  var va0 = aReserve * spbNum + totalLp * spbDen;
-  var vb0 = bReserve * spaDen + totalLp * spaNum;
-  var ceilDiv = function ceilDiv(n, d) {
-    return (n + d - 1n) / d;
-  };
+var bandStates = exports.bandStates = function bandStates(ladder, aReserve, bReserve, hint) {
+  var l = indexLadder(ladder);
+  var w = findWitness(l, aReserve, bReserve, hint);
+  if (!w) return null;
+  var out = [];
+  var restA = 0n;
+  var restB = 0n;
+  for (var i = 0; i < l.bands.length; i++) {
+    var liquidity = liquidityOf(l, w.x, i);
+    if (i < w.k) {
+      var b = bSat(l, w.x, i);
+      restB += b;
+      out.push({
+        quantities: [0n, b],
+        liquidity: liquidity,
+        active: false
+      });
+    } else if (i > w.k) {
+      var a = aSat(l, w.x, i);
+      restA += a;
+      out.push({
+        quantities: [a, 0n],
+        liquidity: liquidity,
+        active: false
+      });
+    } else {
+      out.push({
+        quantities: [0n, 0n],
+        liquidity: liquidity,
+        active: true
+      });
+    }
+  }
+  var ra = aReserve - restA;
+  var rb = bReserve - restB;
+  out[w.k].quantities = [ra < 0n ? 0n : ra, rb < 0n ? 0n : rb];
+  return out;
+};
 
-  // Closed-form minimal effective input, then gross up for the fee floor.
-  var effMin;
-  if (isAInput) {
-    // dvaEff ≥ output·spaDen·va0 / (vb0 − output·spaDen)
-    var denom = vb0 - output * spaDen;
-    if (denom <= 0n) throw new Error("Output not reachable within the pool's range");
-    var dvaEffMin = ceilDiv(output * spaDen * va0, denom);
-    effMin = ceilDiv(dvaEffMin, spbNum);
-  } else {
-    var _denom2 = va0 - output * spbNum;
-    if (_denom2 <= 0n) throw new Error("Output not reachable within the pool's range");
-    var dvbEffMin = ceilDiv(output * spbNum * vb0, _denom2);
-    effMin = ceilDiv(dvbEffMin, spaNum);
+/** Which band holds a sqrt-price. */
+var bandOf = exports.bandOf = function bandOf(l, s) {
+  for (var i = 0; i < l.bands.length; i++) {
+    var hi = upperEdge(l, i);
+    if (s.num * hi.den < hi.num * s.den) return i;
   }
-  var input = feeDiff > 0n ? ceilDiv(effMin * feeDen, feeDiff) : effMin;
+  return l.bands.length - 1;
+};
 
-  // Correct for floor interactions: nudge up until the forward swap clears the
-  // target, then trim any over-shoot. Bounded — a couple of iterations at most.
-  var fwd = function fwd(dx) {
-    return rawSwapOutput(dx, aReserve, bReserve, totalLp, spaNum, spaDen, spbNum, spbDen, feeNum, feeDen, isAInput);
+/**
+ * The exact reserves a ladder holds at counter `x` with the price at
+ * sqrt-price `s`, which must lie in band `k`: what a pool creator deposits
+ * for a chosen shape, scale and launch price. The result is floored, so
+ * `findWitness` must still be run on it to learn the counter the chain
+ * derives — usually `x`, but rounding can move it.
+ */
+var reservesAt = exports.reservesAt = function reservesAt(l, x, k, s) {
+  var A = 0n;
+  var B = 0n;
+  for (var i = 0; i < l.bands.length; i++) {
+    if (i > k) {
+      A += aSat(l, x, i);
+      continue;
+    }
+    if (i < k) {
+      B += bSat(l, x, i);
+      continue;
+    }
+    var lo = l.bands[i].start;
+    var hi = upperEdge(l, i);
+    var L = liquidityOf(l, x, i);
+    if (l.bands[i].curve === 1) {
+      // A constant-sum bin prices at the geometric mean; `s` only says how
+      // far through the bin the conversion has gone.
+      var K = L * delta(lo, hi);
+      var frac = (s.num * lo.den - lo.num * s.den) * hi.den;
+      var span = (hi.num * lo.den - lo.num * hi.den) * s.den;
+      var rb = K * frac / (span * (lo.den * hi.den));
+      A += (K - rb * (lo.den * hi.den)) / (lo.num * hi.num);
+      B += rb;
+    } else {
+      // a = L·(1/s − 1/hi), b = L·(s − lo), in exact rationals.
+      A += L * (s.den * hi.num - s.num * hi.den) / (s.num * hi.num);
+      B += L * (s.num * lo.den - lo.num * s.den) / (s.den * lo.den);
+    }
+  }
+  return {
+    A: A,
+    B: B
   };
-  var guard = 0;
-  while (fwd(input) < output && guard++ < 64) input += 1n;
-  while (input > 1n && fwd(input - 1n) >= output) input -= 1n;
-  var inputLpFee = input * feeNum / feeDen;
-  var inputReserve = isAInput ? aReserve : bReserve;
-  var nextInputReserve = inputReserve + input;
-  var nextOutputReserve = outputReserve - output;
-  var priceImpact = _fraction.Fraction.ZERO;
-  if (output > 0n) {
-    var idealPrice = isAInput ? new _fraction.Fraction(va0 * spaDen, vb0 * spbNum) : new _fraction.Fraction(vb0 * spbNum, va0 * spaDen);
-    var actualPrice = new _fraction.Fraction(input - inputLpFee, output);
-    priceImpact = _fraction.Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+};
+
+/** A fraction in lowest terms. */
+var reduceFrac = function reduceFrac(f) {
+  var _gcd = function gcd(a, b) {
+    return b === 0n ? a : _gcd(b, a % b);
+  };
+  var g = _gcd(f.num < 0n ? -f.num : f.num, f.den);
+  return g > 1n ? {
+    num: f.num / g,
+    den: f.den / g
+  } : f;
+};
+
+/**
+ * An equal-weight ladder of `n` bands from `lo` to `hi`, every band a CL
+ * arc at `fee` unless named in `curves`. The edges are built over a common
+ * denominator and reduced: every rational component of a concentrated-liquidity config
+ * must stay below 2^64 (spec V9).
+ */
+var uniformLadder = exports.uniformLadder = function uniformLadder(n, lo, hi, fee) {
+  var curves = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  if (n < 1) throw new Error("A ladder needs at least one band");
+  if (lo.num * hi.den >= hi.num * lo.den) throw new Error("The lower edge must be strictly below the upper edge");
+  var span = hi.num * lo.den - lo.num * hi.den;
+  var commonDen = lo.den * hi.den * BigInt(n);
+  var bands = [];
+  for (var i = 0; i < n; i++) {
+    var _curves$i;
+    bands.push({
+      start: reduceFrac({
+        num: lo.num * hi.den * BigInt(n) + span * BigInt(i),
+        den: commonDen
+      }),
+      weight: 1n,
+      curve: (_curves$i = curves[i]) !== null && _curves$i !== void 0 ? _curves$i : 0,
+      feeBuy: fee,
+      feeSell: fee
+    });
   }
   return {
-    input: input,
-    output: output,
-    lpFee: new _asset.AssetAmount(inputLpFee, inputMetadata),
-    nextInputReserve: nextInputReserve,
-    nextOutputReserve: nextOutputReserve,
-    priceImpact: priceImpact
+    bands: bands,
+    closing: reduceFrac({
+      num: lo.num * hi.den * BigInt(n) + span * BigInt(n),
+      den: commonDen
+    }),
+    weightTotal: BigInt(n)
   };
 };
 
+/** Band weight profiles. Every weight is at least 1, as `Create` demands. */
+
+var bandWeights = exports.bandWeights = function bandWeights(n) {
+  var _opts$peak, _opts$tail, _opts$centre;
+  var shape = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "concentrated";
+  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (shape === "flat") return Array.from({
+    length: n
+  }, function () {
+    return 1n;
+  });
+  var peak = Number((_opts$peak = opts.peak) !== null && _opts$peak !== void 0 ? _opts$peak : 64n);
+  var tail = Number((_opts$tail = opts.tail) !== null && _opts$tail !== void 0 ? _opts$tail : 1n);
+  var centre = (_opts$centre = opts.centre) !== null && _opts$centre !== void 0 ? _opts$centre : (n - 1) / 2;
+  var sigma = Math.max(n / 5, 0.75);
+  var bell = function bell(i, c) {
+    return Math.exp(-Math.pow((i - c) / sigma, 2));
+  };
+  var profile = function profile(i) {
+    switch (shape) {
+      case "concentrated":
+        return bell(i, centre);
+      case "skewed-low":
+        return Math.exp(-i / Math.max(n / 3, 1));
+      case "skewed-high":
+        return Math.exp(-(n - 1 - i) / Math.max(n / 3, 1));
+      case "bimodal":
+        return Math.max(bell(i, (n - 1) / 4), bell(i, 3 * (n - 1) / 4));
+      default:
+        return 1;
+    }
+  };
+  return Array.from({
+    length: n
+  }, function (_, i) {
+    var w = Math.round(tail + (peak - tail) * profile(i));
+    return BigInt(Math.max(1, w));
+  });
+};
+
 /**
- * Deposit LP estimate for a concentrated-liquidity pool. CL deposits reuse the
- * constant-product *proportional* pinning: minting by the scarcest offered
- * asset and ceil-pinning the reserve deltas gives, per asset,
- * `a1·L0 ≥ a0·L1` and `b1·L0 ≥ b0·L1` — and those two bounds multiply to
- * exactly the on-chain CL non-swap invariant `va1·vb1·L0² ≥ va0·vb0·L1²`
- * (`cl_check.ak`). So the proportional deposit is always chain-valid; excess of
- * either asset is refunded via aChange/bChange. This mirrors the scooper's
- * `resolve_cl_deposit` (which likewise reuses the CP pinning).
+ * A ladder of `n` bands from `lo` to `hi` with a weight shape, optional
+ * constant-sum bins and an optional per-band fee. The edges are
+ * `uniformLadder`'s exactly; only the weights, curves and fees differ.
  */
-var calculateLiquidity = exports.calculateLiquidity = function calculateLiquidity(a, b, aReserve, bReserve, totalLp) {
-  return ConstantProductPool.calculateLiquidity(a, b, aReserve, bReserve, totalLp);
+var shapedLadder = exports.shapedLadder = function shapedLadder(n, lo, hi, fee) {
+  var _opts$shape, _opts$csBands;
+  var opts = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  var base = uniformLadder(n, lo, hi, fee);
+  var weights = bandWeights(n, (_opts$shape = opts.shape) !== null && _opts$shape !== void 0 ? _opts$shape : "concentrated", opts);
+  var cs = new Set((_opts$csBands = opts.csBands) !== null && _opts$csBands !== void 0 ? _opts$csBands : []);
+  var bands = base.bands.map(function (b, i) {
+    var f = opts.feeAt ? opts.feeAt(i) : fee;
+    return _objectSpread(_objectSpread({}, b), {}, {
+      weight: weights[i],
+      curve: cs.has(i) ? 1 : 0,
+      feeBuy: f,
+      feeSell: f
+    });
+  });
+  return {
+    bands: bands,
+    closing: base.closing,
+    weightTotal: weights.reduce(function (s, w) {
+      return s + w;
+    }, 0n)
+  };
 };
 //# sourceMappingURL=ConcentratedLiquidityPool.js.map