@sundaeswap/math 0.2.2 → 0.4.0

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

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

package/dist/esm/PoolMath/ConcentratedLiquidityPool.js

@@ -0,0 +1,181 @@
+import { AssetAmount } from "@sundaeswap/asset";
+import { Fraction } from "@sundaeswap/fraction";
+import * as ConstantProductPool from "./ConstantProductPool.js";
+
+/**
+ * Holds the calculated outcome of a concentrated-liquidity swap. Mirrors
+ * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic
+ * swap-outcome consumers.
+ */
+
+/** 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:
+ *
+ *   VA = a·spbNum + L·spbDen
+ *   VB = b·spaDen + L·spaNum
+ *
+ * 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.
+ */
+
+const asFeeParts = fee => {
+  const f = Fraction.asFraction(fee);
+  if (f.lt(Fraction.ZERO) || f.gte(Fraction.ONE)) throw new Error("fee must be in [0, 1)");
+  return [BigInt(f.numerator), BigInt(f.denominator)];
+};
+
+/**
+ * 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.
+ */
+const rawSwapOutput = (dx, aReserve, bReserve, totalLp, spaNum, spaDen, spbNum, spbDen, feeNum, feeDen, isAInput) => {
+  const fee = dx * feeNum / feeDen;
+  const dxEff = dx - fee;
+  const va0 = aReserve * spbNum + totalLp * spbDen;
+  const vb0 = bReserve * spaDen + totalLp * spaNum;
+  if (isAInput) {
+    const dvaEff = dxEff * spbNum;
+    const denom = (va0 + dvaEff) * spaDen;
+    if (denom <= 0n) return 0n;
+    return vb0 * dvaEff / denom;
+  }
+  const dvbEff = dxEff * spaNum;
+  const denom = (vb0 + dvbEff) * spbNum;
+  if (denom <= 0n) return 0n;
+  return va0 * dvbEff / denom;
+};
+
+/**
+ * Calculate the swap outcome for a concentrated-liquidity pool.
+ *
+ * @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.
+ */
+export const 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");
+  const [spaNum, spaDen] = sqrtPriceA;
+  const [spbNum, spbDen] = sqrtPriceB;
+  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n) throw new Error("sqrt prices must be positive");
+  const [feeNum, feeDen] = asFeeParts(fee);
+  const inputReserve = isAInput ? aReserve : bReserve;
+  const outputReserve = isAInput ? bReserve : aReserve;
+  let 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;
+  const inputLpFee = input * feeNum / feeDen;
+  const nextInputReserve = inputReserve + input;
+  const 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.
+  const va0 = aReserve * spbNum + totalLp * spbDen;
+  const vb0 = bReserve * spaDen + totalLp * spaNum;
+  let priceImpact = Fraction.ZERO;
+  if (output > 0n) {
+    const idealPrice = isAInput ? new Fraction(va0 * spaDen, vb0 * spbNum) : new Fraction(vb0 * spbNum, va0 * spaDen);
+    const actualPrice = new Fraction(input - inputLpFee, output);
+    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  }
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(inputLpFee, inputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+/**
+ * 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`.
+ */
+export const 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");
+  const [spaNum, spaDen] = sqrtPriceA;
+  const [spbNum, spbDen] = sqrtPriceB;
+  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n) throw new Error("sqrt prices must be positive");
+  const outputReserve = isAInput ? bReserve : aReserve;
+  if (output > outputReserve) throw new Error("Output must not exceed the output reserve");
+  const [feeNum, feeDen] = asFeeParts(fee);
+  const feeDiff = feeDen - feeNum;
+  const va0 = aReserve * spbNum + totalLp * spbDen;
+  const vb0 = bReserve * spaDen + totalLp * spaNum;
+  const ceilDiv = (n, d) => (n + d - 1n) / d;
+
+  // Closed-form minimal effective input, then gross up for the fee floor.
+  let effMin;
+  if (isAInput) {
+    // dvaEff ≥ output·spaDen·va0 / (vb0 − output·spaDen)
+    const denom = vb0 - output * spaDen;
+    if (denom <= 0n) throw new Error("Output not reachable within the pool's range");
+    const dvaEffMin = ceilDiv(output * spaDen * va0, denom);
+    effMin = ceilDiv(dvaEffMin, spbNum);
+  } else {
+    const denom = va0 - output * spbNum;
+    if (denom <= 0n) throw new Error("Output not reachable within the pool's range");
+    const dvbEffMin = ceilDiv(output * spbNum * vb0, denom);
+    effMin = ceilDiv(dvbEffMin, spaNum);
+  }
+  let input = feeDiff > 0n ? ceilDiv(effMin * feeDen, feeDiff) : effMin;
+
+  // 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.
+  const fwd = dx => rawSwapOutput(dx, aReserve, bReserve, totalLp, spaNum, spaDen, spbNum, spbDen, feeNum, feeDen, isAInput);
+  let guard = 0;
+  while (fwd(input) < output && guard++ < 64) input += 1n;
+  while (input > 1n && fwd(input - 1n) >= output) input -= 1n;
+  const inputLpFee = input * feeNum / feeDen;
+  const inputReserve = isAInput ? aReserve : bReserve;
+  const nextInputReserve = inputReserve + input;
+  const nextOutputReserve = outputReserve - output;
+  let priceImpact = Fraction.ZERO;
+  if (output > 0n) {
+    const idealPrice = isAInput ? new Fraction(va0 * spaDen, vb0 * spbNum) : new Fraction(vb0 * spbNum, va0 * spaDen);
+    const actualPrice = new Fraction(input - inputLpFee, output);
+    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  }
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(inputLpFee, inputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+/**
+ * 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).
+ */
+export const calculateLiquidity = (a, b, aReserve, bReserve, totalLp) => ConstantProductPool.calculateLiquidity(a, b, aReserve, bReserve, totalLp);
+//# sourceMappingURL=ConcentratedLiquidityPool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConcentratedLiquidityPool.js","names":["AssetAmount","Fraction","ConstantProductPool","asFeeParts","fee","f","asFraction","lt","ZERO","gte","ONE","Error","BigInt","numerator","denominator","rawSwapOutput","dx","aReserve","bReserve","totalLp","spaNum","spaDen","spbNum","spbDen","feeNum","feeDen","isAInput","dxEff","va0","vb0","dvaEff","denom","dvbEff","getSwapOutput","inputMetadata","input","sqrtPriceA","sqrtPriceB","inputReserve","outputReserve","output","inputLpFee","nextInputReserve","nextOutputReserve","priceImpact","idealPrice","actualPrice","subtract","divide","lpFee","getSwapInput","feeDiff","ceilDiv","n","d","effMin","dvaEffMin","dvbEffMin","fwd","guard","calculateLiquidity","a","b"],"sources":["../../../src/PoolMath/ConcentratedLiquidityPool.ts"],"sourcesContent":["import { AssetAmount, IAssetAmountMetadata } from \"@sundaeswap/asset\";\nimport { Fraction, type TFractionLike } from \"@sundaeswap/fraction\";\n\nimport * as ConstantProductPool from \"./ConstantProductPool.js\";\n\n/**\n * Holds the calculated outcome of a concentrated-liquidity swap. Mirrors\n * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic\n * swap-outcome consumers.\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/** A sqrt-price bound from the CL config, as an exact rational `[num, den]`. */\nexport type TSqrtPrice = [bigint, bigint];\n\n/**\n * Concentrated liquidity is Sundae v4's single-range invariant. Unlike Uniswap\n * v3 there are no per-position ranges or ticks: the whole pool shares ONE\n * immutable price range `[sqrtPriceA, sqrtPriceB]` (a < b) set at creation, and\n * LP is a single fungible token. Swaps run on *virtual* reserves that fold the\n * pool's liquidity `L` (its total LP supply) into each side:\n *\n *   VA = a·spbNum + L·spbDen\n *   VB = b·spaDen + L·spaNum\n *\n * where `a`/`b` are the raw assetA/assetB reserves. This is a direct port of the\n * scooper's `cl_swap_result` (scooper-v2/src/sundaev4/swap_math.rs) and the\n * on-chain `cl_check_swap` (sundae-v4/lib/modules/cl_check.ak) — those are the\n * source of truth; keep this in lockstep with them.\n */\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/**\n * The raw forward swap: given a pre-fee input `dx`, return the output amount.\n * A→B and B→A use different virtual-reserve scalings (see `cl_check_swap`).\n * All quantities are non-negative so integer division floors, matching chain.\n */\nconst rawSwapOutput = (\n  dx: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n  spaNum: bigint,\n  spaDen: bigint,\n  spbNum: bigint,\n  spbDen: bigint,\n  feeNum: bigint,\n  feeDen: bigint,\n  isAInput: boolean,\n): bigint => {\n  const fee = (dx * feeNum) / feeDen;\n  const dxEff = dx - fee;\n  const va0 = aReserve * spbNum + totalLp * spbDen;\n  const vb0 = bReserve * spaDen + totalLp * spaNum;\n  if (isAInput) {\n    const dvaEff = dxEff * spbNum;\n    const denom = (va0 + dvaEff) * spaDen;\n    if (denom <= 0n) return 0n;\n    return (vb0 * dvaEff) / denom;\n  }\n  const dvbEff = dxEff * spaNum;\n  const denom = (vb0 + dvbEff) * spbNum;\n  if (denom <= 0n) return 0n;\n  return (va0 * dvbEff) / denom;\n};\n\n/**\n * Calculate the swap outcome for a concentrated-liquidity pool.\n *\n * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.\n * @param input The pre-fee amount of the input asset being swapped.\n * @param aReserve The pool's raw reserve of asset A.\n * @param bReserve The pool's raw reserve of asset B.\n * @param totalLp The pool's total LP supply (the virtual liquidity `L`).\n * @param sqrtPriceA The lower sqrt-price bound `[num, den]` from the CL config.\n * @param sqrtPriceB The upper sqrt-price bound `[num, den]` from the CL config.\n * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.\n * @param isAInput True when asset A is the supplied asset (A→B swap).\n * @returns The swap details in the shared {@link TSwapOutcome} shape.\n */\nexport const getSwapOutput = (\n  inputMetadata: IAssetAmountMetadata,\n  input: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n  sqrtPriceA: TSqrtPrice,\n  sqrtPriceB: TSqrtPrice,\n  fee: TFractionLike,\n  isAInput: boolean,\n): TSwapOutcome => {\n  if (input <= 0n || aReserve <= 0n || bReserve <= 0n || totalLp <= 0n)\n    throw new Error(\"Input, reserves and liquidity must be positive\");\n  const [spaNum, spaDen] = sqrtPriceA;\n  const [spbNum, spbDen] = sqrtPriceB;\n  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n)\n    throw new Error(\"sqrt prices must be positive\");\n  const [feeNum, feeDen] = asFeeParts(fee);\n\n  const inputReserve = isAInput ? aReserve : bReserve;\n  const outputReserve = isAInput ? bReserve : aReserve;\n\n  let output = rawSwapOutput(\n    input,\n    aReserve,\n    bReserve,\n    totalLp,\n    spaNum,\n    spaDen,\n    spbNum,\n    spbDen,\n    feeNum,\n    feeDen,\n    isAInput,\n  );\n  // Can't take more than the pool actually holds (virtual reserves can\n  // otherwise let the formula exceed the real reserve near the boundary).\n  if (output > outputReserve) output = outputReserve;\n\n  const inputLpFee = (input * feeNum) / feeDen;\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  // Price impact vs the marginal (dx→0) rate. Marginal output-per-effective-\n  // input is vb0·spbNum/(va0·spaDen) for A→B (symmetric for B→A), so the ideal\n  // input-per-output is its reciprocal. Display-only.\n  const va0 = aReserve * spbNum + totalLp * spbDen;\n  const vb0 = bReserve * spaDen + totalLp * spaNum;\n  let priceImpact = Fraction.ZERO;\n  if (output > 0n) {\n    const idealPrice = isAInput\n      ? new Fraction(va0 * spaDen, vb0 * spbNum)\n      : new Fraction(vb0 * spbNum, va0 * spaDen);\n    const actualPrice = new Fraction(input - inputLpFee, output);\n    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n  }\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(inputLpFee, inputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n/**\n * Calculate the minimal input required to receive a given output — the inverse\n * of {@link getSwapOutput}. The forward swap is linear-fractional in the\n * effective input, so it inverts in closed form; a short correction loop\n * absorbs the fee floor and integer rounding so the result is the exact minimal\n * input whose forward swap yields at least `output`.\n */\nexport const getSwapInput = (\n  inputMetadata: IAssetAmountMetadata,\n  output: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n  sqrtPriceA: TSqrtPrice,\n  sqrtPriceB: TSqrtPrice,\n  fee: TFractionLike,\n  isAInput: boolean,\n): TSwapOutcome => {\n  if (output <= 0n || aReserve <= 0n || bReserve <= 0n || totalLp <= 0n)\n    throw new Error(\"Output, reserves and liquidity must be positive\");\n  const [spaNum, spaDen] = sqrtPriceA;\n  const [spbNum, spbDen] = sqrtPriceB;\n  if (spaNum <= 0n || spaDen <= 0n || spbNum <= 0n || spbDen <= 0n)\n    throw new Error(\"sqrt prices must be positive\");\n  const outputReserve = isAInput ? bReserve : aReserve;\n  if (output > outputReserve)\n    throw new Error(\"Output must not exceed the output reserve\");\n\n  const [feeNum, feeDen] = asFeeParts(fee);\n  const feeDiff = feeDen - feeNum;\n\n  const va0 = aReserve * spbNum + totalLp * spbDen;\n  const vb0 = bReserve * spaDen + totalLp * spaNum;\n\n  const ceilDiv = (n: bigint, d: bigint) => (n + d - 1n) / d;\n\n  // Closed-form minimal effective input, then gross up for the fee floor.\n  let effMin: bigint;\n  if (isAInput) {\n    // dvaEff ≥ output·spaDen·va0 / (vb0 − output·spaDen)\n    const denom = vb0 - output * spaDen;\n    if (denom <= 0n)\n      throw new Error(\"Output not reachable within the pool's range\");\n    const dvaEffMin = ceilDiv(output * spaDen * va0, denom);\n    effMin = ceilDiv(dvaEffMin, spbNum);\n  } else {\n    const denom = va0 - output * spbNum;\n    if (denom <= 0n)\n      throw new Error(\"Output not reachable within the pool's range\");\n    const dvbEffMin = ceilDiv(output * spbNum * vb0, denom);\n    effMin = ceilDiv(dvbEffMin, spaNum);\n  }\n  let input = feeDiff > 0n ? ceilDiv(effMin * feeDen, feeDiff) : effMin;\n\n  // Correct for floor interactions: nudge up until the forward swap clears the\n  // target, then trim any over-shoot. Bounded — a couple of iterations at most.\n  const fwd = (dx: bigint) =>\n    rawSwapOutput(\n      dx,\n      aReserve,\n      bReserve,\n      totalLp,\n      spaNum,\n      spaDen,\n      spbNum,\n      spbDen,\n      feeNum,\n      feeDen,\n      isAInput,\n    );\n  let guard = 0;\n  while (fwd(input) < output && guard++ < 64) input += 1n;\n  while (input > 1n && fwd(input - 1n) >= output) input -= 1n;\n\n  const inputLpFee = (input * feeNum) / feeDen;\n  const inputReserve = isAInput ? aReserve : bReserve;\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  let priceImpact = Fraction.ZERO;\n  if (output > 0n) {\n    const idealPrice = isAInput\n      ? new Fraction(va0 * spaDen, vb0 * spbNum)\n      : new Fraction(vb0 * spbNum, va0 * spaDen);\n    const actualPrice = new Fraction(input - inputLpFee, output);\n    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n  }\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(inputLpFee, inputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n/**\n * Deposit LP estimate for a concentrated-liquidity pool. CL deposits reuse the\n * constant-product *proportional* pinning: minting by the scarcest offered\n * asset and ceil-pinning the reserve deltas gives, per asset,\n * `a1·L0 ≥ a0·L1` and `b1·L0 ≥ b0·L1` — and those two bounds multiply to\n * exactly the on-chain CL non-swap invariant `va1·vb1·L0² ≥ va0·vb0·L1²`\n * (`cl_check.ak`). So the proportional deposit is always chain-valid; excess of\n * either asset is refunded via aChange/bChange. This mirrors the scooper's\n * `resolve_cl_deposit` (which likewise reuses the CP pinning).\n */\nexport const calculateLiquidity = (\n  a: bigint,\n  b: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n) => ConstantProductPool.calculateLiquidity(a, b, aReserve, bReserve, totalLp);\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/PoolMath/ConstantSumPool.js

@@ -0,0 +1,266 @@
+import { AssetAmount } from "@sundaeswap/asset";
+import { Fraction } from "@sundaeswap/fraction";
+import { SharedPoolMath } from "./index.js";
+
+/**
+ * Holds the calculated outcome of a constant-sum swap. Mirrors
+ * {@link ConstantProductPool.TSwapOutcome} so both can flow through the same
+ * generic swap-outcome consumers.
+ */
+
+/**
+ * Calculate the swap outcome for a constant-sum (fixed-price) pool — the
+ * invariant used by Sundae v4 stable/pegged pools. Unlike constant product,
+ * the exchange rate is fixed by the pool's per-asset `prices`: the input is
+ * converted to "value" at `priceIn`, the fee is taken off that value, and the
+ * remainder is converted to the output asset at `priceOut`. The result is
+ * capped at the output reserve (you can't take more than the pool holds).
+ *
+ * Matches the scooper's `cs_swap_result`:
+ *   output = floor((input·priceIn − floor(input·priceIn·fee)) / priceOut)
+ *
+ * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.
+ * @param input The amount of the input asset being swapped.
+ * @param inputReserve The pool's reserve of the input asset.
+ * @param outputReserve The pool's reserve of the output asset.
+ * @param priceIn The pool's price for the input asset (from the constant-sum config).
+ * @param priceOut The pool's price for the output asset.
+ * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.
+ * @param roundOutputUp When true, round the output up instead of flooring.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export const getSwapOutput = (inputMetadata, input, inputReserve, outputReserve, priceIn, priceOut, fee, roundOutputUp) => {
+  if (input <= 0n || inputReserve <= 0n || outputReserve <= 0n) throw new Error("Input and reserves must be positive");
+  if (priceIn <= 0n || priceOut <= 0n) throw new Error("Prices must be positive");
+  const feeFraction = Fraction.asFraction(fee);
+  if (feeFraction.lt(Fraction.ZERO) || feeFraction.gt(Fraction.ONE)) throw new Error("fee must be between 0 and 1");
+  const inputValue = input * priceIn;
+  const feeValue = new Fraction(inputValue * BigInt(feeFraction.numerator), BigInt(feeFraction.denominator)).quotient;
+  const outputValue = inputValue - feeValue;
+  let output = roundOutputUp ? (outputValue + priceOut - 1n) / priceOut : outputValue / priceOut;
+
+  // Can't take more than the pool holds.
+  if (output > outputReserve) {
+    output = outputReserve;
+  }
+
+  // LP fee expressed in input-asset units (value scales linearly with input,
+  // so the input-denominated fee is input·feeRate) — matching ConstantProductPool.
+  const inputLpFee = new Fraction(input * BigInt(feeFraction.numerator), BigInt(feeFraction.denominator)).quotient;
+  const nextInputReserve = inputReserve + input;
+  const nextOutputReserve = outputReserve - output;
+
+  // Price impact vs the pool's par price (priceOut/priceIn input-per-output);
+  // ~0 for a constant-sum pool aside from the fee. See ConstantProductPool.
+  let priceImpact = Fraction.ZERO;
+  if (output > 0n) {
+    const amountInLessFee = input - inputLpFee;
+    const idealPrice = new Fraction(priceOut, priceIn);
+    const actualPrice = new Fraction(amountInLessFee, output);
+    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  }
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(inputLpFee, inputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+/**
+ * Calculate the minimal input required to receive a given output from a
+ * constant-sum pool — the exact inverse of {@link getSwapOutput}.
+ *
+ * The forward math floors the fee off the input value, which makes the
+ * post-fee value `ceil(input·priceIn·(1−fee))`; inverting that ceiling gives
+ * the smallest input whose forward swap yields at least `output`.
+ *
+ * Unlike constant product there is no asymptote, so an output equal to the
+ * full output reserve is attainable (the pool can be drained at par).
+ *
+ * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.
+ * @param output The desired amount of the output asset.
+ * @param inputReserve The pool's reserve of the input asset.
+ * @param outputReserve The pool's reserve of the output asset.
+ * @param priceIn The pool's price for the input asset (from the constant-sum config).
+ * @param priceOut The pool's price for the output asset.
+ * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export const getSwapInput = (inputMetadata, output, inputReserve, outputReserve, priceIn, priceOut, fee) => {
+  if (output <= 0n || inputReserve <= 0n || outputReserve <= 0n) throw new Error("Output and reserves must be positive");
+  if (priceIn <= 0n || priceOut <= 0n) throw new Error("Prices must be positive");
+  if (output > outputReserve) throw new Error("Output must not exceed the output reserve");
+  const feeFraction = Fraction.asFraction(fee);
+  if (feeFraction.lt(Fraction.ZERO) || feeFraction.gte(Fraction.ONE)) throw new Error("fee must be [0,1)");
+  const feeNum = BigInt(feeFraction.numerator);
+  const feeDen = BigInt(feeFraction.denominator);
+  const feeDiff = feeDen - feeNum;
+
+  // Forward: outputValue = ceil(input·priceIn·feeDiff/feeDen), and the swap
+  // yields ≥ output iff outputValue ≥ output·priceOut. ceil(x/d) ≥ T for
+  // integer x iff x ≥ d·(T−1)+1, so the minimal input is the ceiling of
+  // (feeDen·(output·priceOut − 1) + 1) / (feeDiff·priceIn).
+  const targetValue = output * priceOut;
+  const numerator = feeDen * (targetValue - 1n) + 1n;
+  const denominator = feeDiff * priceIn;
+  const input = (numerator + denominator - 1n) / denominator;
+  const inputLpFee = new Fraction(input * feeNum, feeDen).quotient;
+  const nextInputReserve = inputReserve + input;
+  const nextOutputReserve = outputReserve - output;
+
+  // Same par-price impact definition as getSwapOutput.
+  const amountInLessFee = input - inputLpFee;
+  const idealPrice = new Fraction(priceOut, priceIn);
+  const actualPrice = new Fraction(amountInLessFee, output);
+  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));
+  return {
+    input,
+    output,
+    lpFee: new AssetAmount(inputLpFee, inputMetadata),
+    nextInputReserve,
+    nextOutputReserve,
+    priceImpact
+  };
+};
+
+/**
+ * Calculate the deposit parameters for a 2-asset constant-sum pool via the
+ * TARGET-PINNED rule the deployed validator enforces (see
+ * {@link calculatePinnedDeposit}): the mint is capped by the scarcest offered
+ * asset, both assets must be offered, and anything above the pinned deltas is
+ * refunded via aChange/bChange.
+ *
+ * @param {bigint} a - The amount of token A to deposit.
+ * @param {bigint} b - The amount of token B to deposit.
+ * @param {bigint} aReserve - The current reserve of token A in the pool.
+ * @param {bigint} bReserve - The current reserve of token B in the pool.
+ * @param {bigint} totalLp - The total lp tokens for the pool before the deposit.
+ * @param {bigint} priceA - The pool's price for token A (from the constant-sum config).
+ * @param {bigint} priceB - The pool's price for token B.
+ * @throws {Error} If the pool has no value or minted lp.
+ * @throws {Error} If both deposit amounts are zero, or either is negative.
+ * @throws {Error} If either price is non-positive.
+ */
+export const calculateLiquidity = (a, b, aReserve, bReserve, totalLp, priceA, priceB) => {
+  // Target-pinned (what the deployed validator accepts): mint by the
+  // scarcest offered asset; anything above the pinned deltas is refunded
+  // (aChange/bChange).
+  const {
+    deltas,
+    generatedLp,
+    nextTotalLp,
+    shareAfterDeposit
+  } = calculatePinnedDeposit([a, b], [aReserve, bReserve], [priceA, priceB], totalLp);
+  return {
+    nextTotalLp,
+    generatedLp,
+    shareAfterDeposit,
+    aChange: a - deltas[0],
+    bChange: b - deltas[1],
+    actualDepositedA: deltas[0],
+    actualDepositedB: deltas[1]
+  };
+};
+
+/**
+ * The N-asset form of {@link calculateLiquidity}, mirroring the v4 contract's
+ * `compute_deposit_n` exactly: a deposit of any mix of the pool's assets is
+ * valued at the fixed prices against the value of ALL reserves —
+ *
+ *   generatedLp = Σ(amount_i·price_i) · totalLp / Σ(reserve_i·price_i)
+ *
+ * The three arrays must be aligned to the pool's canonical asset order (the
+ * API's `assets`/`quantities`/`prices`). Estimating an N-asset pool's deposit
+ * from just two of its reserves overstates the minted LP — the denominator is
+ * the whole pool's value — which is exactly the mistake this exists to
+ * prevent.
+ */
+/**
+ * The target-pinned deposit — what the deployed CS validator (cs_check tag 6)
+ * actually accepts, and what the scooper builds. Asymmetric deposits are
+ * disallowed on-chain: the fill declares a value delta `t` and every asset's
+ * contribution is ceil-pinned to `ceil(r_i·t/V_b)`, with total LP
+ * floor-pinned to `floor(lp_b·(V_b+t)/V_b)`. Given what the user offers, the
+ * largest fillable t is capped by the SCARCEST asset —
+ * `t = min_i floor(offered_i·V_b/r_i)` — and anything above the pinned
+ * deltas is returned as surplus. Every pool asset must be offered (> 0) or
+ * t is zero and the deposit can never fill.
+ *
+ * Contrast with `calculateDepositN`, which is the plain value formula:
+ * it matches the pin only for exactly proportional offers and OVERSTATES the
+ * mint otherwise — using it for `minReceived` makes non-proportional orders
+ * unfillable.
+ */
+export const calculatePinnedDeposit = (offered, reserves, prices, totalLp) => {
+  if (offered.length !== reserves.length || reserves.length !== prices.length) throw new Error("offered, reserves and prices must be aligned");
+  if (prices.some(p => p <= 0n)) throw new Error("Prices must be positive");
+  if (totalLp <= 0n) throw new Error("Not enough pool liquidity");
+  let vB = 0n;
+  for (let i = 0; i < reserves.length; i++) {
+    vB += reserves[i] * prices[i];
+  }
+  if (vB <= 0n) throw new Error("Pool value is zero");
+  let t;
+  for (let i = 0; i < offered.length; i++) {
+    if (reserves[i] === 0n) continue;
+    const cap = offered[i] * vB / reserves[i];
+    t = t === undefined || cap < t ? cap : t;
+  }
+  if (t === undefined || t <= 0n) {
+    throw new Error("A constant-sum deposit must offer every pool asset in proportion (asymmetric deposits are disallowed on-chain)");
+  }
+  const deltas = reserves.map(r => (r * t + vB - 1n) / vB); // ceil
+  const nextTotalLp = totalLp * (vB + t) / vB; // floor
+  const generatedLp = nextTotalLp - totalLp;
+  if (generatedLp <= 0n) throw new Error("Deposit mints zero LP");
+  return {
+    targetDeltaV: t,
+    deltas,
+    generatedLp,
+    nextTotalLp,
+    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp)
+  };
+};
+
+/**
+ * The per-asset amounts a pinned deposit needs when the user anchors on one
+ * asset's amount: t from the anchor (`floor(anchor·V_b/r_anchor)`), every
+ * delta ceil-pinned to it. Drives proportional auto-fill in deposit forms.
+ */
+export const pinnedDepositFromAnchor = (anchorIndex, anchorAmount, reserves, prices) => {
+  if (reserves.length !== prices.length) throw new Error("reserves and prices must be aligned");
+  if (anchorIndex < 0 || anchorIndex >= reserves.length || reserves[anchorIndex] <= 0n) throw new Error("anchor asset has no reserve");
+  if (anchorAmount <= 0n) return reserves.map(() => 0n);
+  let vB = 0n;
+  for (let i = 0; i < reserves.length; i++) {
+    vB += reserves[i] * prices[i];
+  }
+  if (vB <= 0n) throw new Error("Pool value is zero");
+  const t = anchorAmount * vB / reserves[anchorIndex];
+  return reserves.map((r, i) => i === anchorIndex ? anchorAmount : (r * t + vB - 1n) / vB);
+};
+export const calculateDepositN = (amounts, reserves, prices, totalLp) => {
+  if (amounts.length !== reserves.length || reserves.length !== prices.length) throw new Error("amounts, reserves and prices must be aligned");
+  if (prices.some(p => p <= 0n)) throw new Error("Prices must be positive");
+  // Zeros in a MIX are fine — offering a subset is the point of the N-asset
+  // form. What's rejected is a negative amount, or offering nothing at all.
+  if (amounts.some(a => a < 0n) || amounts.every(a => a === 0n)) throw new Error("Deposit amounts must be non-negative, with at least one positive");
+  let totalValue = 0n;
+  let depositValue = 0n;
+  for (let i = 0; i < amounts.length; i++) {
+    totalValue += reserves[i] * prices[i];
+    depositValue += amounts[i] * prices[i];
+  }
+  if (totalValue <= 0n || totalLp <= 0n) throw new Error("Not enough pool liquidity");
+  const generatedLp = depositValue * totalLp / totalValue;
+  const nextTotalLp = totalLp + generatedLp;
+  return {
+    nextTotalLp,
+    generatedLp,
+    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp)
+  };
+};
+//# sourceMappingURL=ConstantSumPool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConstantSumPool.js","names":["AssetAmount","Fraction","SharedPoolMath","getSwapOutput","inputMetadata","input","inputReserve","outputReserve","priceIn","priceOut","fee","roundOutputUp","Error","feeFraction","asFraction","lt","ZERO","gt","ONE","inputValue","feeValue","BigInt","numerator","denominator","quotient","outputValue","output","inputLpFee","nextInputReserve","nextOutputReserve","priceImpact","amountInLessFee","idealPrice","actualPrice","subtract","divide","lpFee","getSwapInput","gte","feeNum","feeDen","feeDiff","targetValue","calculateLiquidity","a","b","aReserve","bReserve","totalLp","priceA","priceB","deltas","generatedLp","nextTotalLp","shareAfterDeposit","calculatePinnedDeposit","aChange","bChange","actualDepositedA","actualDepositedB","offered","reserves","prices","length","some","p","vB","i","t","cap","undefined","map","r","targetDeltaV","getShare","pinnedDepositFromAnchor","anchorIndex","anchorAmount","calculateDepositN","amounts","every","totalValue","depositValue"],"sources":["../../../src/PoolMath/ConstantSumPool.ts"],"sourcesContent":["import { AssetAmount, IAssetAmountMetadata } from \"@sundaeswap/asset\";\nimport { Fraction, type TFractionLike } from \"@sundaeswap/fraction\";\nimport { SharedPoolMath } from \"./index.js\";\n\n/**\n * Holds the calculated outcome of a constant-sum swap. Mirrors\n * {@link ConstantProductPool.TSwapOutcome} so both can flow through the same\n * generic swap-outcome consumers.\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/**\n * Calculate the swap outcome for a constant-sum (fixed-price) pool — the\n * invariant used by Sundae v4 stable/pegged pools. Unlike constant product,\n * the exchange rate is fixed by the pool's per-asset `prices`: the input is\n * converted to \"value\" at `priceIn`, the fee is taken off that value, and the\n * remainder is converted to the output asset at `priceOut`. The result is\n * capped at the output reserve (you can't take more than the pool holds).\n *\n * Matches the scooper's `cs_swap_result`:\n *   output = floor((input·priceIn − floor(input·priceIn·fee)) / priceOut)\n *\n * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.\n * @param input The amount of the input asset being swapped.\n * @param inputReserve The pool's reserve of the input asset.\n * @param outputReserve The pool's reserve of the output asset.\n * @param priceIn The pool's price for the input asset (from the constant-sum config).\n * @param priceOut The pool's price for the output asset.\n * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.\n * @param roundOutputUp When true, round the output up instead of flooring.\n * @returns The swap details in the shared {@link TSwapOutcome} shape.\n */\nexport const getSwapOutput = (\n  inputMetadata: IAssetAmountMetadata,\n  input: bigint,\n  inputReserve: bigint,\n  outputReserve: bigint,\n  priceIn: bigint,\n  priceOut: bigint,\n  fee: TFractionLike,\n  roundOutputUp?: boolean,\n): TSwapOutcome => {\n  if (input <= 0n || inputReserve <= 0n || outputReserve <= 0n)\n    throw new Error(\"Input and reserves must be positive\");\n  if (priceIn <= 0n || priceOut <= 0n)\n    throw new Error(\"Prices must be positive\");\n\n  const feeFraction = Fraction.asFraction(fee);\n  if (feeFraction.lt(Fraction.ZERO) || feeFraction.gt(Fraction.ONE))\n    throw new Error(\"fee must be between 0 and 1\");\n\n  const inputValue = input * priceIn;\n  const feeValue = new Fraction(\n    inputValue * BigInt(feeFraction.numerator),\n    BigInt(feeFraction.denominator),\n  ).quotient;\n  const outputValue = inputValue - feeValue;\n\n  let output = roundOutputUp\n    ? (outputValue + priceOut - 1n) / priceOut\n    : outputValue / priceOut;\n\n  // Can't take more than the pool holds.\n  if (output > outputReserve) {\n    output = outputReserve;\n  }\n\n  // LP fee expressed in input-asset units (value scales linearly with input,\n  // so the input-denominated fee is input·feeRate) — matching ConstantProductPool.\n  const inputLpFee = new Fraction(\n    input * BigInt(feeFraction.numerator),\n    BigInt(feeFraction.denominator),\n  ).quotient;\n\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  // Price impact vs the pool's par price (priceOut/priceIn input-per-output);\n  // ~0 for a constant-sum pool aside from the fee. See ConstantProductPool.\n  let priceImpact = Fraction.ZERO;\n  if (output > 0n) {\n    const amountInLessFee = input - inputLpFee;\n    const idealPrice = new Fraction(priceOut, priceIn);\n    const actualPrice = new Fraction(amountInLessFee, output);\n    priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n  }\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(inputLpFee, inputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n/**\n * Calculate the minimal input required to receive a given output from a\n * constant-sum pool — the exact inverse of {@link getSwapOutput}.\n *\n * The forward math floors the fee off the input value, which makes the\n * post-fee value `ceil(input·priceIn·(1−fee))`; inverting that ceiling gives\n * the smallest input whose forward swap yields at least `output`.\n *\n * Unlike constant product there is no asymptote, so an output equal to the\n * full output reserve is attainable (the pool can be drained at par).\n *\n * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.\n * @param output The desired amount of the output asset.\n * @param inputReserve The pool's reserve of the input asset.\n * @param outputReserve The pool's reserve of the output asset.\n * @param priceIn The pool's price for the input asset (from the constant-sum config).\n * @param priceOut The pool's price for the output asset.\n * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.\n * @returns The swap details in the shared {@link TSwapOutcome} shape.\n */\nexport const getSwapInput = (\n  inputMetadata: IAssetAmountMetadata,\n  output: bigint,\n  inputReserve: bigint,\n  outputReserve: bigint,\n  priceIn: bigint,\n  priceOut: 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 (priceIn <= 0n || priceOut <= 0n)\n    throw new Error(\"Prices must be positive\");\n  if (output > outputReserve)\n    throw new Error(\"Output must not exceed the output reserve\");\n\n  const feeFraction = Fraction.asFraction(fee);\n  if (feeFraction.lt(Fraction.ZERO) || feeFraction.gte(Fraction.ONE))\n    throw new Error(\"fee must be [0,1)\");\n\n  const feeNum = BigInt(feeFraction.numerator);\n  const feeDen = BigInt(feeFraction.denominator);\n  const feeDiff = feeDen - feeNum;\n\n  // Forward: outputValue = ceil(input·priceIn·feeDiff/feeDen), and the swap\n  // yields ≥ output iff outputValue ≥ output·priceOut. ceil(x/d) ≥ T for\n  // integer x iff x ≥ d·(T−1)+1, so the minimal input is the ceiling of\n  // (feeDen·(output·priceOut − 1) + 1) / (feeDiff·priceIn).\n  const targetValue = output * priceOut;\n  const numerator = feeDen * (targetValue - 1n) + 1n;\n  const denominator = feeDiff * priceIn;\n  const input = (numerator + denominator - 1n) / denominator;\n\n  const inputLpFee = new Fraction(input * feeNum, feeDen).quotient;\n  const nextInputReserve = inputReserve + input;\n  const nextOutputReserve = outputReserve - output;\n\n  // Same par-price impact definition as getSwapOutput.\n  const amountInLessFee = input - inputLpFee;\n  const idealPrice = new Fraction(priceOut, priceIn);\n  const actualPrice = new Fraction(amountInLessFee, output);\n  const priceImpact = Fraction.ONE.subtract(idealPrice.divide(actualPrice));\n\n  return {\n    input,\n    output,\n    lpFee: new AssetAmount(inputLpFee, inputMetadata),\n    nextInputReserve,\n    nextOutputReserve,\n    priceImpact,\n  };\n};\n\n/**\n * Calculate the deposit parameters for a 2-asset constant-sum pool via the\n * TARGET-PINNED rule the deployed validator enforces (see\n * {@link calculatePinnedDeposit}): the mint is capped by the scarcest offered\n * asset, both assets must be offered, and anything above the pinned deltas is\n * refunded via aChange/bChange.\n *\n * @param {bigint} a - The amount of token A to deposit.\n * @param {bigint} b - The amount of token B to deposit.\n * @param {bigint} aReserve - The current reserve of token A in the pool.\n * @param {bigint} bReserve - The current reserve of token B in the pool.\n * @param {bigint} totalLp - The total lp tokens for the pool before the deposit.\n * @param {bigint} priceA - The pool's price for token A (from the constant-sum config).\n * @param {bigint} priceB - The pool's price for token B.\n * @throws {Error} If the pool has no value or minted lp.\n * @throws {Error} If both deposit amounts are zero, or either is negative.\n * @throws {Error} If either price is non-positive.\n */\nexport const calculateLiquidity = (\n  a: bigint,\n  b: bigint,\n  aReserve: bigint,\n  bReserve: bigint,\n  totalLp: bigint,\n  priceA: bigint,\n  priceB: bigint,\n) => {\n  // Target-pinned (what the deployed validator accepts): mint by the\n  // scarcest offered asset; anything above the pinned deltas is refunded\n  // (aChange/bChange).\n  const { deltas, generatedLp, nextTotalLp, shareAfterDeposit } =\n    calculatePinnedDeposit(\n      [a, b],\n      [aReserve, bReserve],\n      [priceA, priceB],\n      totalLp,\n    );\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 N-asset form of {@link calculateLiquidity}, mirroring the v4 contract's\n * `compute_deposit_n` exactly: a deposit of any mix of the pool's assets is\n * valued at the fixed prices against the value of ALL reserves —\n *\n *   generatedLp = Σ(amount_i·price_i) · totalLp / Σ(reserve_i·price_i)\n *\n * The three arrays must be aligned to the pool's canonical asset order (the\n * API's `assets`/`quantities`/`prices`). Estimating an N-asset pool's deposit\n * from just two of its reserves overstates the minted LP — the denominator is\n * the whole pool's value — which is exactly the mistake this exists to\n * prevent.\n */\n/**\n * The target-pinned deposit — what the deployed CS validator (cs_check tag 6)\n * actually accepts, and what the scooper builds. Asymmetric deposits are\n * disallowed on-chain: the fill declares a value delta `t` and every asset's\n * contribution is ceil-pinned to `ceil(r_i·t/V_b)`, with total LP\n * floor-pinned to `floor(lp_b·(V_b+t)/V_b)`. Given what the user offers, the\n * largest fillable t is capped by the SCARCEST asset —\n * `t = min_i floor(offered_i·V_b/r_i)` — and anything above the pinned\n * deltas is returned as surplus. Every pool asset must be offered (> 0) or\n * t is zero and the deposit can never fill.\n *\n * Contrast with `calculateDepositN`, which is the plain value formula:\n * it matches the pin only for exactly proportional offers and OVERSTATES the\n * mint otherwise — using it for `minReceived` makes non-proportional orders\n * unfillable.\n */\nexport const calculatePinnedDeposit = (\n  offered: bigint[],\n  reserves: bigint[],\n  prices: bigint[],\n  totalLp: bigint,\n): {\n  targetDeltaV: bigint;\n  deltas: bigint[];\n  generatedLp: bigint;\n  nextTotalLp: bigint;\n  shareAfterDeposit: Fraction;\n} => {\n  if (offered.length !== reserves.length || reserves.length !== prices.length)\n    throw new Error(\"offered, reserves and prices must be aligned\");\n  if (prices.some((p) => p <= 0n)) throw new Error(\"Prices must be positive\");\n  if (totalLp <= 0n) throw new Error(\"Not enough pool liquidity\");\n\n  let vB = 0n;\n  for (let i = 0; i < reserves.length; i++) {\n    vB += reserves[i] * prices[i];\n  }\n  if (vB <= 0n) throw new Error(\"Pool value is zero\");\n\n  let t: bigint | undefined;\n  for (let i = 0; i < offered.length; i++) {\n    if (reserves[i] === 0n) continue;\n    const cap = (offered[i] * vB) / reserves[i];\n    t = t === undefined || cap < t ? cap : t;\n  }\n  if (t === undefined || t <= 0n) {\n    throw new Error(\n      \"A constant-sum deposit must offer every pool asset in proportion (asymmetric deposits are disallowed on-chain)\",\n    );\n  }\n\n  const deltas = reserves.map((r) => (r * t! + vB - 1n) / vB); // ceil\n  const nextTotalLp = (totalLp * (vB + t)) / vB; // floor\n  const generatedLp = nextTotalLp - totalLp;\n  if (generatedLp <= 0n) throw new Error(\"Deposit mints zero LP\");\n\n  return {\n    targetDeltaV: t,\n    deltas,\n    generatedLp,\n    nextTotalLp,\n    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp),\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·V_b/r_anchor)`), every\n * delta ceil-pinned to it. Drives proportional auto-fill in deposit forms.\n */\nexport const pinnedDepositFromAnchor = (\n  anchorIndex: number,\n  anchorAmount: bigint,\n  reserves: bigint[],\n  prices: bigint[],\n): bigint[] => {\n  if (reserves.length !== prices.length)\n    throw new Error(\"reserves and prices must be aligned\");\n  if (\n    anchorIndex < 0 ||\n    anchorIndex >= reserves.length ||\n    reserves[anchorIndex] <= 0n\n  )\n    throw new Error(\"anchor asset has no reserve\");\n  if (anchorAmount <= 0n) return reserves.map(() => 0n);\n\n  let vB = 0n;\n  for (let i = 0; i < reserves.length; i++) {\n    vB += reserves[i] * prices[i];\n  }\n  if (vB <= 0n) throw new Error(\"Pool value is zero\");\n\n  const t = (anchorAmount * vB) / reserves[anchorIndex];\n  return reserves.map((r, i) =>\n    i === anchorIndex ? anchorAmount : (r * t + vB - 1n) / vB,\n  );\n};\n\nexport const calculateDepositN = (\n  amounts: bigint[],\n  reserves: bigint[],\n  prices: bigint[],\n  totalLp: bigint,\n) => {\n  if (amounts.length !== reserves.length || reserves.length !== prices.length)\n    throw new Error(\"amounts, reserves and prices must be aligned\");\n  if (prices.some((p) => p <= 0n)) throw new Error(\"Prices must be positive\");\n  // Zeros in a MIX are fine — offering a subset is the point of the N-asset\n  // form. What's rejected is a negative amount, or offering nothing at all.\n  if (amounts.some((a) => a < 0n) || amounts.every((a) => a === 0n))\n    throw new Error(\n      \"Deposit amounts must be non-negative, with at least one positive\",\n    );\n\n  let totalValue = 0n;\n  let depositValue = 0n;\n  for (let i = 0; i < amounts.length; i++) {\n    totalValue += reserves[i] * prices[i];\n    depositValue += amounts[i] * prices[i];\n  }\n  if (totalValue <= 0n || totalLp <= 0n)\n    throw new Error(\"Not enough pool liquidity\");\n\n  const generatedLp = (depositValue * totalLp) / totalValue;\n  const nextTotalLp = totalLp + generatedLp;\n\n  return {\n    nextTotalLp,\n    generatedLp,\n    shareAfterDeposit: SharedPoolMath.getShare(generatedLp, nextTotalLp),\n  };\n};\n"],"mappings":"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","ignoreList":[]}