@sundaeswap/math 0.2.2 → 0.4.0

package/dist/types/PoolMath/ConcentratedLiquidityPool.d.ts

@@ -0,0 +1,60 @@
+import { AssetAmount, IAssetAmountMetadata } from "@sundaeswap/asset";
+import { Fraction, type TFractionLike } from "@sundaeswap/fraction";
+/**
+ * Holds the calculated outcome of a concentrated-liquidity swap. Mirrors
+ * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic
+ * swap-outcome consumers.
+ */
+export type TSwapOutcome = {
+    input: bigint;
+    output: bigint;
+    lpFee: AssetAmount<IAssetAmountMetadata>;
+    nextInputReserve: bigint;
+    nextOutputReserve: bigint;
+    priceImpact: Fraction;
+};
+/** A sqrt-price bound from the CL config, as an exact rational `[num, den]`. */
+export type TSqrtPrice = [bigint, bigint];
+/**
+ * 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 declare const getSwapOutput: (inputMetadata: IAssetAmountMetadata, input: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, sqrtPriceA: TSqrtPrice, sqrtPriceB: TSqrtPrice, fee: TFractionLike, isAInput: boolean) => TSwapOutcome;
+/**
+ * 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 declare const getSwapInput: (inputMetadata: IAssetAmountMetadata, output: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, sqrtPriceA: TSqrtPrice, sqrtPriceB: TSqrtPrice, fee: TFractionLike, isAInput: boolean) => TSwapOutcome;
+/**
+ * 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 declare const calculateLiquidity: (a: bigint, b: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint) => {
+    nextTotalLp: bigint;
+    generatedLp: bigint;
+    shareAfterDeposit: Fraction;
+    bChange: bigint;
+    aChange: bigint;
+    actualDepositedA: bigint;
+    actualDepositedB: bigint;
+};
+//# sourceMappingURL=ConcentratedLiquidityPool.d.ts.map

package/dist/types/PoolMath/ConcentratedLiquidityPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcentratedLiquidityPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/ConcentratedLiquidityPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAIpE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2D1C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,kBACT,oBAAoB,SAC5B,MAAM,YACH,MAAM,YACN,MAAM,WACP,MAAM,cACH,UAAU,cACV,UAAU,OACjB,aAAa,YACR,OAAO,KAChB,YAuDF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,kBACR,oBAAoB,UAC3B,MAAM,YACJ,MAAM,YACN,MAAM,WACP,MAAM,cACH,UAAU,cACV,UAAU,OACjB,aAAa,YACR,OAAO,KAChB,YA+EF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM;;;;;;;;CAC6D,CAAC"}

package/dist/types/PoolMath/ConstantSumPool.d.ts

@@ -0,0 +1,133 @@
+import { AssetAmount, IAssetAmountMetadata } from "@sundaeswap/asset";
+import { Fraction, type TFractionLike } from "@sundaeswap/fraction";
+/**
+ * Holds the calculated outcome of a constant-sum swap. Mirrors
+ * {@link ConstantProductPool.TSwapOutcome} so both can flow through the same
+ * generic swap-outcome consumers.
+ */
+export type TSwapOutcome = {
+    input: bigint;
+    output: bigint;
+    lpFee: AssetAmount<IAssetAmountMetadata>;
+    nextInputReserve: bigint;
+    nextOutputReserve: bigint;
+    priceImpact: Fraction;
+};
+/**
+ * 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 declare const getSwapOutput: (inputMetadata: IAssetAmountMetadata, input: bigint, inputReserve: bigint, outputReserve: bigint, priceIn: bigint, priceOut: bigint, fee: TFractionLike, roundOutputUp?: boolean) => TSwapOutcome;
+/**
+ * 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 declare const getSwapInput: (inputMetadata: IAssetAmountMetadata, output: bigint, inputReserve: bigint, outputReserve: bigint, priceIn: bigint, priceOut: bigint, fee: TFractionLike) => TSwapOutcome;
+/**
+ * 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 declare const calculateLiquidity: (a: bigint, b: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, priceA: bigint, priceB: bigint) => {
+    nextTotalLp: bigint;
+    generatedLp: bigint;
+    shareAfterDeposit: Fraction;
+    aChange: bigint;
+    bChange: bigint;
+    actualDepositedA: bigint;
+    actualDepositedB: bigint;
+};
+/**
+ * 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 declare const calculatePinnedDeposit: (offered: bigint[], reserves: bigint[], prices: bigint[], totalLp: bigint) => {
+    targetDeltaV: bigint;
+    deltas: bigint[];
+    generatedLp: bigint;
+    nextTotalLp: bigint;
+    shareAfterDeposit: Fraction;
+};
+/**
+ * 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 declare const pinnedDepositFromAnchor: (anchorIndex: number, anchorAmount: bigint, reserves: bigint[], prices: bigint[]) => bigint[];
+export declare const calculateDepositN: (amounts: bigint[], reserves: bigint[], prices: bigint[], totalLp: bigint) => {
+    nextTotalLp: bigint;
+    generatedLp: bigint;
+    shareAfterDeposit: Fraction;
+};
+//# sourceMappingURL=ConstantSumPool.d.ts.map

package/dist/types/PoolMath/ConstantSumPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstantSumPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/ConstantSumPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGpE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,kBACT,oBAAoB,SAC5B,MAAM,gBACC,MAAM,iBACL,MAAM,WACZ,MAAM,YACL,MAAM,OACX,aAAa,kBACF,OAAO,KACtB,YAsDF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,YAAY,kBACR,oBAAoB,UAC3B,MAAM,gBACA,MAAM,iBACL,MAAM,WACZ,MAAM,YACL,MAAM,OACX,aAAa,KACjB,YA2CF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM,UACP,MAAM,UACN,MAAM;;;;;;;;CAsBf,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,YACxB,MAAM,EAAE,YACP,MAAM,EAAE,UACV,MAAM,EAAE,WACP,MAAM,KACd;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,QAAQ,CAAC;CAqC7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,gBACrB,MAAM,gBACL,MAAM,YACV,MAAM,EAAE,UACV,MAAM,EAAE,KACf,MAAM,EAqBR,CAAC;AAEF,eAAO,MAAM,iBAAiB,YACnB,MAAM,EAAE,YACP,MAAM,EAAE,UACV,MAAM,EAAE,WACP,MAAM;;;;CA6BhB,CAAC"}

package/dist/types/PoolMath/V4StableswapPool.d.ts

@@ -0,0 +1,221 @@
+import { AssetAmount, IAssetAmountMetadata } from "@sundaeswap/asset";
+import { Fraction, type TFractionLike } from "@sundaeswap/fraction";
+/**
+ * THE V4 STABLESWAP INVARIANT MODULE — NOT THE V3 "STABLESWAPS" CONTRACT.
+ *
+ * Two different things in this SDK carry the word "stableswap". Keep them
+ * apart:
+ *
+ * - `StableSwapsPool` / `EContractVersion.Stableswaps` is the **v3** stableswap
+ *   contract. It is a whole contract version with its own datum builder and
+ *   transaction builder. It stores `D` in the pool datum and has no per-asset
+ *   rates.
+ * - `V4StableswapPool` / `EPoolCurve.V4Stableswap` (this file) is a **v4
+ *   invariant module**. It is one curve among several a v4 pool can bind, next
+ *   to constant product, constant sum and concentrated liquidity. It stores no
+ *   `D` and carries per-asset integer `rates`.
+ *
+ * The amplification `A` is the ONE thing they share: the same parameter on the
+ * same scale, carried by the same `linearAmplificationFactor` field, with each
+ * implementation applying its own internal scaling. Everything else is
+ * different — do not pass one's reserves, rates or `D` to the other.
+ *
+ * The curve, on rated and scaled reserves `x = r_a·rate_a·P` and
+ * `y = r_b·rate_b·P` with `P = calc_precision = 10^12` and `A` the linear
+ * amplification:
+ *
+ *   4A(x + y) + D = 4AD + D³ / (4xy)
+ *
+ * `D` is the largest integer that satisfies it. Neither `D` nor a swap output
+ * can be computed on-chain, because both need Newton's method. The scooper
+ * computes them and the module checks that each supplied integer is the unique
+ * one that solves the invariant. This file is the off-chain twin of
+ * `lib/modules/ss_math.ak` and `lib/modules/ss_check.ak` in the sundae-v4
+ * repository — those are the source of truth; keep this in lockstep with them.
+ */
+/** `ss_math.calc_precision`: the scale applied to reserves before they enter the invariant. */
+export declare const CALC_PRECISION = 1000000000000n;
+/**
+ * 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.
+ */
+export type TSwapOutcome = {
+    input: bigint;
+    output: bigint;
+    lpFee: AssetAmount<IAssetAmountMetadata>;
+    nextInputReserve: bigint;
+    nextOutputReserve: bigint;
+    priceImpact: Fraction;
+};
+/**
+ * `f(D)` from the on-chain `liquidity_invariant`. It is ≤ 0 when `D` is at or
+ * below the curve. All arguments are rated and scaled.
+ */
+export declare const invariantF: (x: bigint, y: bigint, amp: bigint, d: bigint) => bigint;
+/**
+ * `g(y)` from the on-chain `exchange_invariant`. It is ≥ 0 when the pool keeps
+ * enough of the taken asset. `g` is symmetric in `x` and `y`, which is what
+ * lets {@link getSwapInput} reuse the same solver in the other direction.
+ */
+export declare const invariantG: (x: bigint, y: bigint, amp: bigint, d: bigint) => bigint;
+/**
+ * The sum invariant `D` of a two-asset v4 stableswap pool: the largest integer
+ * that satisfies the curve on the rated, scaled reserves. Newton from
+ * `D = x + y`, then a ±1 fix-up.
+ *
+ * `D` carries the `rate · CALC_PRECISION` scale — it is not a token amount.
+ *
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param aReserve The pool's reserve of asset A, in token units.
+ * @param bReserve The pool's reserve of asset B, in token units.
+ * @param rateA The pool's rate for asset A (from the stableswap config).
+ * @param rateB The pool's rate for asset B.
+ */
+export declare const getD: (amp: bigint, aReserve: bigint, bReserve: bigint, rateA?: bigint, rateB?: bigint) => bigint;
+/**
+ * The raw swap output: the scaled, pre-fee amount the curve releases when the
+ * given reserve becomes `inAfter` and the taken reserve starts at `outBefore`,
+ * at the pre-swap `d`. It is the largest such amount the exchange invariant
+ * admits — one unit more leaves the pool below the curve — and it is at or
+ * below the exact real-valued output, so it never over-quotes.
+ *
+ * The result carries the `rate · CALC_PRECISION` scale. Divide by
+ * `rateOut · CALC_PRECISION` to get the gross output in token units.
+ *
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param d The pre-swap sum invariant, from {@link getD}.
+ * @param inAfter The given asset's reserve after the input arrives, in token units.
+ * @param outBefore The taken asset's reserve before the swap, in token units.
+ * @param rateIn The pool's rate for the given asset.
+ * @param rateOut The pool's rate for the taken asset.
+ */
+export declare const getRawSwap: (amp: bigint, d: bigint, inAfter: bigint, outBefore: bigint, rateIn?: bigint, rateOut?: bigint) => bigint;
+/**
+ * The pool's marginal price as raw units of asset A per raw unit of asset B.
+ * Use it where a constant-product pool would use the reserve ratio: for a
+ * stableswap pool the reserve ratio is not the price, because the curve holds
+ * the price near par across a wide band of ratios.
+ *
+ * The result is in raw (undecimalized) units. Adjust for the two assets'
+ * decimals before display.
+ */
+export declare const getPrice: (amp: bigint, aReserve: bigint, bReserve: bigint, rateA?: bigint, rateB?: bigint) => Fraction;
+/**
+ * Calculate the swap outcome for a v4 stableswap pool.
+ *
+ * The sequence the chain enforces (`ss_check.ak`, tag 3):
+ *
+ * 1. `D` is derived from the pre-swap reserves at the pool's rates.
+ * 2. `raw` is the LARGEST scaled output the exchange invariant admits at that
+ *    `D`, with the input already added to the given reserve. The solver pins
+ *    the pool's remaining taken reserve `y` to the SMALLEST integer that still
+ *    satisfies the invariant, and `raw = outBefore·rateOut·P − y`, so the two
+ *    statements are the same one: least reserve kept, most output released.
+ * 3. `gross = floor(raw / (rateOut · CALC_PRECISION))` is the output in token units.
+ * 4. `fee = ceil(gross · feeRate)` stays in the pool.
+ * 5. The trader receives `gross − fee`.
+ *
+ * Every rounding step favours the pool, never the trader: `y` is a ceiling on
+ * the exact reserve the curve requires, `gross` floors to whole tokens, and the
+ * fee ceilings. A trader is never quoted more than the chain will pay.
+ *
+ * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.
+ * @param input The amount of the given asset being swapped.
+ * @param inputReserve The pool's reserve of the given asset.
+ * @param outputReserve The pool's reserve of the taken asset.
+ * @param rateIn The pool's rate for the given asset (from the stableswap config).
+ * @param rateOut The pool's rate for the taken asset.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param fee The swap fee rate, applied to the gross output.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export declare const getSwapOutput: (outputMetadata: IAssetAmountMetadata, input: bigint, inputReserve: bigint, outputReserve: bigint, rateIn: bigint, rateOut: bigint, amp: bigint, fee: TFractionLike) => TSwapOutcome;
+/**
+ * Calculate the minimal input that buys a given output — the inverse of
+ * {@link getSwapOutput}.
+ *
+ * The steps:
+ *
+ * 1. Invert the fee: the smallest gross output that nets `output` after
+ *    `ceil(gross · feeRate)` is `ceil(output · feeDen / (feeDen − feeNum))`.
+ * 2. Turn that gross into the scaled reserve the pool may keep of the taken
+ *    asset.
+ * 3. Solve the exchange invariant in the other direction for the given
+ *    reserve that supports it. `g` is symmetric, so this is the same solver.
+ * 4. Convert to token units and walk down to the minimum, which absorbs the
+ *    integer rounding of step 3.
+ *
+ * @param outputMetadata Metadata for the **taken** asset. The fee is denominated in it.
+ * @param output The wanted amount of the taken asset.
+ * @param inputReserve The pool's reserve of the given asset.
+ * @param outputReserve The pool's reserve of the taken asset.
+ * @param rateIn The pool's rate for the given asset (from the stableswap config).
+ * @param rateOut The pool's rate for the taken asset.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ * @param fee The swap fee rate, applied to the gross output.
+ * @returns The swap details in the shared {@link TSwapOutcome} shape.
+ */
+export declare const getSwapInput: (outputMetadata: IAssetAmountMetadata, output: bigint, inputReserve: bigint, outputReserve: bigint, rateIn: bigint, rateOut: bigint, amp: bigint, fee: TFractionLike) => TSwapOutcome;
+/**
+ * The deposit target a holder of `offered` can cover, and everything pinned to
+ * it. This is the target-pinned rule the v4 module enforces (`ss_check.ak`,
+ * tag 6), and it is the same shape constant sum uses, stated on `D` instead of
+ * on the value sum `V`:
+ *
+ * - the fill declares a `D` delta `t`;
+ * - every reserve moves by `ceil(r_i · t / D_before)`;
+ * - `total_lp` becomes `floor(lp_before · (D_before + t) / D_before)`.
+ *
+ * The largest `t` a holder can cover is capped by the scarcest offered asset,
+ * `t = min_i floor(offered_i · D_before / r_i)`. Anything above the pinned
+ * deltas is refunded. Every pool asset must be offered, or `t` is zero and the
+ * deposit can never fill.
+ *
+ * The rates do not enter the deltas: a proportional move is proportional in
+ * any units. They enter only through `D`.
+ */
+export declare const calculatePinnedDeposit: (offered: bigint[], reserves: bigint[], totalLp: bigint, d: bigint) => {
+    targetDeltaD: bigint;
+    deltas: bigint[];
+    generatedLp: bigint;
+    nextTotalLp: bigint;
+    shareAfterDeposit: Fraction;
+};
+/**
+ * Calculate the deposit parameters for a two-asset v4 stableswap pool through
+ * the target-pinned rule (see {@link calculatePinnedDeposit}). Surplus above
+ * the pinned deltas comes back as `aChange` / `bChange`, the way the scoop
+ * refunds it on-chain.
+ *
+ * @param a The amount of token A to deposit.
+ * @param b The amount of token B to deposit.
+ * @param aReserve The pool's reserve of token A.
+ * @param bReserve The pool's reserve of token B.
+ * @param totalLp The pool's total LP supply before the deposit.
+ * @param rateA The pool's rate for token A (from the stableswap config).
+ * @param rateB The pool's rate for token B.
+ * @param amp The pool's `linear_amplification` (`A`), the raw stored integer.
+ */
+export declare const calculateLiquidity: (a: bigint, b: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, rateA: bigint, rateB: bigint, amp: bigint) => {
+    nextTotalLp: bigint;
+    generatedLp: bigint;
+    shareAfterDeposit: Fraction;
+    aChange: bigint;
+    bChange: bigint;
+    actualDepositedA: bigint;
+    actualDepositedB: bigint;
+};
+/**
+ * The per-asset amounts a pinned deposit needs when the user anchors on one
+ * asset's amount: `t` from the anchor (`floor(anchor · D / r_anchor)`), every
+ * other delta ceil-pinned to it. Drives proportional auto-fill in deposit
+ * forms.
+ */
+export declare const pinnedDepositFromAnchor: (anchorIndex: number, anchorAmount: bigint, reserves: bigint[], d: bigint) => bigint[];
+//# sourceMappingURL=V4StableswapPool.d.ts.map

package/dist/types/PoolMath/V4StableswapPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"V4StableswapPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/V4StableswapPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAIpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,+FAA+F;AAC/F,eAAO,MAAM,cAAc,iBAAqB,CAAC;AAQjD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAuBF;;;GAGG;AACH,eAAO,MAAM,UAAU,MAClB,MAAM,KACN,MAAM,OACJ,MAAM,KACR,MAAM,KACR,MAGF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,MAClB,MAAM,KACN,MAAM,OACJ,MAAM,KACR,MAAM,KACR,MAGF,CAAC;AAYF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,QACV,MAAM,YACD,MAAM,YACN,MAAM,qCAGf,MAiCF,CAAC;AA+CF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,QAChB,MAAM,KACR,MAAM,WACA,MAAM,aACJ,MAAM,wCAGhB,MAQF,CAAC;AA6BF;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,QACd,MAAM,YACD,MAAM,YACN,MAAM,qCAGf,QAQF,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,mBACR,oBAAoB,SAC7B,MAAM,gBACC,MAAM,iBACL,MAAM,UACb,MAAM,WACL,MAAM,OACV,MAAM,OACN,aAAa,KACjB,YA6CF,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,mBACP,oBAAoB,UAC5B,MAAM,gBACA,MAAM,iBACL,MAAM,UACb,MAAM,WACL,MAAM,OACV,MAAM,OACN,aAAa,KACjB,YAuEF,CAAC;AAIF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB,YACxB,MAAM,EAAE,YACP,MAAM,EAAE,WACT,MAAM,KACZ,MAAM,KACR;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,QAAQ,CAAC;CAgC7B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM,SACR,MAAM,SACN,MAAM,OACR,MAAM;;;;;;;;CAiBZ,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,gBACrB,MAAM,gBACL,MAAM,YACV,MAAM,EAAE,KACf,MAAM,KACR,MAAM,EAYR,CAAC"}

package/dist/types/PoolMath/index.d.ts

@@ -1,4 +1,7 @@
+export * as ConcentratedLiquidityPool from "./ConcentratedLiquidityPool.js";
 export * as ConstantProductPool from "./ConstantProductPool.js";
+export * as ConstantSumPool from "./ConstantSumPool.js";
 export * as StableSwapsPool from "./StableSwapsPool.js";
+export * as V4StableswapPool from "./V4StableswapPool.js";
 export * as SharedPoolMath from "./SharedPoolMath.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/PoolMath/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,yBAAyB,MAAM,gCAAgC,CAAC;AAC5E,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAC"}