@moon-cx/sdk 0.0.0-stage → 2.0.1

package/dist/math/clmm.js

@@ -0,0 +1,270 @@
+import { constantOf } from "../protocol/index.js";
+import { SCALE, q128Div, q128DivCeil, q128DivFloor, q128Mul, q128MulCeil, q128MulFloor, q128Pow, q128Sqrt, mulDivFloor, } from "./q128.js";
+/**
+ * CLMM bin and price arithmetic, as the ranges compute it on chain.
+ *
+ * Liquidity is held in discrete bins whose price bounds form a geometric
+ * series with ratio `1 + binStep/10000`.
+ *
+ * Every upper bound is exactly the next bin's lower bound, including odd and
+ * negative bins; multiplying the lower bound by sqrt(1+beta) again would
+ * round differently from the range.
+ */
+/** Bins per range. A pool is split across several ranges. */
+export const BINS_PER_RANGE = Number(constantOf('clmm', 'BINS_PER_RANGE'));
+/** Offset that centres range 0 on bin 0. */
+export const RANGE_OFFSET = Number(constantOf('clmm', 'RANGE_OFFSET'));
+/** Bin steps the factory accepts, in basis points. */
+export const BIN_STEPS = [25, 50, 100, 200];
+/**
+ * The four bin steps. The digits are the value: `Bps25` is `25`.
+ *
+ * A narrower step concentrates liquidity harder — better fills, but the market
+ * leaves the position sooner.
+ */
+export const BinStep = {
+    /** 0.25% per bin — "micro bins", stable pairs. */
+    Bps25: 25,
+    /** 0.50% per bin — "tight bins", stable pairs. */
+    Bps50: 50,
+    /** 1.00% per bin — "wide bins", volatile pairs. */
+    Bps100: 100,
+    /** 2.00% per bin — "broad bins", exotic pairs. */
+    Bps200: 200,
+};
+/** Whether a number is one of the four the factory accepts. */
+export function isBinStep(value) {
+    return BIN_STEPS.includes(value);
+}
+/** Range indices the protocol currently deploys. */
+export const RANGE_MIN = Number(constantOf('clmm', 'RANGE_MIN'));
+export const RANGE_MAX = Number(constantOf('clmm', 'RANGE_MAX'));
+/**
+ * Bins a single position may span.
+ *
+ * The deposit also aborts once it has burned 940 000 gas, so a wide deposit
+ * into an already-crowded range can fail below this cap; there is no way to
+ * know that before sending.
+ */
+export const MAX_BINS_PER_POSITION = 50;
+/** Bins one swap may cross before the range gives up. */
+export const MAX_BINS_PER_SWAP = 40;
+/** First bin belonging to a range. */
+export function firstBinOfRange(range) {
+    return range * BINS_PER_RANGE - RANGE_OFFSET;
+}
+/** Last bin belonging to a range. */
+export function lastBinOfRange(range) {
+    return range * BINS_PER_RANGE + (RANGE_OFFSET - 1);
+}
+/**
+ * Which range holds a bin.
+ *
+ * Rounds down, not toward zero. TVM divides toward negative infinity, and the
+ * difference is not academic: bin −1025 belongs to range −1, but truncation
+ * would put it in range 0 and send the message to a range that does not
+ * own that bin.
+ */
+export function rangeOfBin(bin) {
+    return Math.floor((bin + RANGE_OFFSET) / BINS_PER_RANGE);
+}
+/** Lowest and highest bins any deployed range covers. */
+export function binCoverage() {
+    return { min: firstBinOfRange(RANGE_MIN), max: lastBinOfRange(RANGE_MAX) };
+}
+/** `1 + binStep/10000` in Q128, as the range computes it. */
+export function onePlusBeta(binStep) {
+    return SCALE + mulDivFloor(SCALE, BigInt(binStep), 10000n);
+}
+/** Square root of {@link onePlusBeta}, in Q128. */
+export function sqrtOnePlusBeta(binStep) {
+    return q128Sqrt(onePlusBeta(binStep));
+}
+/**
+ * Lower price bound of a bin, as a Q128 square root.
+ *
+ * Odd bins are computed as `(1+β)^(n>>1) · sqrt(1+β)` rather than by raising to
+ * a half power — matching the range's own shortcut, rounding included.
+ */
+export function sqrtPriceAtBin(bin, binStep) {
+    const beta = onePlusBeta(binStep);
+    const sqrtBeta = sqrtOnePlusBeta(binStep);
+    return sqrtPriceAtBinWith(bin, beta, sqrtBeta);
+}
+function sqrtPriceAtBinWith(bin, beta, sqrtBeta) {
+    const half = BigInt(bin >> 1);
+    const power = q128Pow(beta, half);
+    return (bin & 1) === 0 ? power : q128Mul(power, sqrtBeta);
+}
+/**
+ * Upper bound of a bin, where a swap moving the price down enters it. The
+ * range uses this same boundary for liquidity and swap arithmetic.
+ */
+export function sqrtPriceEnteringBin(bin, binStep) {
+    return sqrtPriceAtBin(bin + 1, binStep);
+}
+/** Both price bounds of a bin, as Q128 square roots. */
+export function binBounds(bin, binStep) {
+    const beta = onePlusBeta(binStep);
+    const sqrtBeta = sqrtOnePlusBeta(binStep);
+    const sqrtPa = sqrtPriceAtBinWith(bin, beta, sqrtBeta);
+    return { sqrtPa, sqrtPb: sqrtPriceAtBinWith(bin + 1, beta, sqrtBeta) };
+}
+/**
+ * Price from a Q128 square root, as a JavaScript number.
+ *
+ * For display only. The value is squared and scaled down, so it loses
+ * precision — never feed it back into anything that builds a transaction.
+ */
+export function sqrtPriceToPrice(sqrtPrice, decimalsX = 0, decimalsY = 0) {
+    const raw = Number(sqrtPrice) / Number(SCALE);
+    return raw * raw * 10 ** (decimalsX - decimalsY);
+}
+/**
+ * Bin index as a real number: `log(price) / log(1+β)`.
+ *
+ * The integer part names the bin, the fraction says how far into it the price
+ * sits. Shared so that containment and proximity cannot drift apart.
+ */
+function binExponent(rawPrice, binStep) {
+    if (!(rawPrice > 0) || !Number.isFinite(rawPrice)) {
+        throw new RangeError('price must be a finite number greater than zero');
+    }
+    return Math.log(rawPrice) / Math.log(1 + binStep / 10_000);
+}
+/**
+ * The bin containing a price expressed in **raw** units — token Y per token X
+ * before decimals are applied.
+ *
+ * Containment, not proximity. A bin owns the half-open interval
+ * `[Pa(n), Pa(n+1))`, so a price anywhere in the upper part of a bin still
+ * belongs to that bin and not to the next one. When you want the closest
+ * boundary instead, ask for it by name: {@link nearestBinToRawPrice}.
+ *
+ * Named apart from `pool.binAtPrice`, which takes the price as a person would
+ * write it. Feeding a human price here puts the bin thousands of steps away
+ * whenever the two assets have different decimals.
+ */
+export function binAtRawPrice(rawPrice, binStep) {
+    // Floor, not round: a bin owns [Pa(n), Pa(n+1)).
+    // In doubles (1+β)^bin lands slightly below the exact power (worst exponent
+    // error −4.5e-13), so a bare floor breaks bin↔price round trips; 1e-9 absorbs
+    // that and is far too small to cross a real bin boundary.
+    return Math.floor(binExponent(rawPrice, binStep) + 1e-9);
+}
+/**
+ * The bin whose lower bound lies **closest** to a raw price — the nearest
+ * boundary, not the bin the price falls into.
+ *
+ * Only pool creation wants this: the factory accepts any `initBin`, and
+ * rounding to the nearest boundary opens the pool at the price the creator
+ * actually asked for rather than up to a whole bin below it. Everything that
+ * asks "where does this price live?" wants {@link binAtRawPrice}.
+ */
+export function nearestBinToRawPrice(rawPrice, binStep) {
+    return Math.round(binExponent(rawPrice, binStep));
+}
+/** Human-readable price of a bin, decimals applied. */
+export function priceAtBin(bin, binStep, decimalsX = 0, decimalsY = 0) {
+    return (1 + binStep / 10_000) ** bin * 10 ** (decimalsX - decimalsY);
+}
+/**
+ * Converts a human price into a bin, accounting for the two tokens' decimals.
+ *
+ * A pool of TON (9 decimals) against a 6-decimal jetton prices very differently
+ * in raw units than it does on screen; getting this wrong puts a position
+ * thousands of bins away from the market.
+ */
+export function binAtHumanPrice(args) {
+    const raw = args.price * 10 ** (args.decimalsY - args.decimalsX);
+    return binAtRawPrice(raw, args.binStep);
+}
+/**
+ * {@link nearestBinToRawPrice} for a human price, decimals accounted for.
+ *
+ * The counterpart of {@link binAtHumanPrice}: nearest boundary rather than
+ * containment. Pool creation is the one caller that means it.
+ */
+export function nearestBinToHumanPrice(args) {
+    const raw = args.price * 10 ** (args.decimalsY - args.decimalsX);
+    return nearestBinToRawPrice(raw, args.binStep);
+}
+/**
+ * What one bin does with the amounts offered to it.
+ *
+ * A bin below the current price takes only Y; one above takes only X; the bin
+ * holding the current price takes both, in the ratio its bounds dictate. The
+ * side that runs out first caps the liquidity, and the excess is refunded —
+ * which is why an unbalanced deposit silently returns part of itself.
+ */
+export function contributeLiquidity(args) {
+    const { sqrtPa, sqrtPb } = binBounds(args.bin, args.binStep);
+    const clamped = args.currentSqrtPrice < sqrtPa ? sqrtPa : args.currentSqrtPrice;
+    const sqrtP = clamped > sqrtPb ? sqrtPb : clamped;
+    const dxPerL = q128Div(SCALE, sqrtP) - q128Div(SCALE, sqrtPb);
+    const dyPerL = sqrtP - sqrtPa;
+    let liquidity = 0n;
+    if (dxPerL > 0n || dyPerL > 0n) {
+        const fromX = dxPerL > 0n ? q128DivFloor(args.x, dxPerL) : 1n << 255n;
+        const fromY = dyPerL > 0n ? q128DivFloor(args.y, dyPerL) : 1n << 255n;
+        liquidity = fromX < fromY ? fromX : fromY;
+    }
+    // Used amounts round up, as on chain.
+    let usedX = q128MulCeil(dxPerL, liquidity);
+    let usedY = q128MulCeil(dyPerL, liquidity);
+    if (usedX > args.x)
+        usedX = args.x;
+    if (usedY > args.y)
+        usedY = args.y;
+    return {
+        liquidity,
+        used: { x: usedX, y: usedY },
+        refund: { x: args.x - usedX, y: args.y - usedY },
+    };
+}
+/**
+ * What one bin of a position is worth right now.
+ *
+ * Mirrors a withdrawal from the range: liquidity is converted
+ * back into both sides at the price clamped to the bin's own bounds, so a bin
+ * the price has moved past holds only one of them.
+ */
+export function binValue(args) {
+    const { sqrtPa, sqrtPb } = binBounds(args.bin, args.binStep);
+    const clamped = args.currentSqrtPrice < sqrtPa ? sqrtPa : args.currentSqrtPrice;
+    const sqrtP = clamped > sqrtPb ? sqrtPb : clamped;
+    const dxPerL = q128DivFloor(SCALE, sqrtP) - q128DivCeil(SCALE, sqrtPb);
+    const dyPerL = sqrtP - sqrtPa;
+    const x = q128MulFloor(dxPerL, args.liquidity);
+    const y = q128MulFloor(dyPerL, args.liquidity);
+    return { x: x > 0n ? x : 0n, y: y > 0n ? y : 0n };
+}
+/**
+ * Fees one bin owes a position.
+ *
+ * Mirrors the on-chain fee payout: the range keeps a per-unit-of-liquidity
+ * accumulator per bin, the position keeps the value it last settled at, and
+ * what is owed is the growth times the position's liquidity in that bin.
+ */
+export function binFees(args) {
+    const deltaX = args.binFees.x - args.checkpoint.x;
+    const deltaY = args.binFees.y - args.checkpoint.y;
+    return {
+        x: q128MulFloor(args.liquidity, deltaX > 0n ? deltaX : 0n),
+        y: q128MulFloor(args.liquidity, deltaY > 0n ? deltaY : 0n),
+    };
+}
+/**
+ * Which side or sides a bin can take, given where the price sits.
+ *
+ * Useful before building a deposit: offering X to a bin that only takes Y
+ * gets it refunded, minus the gas spent finding out.
+ */
+export function binSides(args) {
+    const { sqrtPa, sqrtPb } = binBounds(args.bin, args.binStep);
+    return {
+        takesX: args.currentSqrtPrice < sqrtPb,
+        takesY: args.currentSqrtPrice > sqrtPa,
+    };
+}
+//# sourceMappingURL=clmm.js.map

package/dist/math/clmm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clmm.js","sourceRoot":"","sources":["../../src/math/clmm.ts"],"names":[],"mappings":"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"}

package/dist/math/cpmm.d.ts

@@ -0,0 +1,170 @@
+/**
+ * CPMM arithmetic, as the pool computes it on chain.
+ *
+ * Constants come from the generated protocol table, so a change on chain
+ * shows up as a failing test.
+ */
+/** Fees are shares of 10000. */
+export declare const FEE_DIVIDER: bigint;
+/** Fixed-point scale for per-share fee accumulators: 2^128. */
+export declare const SCALE: bigint;
+export declare const MAX_COINS: bigint;
+/**
+ * Liquidity permanently retained by the pool on its first deposit.
+ *
+ * `sqrt(10000 * 10000)` in the pool. It is minted to nobody and can never
+ * be withdrawn, which is what stops the pool from being drained to zero.
+ */
+export declare const INITIAL_LOCKED_LP: bigint;
+export type SwapResult = {
+    amountOut: bigint;
+    newReserveIn: bigint;
+    newReserveOut: bigint;
+    /** Portion of the input kept for liquidity providers. */
+    lpFee: bigint;
+    /** Portion of the input kept for the protocol. */
+    protocolFee: bigint;
+};
+/**
+ * Output of a constant-product swap, fees included.
+ *
+ * Note the shape of the formula: fees are taken off the *input* before the
+ * curve is applied, and the reserve grows by the input minus both fees — the
+ * fee portion is accounted separately rather than left in the reserve.
+ */
+export declare function swapOutput(args: {
+    amountIn: bigint;
+    reserveIn: bigint;
+    reserveOut: bigint;
+    lpFeeBps: number;
+    protocolFeeBps: number;
+}): SwapResult;
+/**
+ * The conditions under which the pool refuses a swap.
+ *
+ * Checked before building so the caller sees the reason instead of a bounced
+ * message — or, on the jetton leg, instead of nothing at all.
+ */
+export declare function swapRejectionReason(args: {
+    amountIn: bigint;
+    reserveIn: bigint;
+    reserveOut: bigint;
+    lpTotal: bigint;
+    lpFeeBps: number;
+    protocolFeeBps: number;
+    minOut: bigint;
+}): string | null;
+/**
+ * How far the swap moves the price, in basis points.
+ *
+ * Measured against the mid price before the trade, so a tiny trade in a deep
+ * pool reads as ~0 and a trade that eats the pool reads as most of 10000.
+ */
+export declare function priceImpactBps(args: {
+    amountIn: bigint;
+    amountOut: bigint;
+    reserveIn: bigint;
+    reserveOut: bigint;
+}): number;
+export type FirstDeposit = {
+    /** Total LP the pool will hold. */
+    lpTotal: bigint;
+    /** LP actually credited to the depositor. */
+    userLp: bigint;
+    /** LP retained by the pool forever. */
+    lockedLp: bigint;
+};
+/**
+ * LP minted by the very first deposit into a pool.
+ *
+ * `sqrt(x * y)`, less the 10000 units the pool keeps. A first deposit small
+ * enough that `sqrt(x * y) <= 10000` mints the depositor nothing.
+ */
+export declare function firstDepositLp(x: bigint, y: bigint): FirstDeposit;
+/**
+ * LP minted by a deposit into a pool that already has liquidity.
+ *
+ * The smaller of the two sides decides — supplying more of one asset than the
+ * ratio calls for mints nothing extra for the excess.
+ */
+export declare function depositLp(args: {
+    x: bigint;
+    y: bigint;
+    lpTotal: bigint;
+    reserveX: bigint;
+    reserveY: bigint;
+}): bigint;
+/**
+ * The amounts of each side that match a given amount of the other, at the
+ * pool's current ratio. Use it to fill in the second field of a deposit form.
+ */
+export declare function matchingDeposit(args: {
+    reserveX: bigint;
+    reserveY: bigint;
+    x?: bigint;
+    y?: bigint;
+}): {
+    x: bigint;
+    y: bigint;
+};
+export type WithdrawResult = {
+    /** Principal returned, before fees. */
+    principal: {
+        x: bigint;
+        y: bigint;
+    };
+    /** Fees accrued since the position last settled. */
+    fees: {
+        x: bigint;
+        y: bigint;
+    };
+    /** What actually arrives: principal plus fees. */
+    total: {
+        x: bigint;
+        y: bigint;
+    };
+};
+/**
+ * What withdrawing `lp` returns, fees included.
+ *
+ * Fees are tracked as a per-share accumulator: the position stores the value
+ * of the accumulator when it last settled, and is owed the growth since.
+ */
+export declare function withdrawAmounts(args: {
+    lp: bigint;
+    lpTotal: bigint;
+    reserveX: bigint;
+    reserveY: bigint;
+    /** Pool-wide fee accumulators, scaled by 2^128. */
+    feesLp: {
+        x: bigint;
+        y: bigint;
+    };
+    /** The position's checkpoint of those accumulators. */
+    checkpoint: {
+        x: bigint;
+        y: bigint;
+    };
+}): WithdrawResult;
+/** Fees owed to a position right now, without touching its liquidity. */
+export declare function pendingFees(args: {
+    lp: bigint;
+    feesLp: {
+        x: bigint;
+        y: bigint;
+    };
+    checkpoint: {
+        x: bigint;
+        y: bigint;
+    };
+}): {
+    x: bigint;
+    y: bigint;
+};
+/**
+ * How much the pool-wide fee accumulator grows when a swap collects `lpFee`.
+ *
+ * Mirrors the update the pool makes on every swap.
+ */
+export declare function feeShareGrowth(lpFee: bigint, lpTotal: bigint): bigint;
+//# sourceMappingURL=cpmm.d.ts.map

package/dist/math/cpmm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpmm.d.ts","sourceRoot":"","sources":["../../src/math/cpmm.ts"],"names":[],"mappings":"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"}

package/dist/math/cpmm.js

@@ -0,0 +1,175 @@
+import { constantOf } from "../protocol/index.js";
+import { isqrt, max, min, mulDivFloor } from "./integer.js";
+/**
+ * CPMM arithmetic, as the pool computes it on chain.
+ *
+ * Constants come from the generated protocol table, so a change on chain
+ * shows up as a failing test.
+ */
+/** Fees are shares of 10000. */
+export const FEE_DIVIDER = constantOf('cpmm', 'FEE_DIVIDER');
+/** Fixed-point scale for per-share fee accumulators: 2^128. */
+export const SCALE = constantOf('cpmm', 'SCALE');
+export const MAX_COINS = constantOf('cpmm', 'MAX_COINS');
+/**
+ * Liquidity permanently retained by the pool on its first deposit.
+ *
+ * `sqrt(10000 * 10000)` in the pool. It is minted to nobody and can never
+ * be withdrawn, which is what stops the pool from being drained to zero.
+ */
+export const INITIAL_LOCKED_LP = isqrt(10000n * 10000n);
+/**
+ * Output of a constant-product swap, fees included.
+ *
+ * Note the shape of the formula: fees are taken off the *input* before the
+ * curve is applied, and the reserve grows by the input minus both fees — the
+ * fee portion is accounted separately rather than left in the reserve.
+ */
+export function swapOutput(args) {
+    const { amountIn, reserveIn, reserveOut } = args;
+    if (amountIn <= 0n)
+        throw new RangeError('amountIn must be positive');
+    if (reserveIn <= 0n || reserveOut <= 0n)
+        throw new RangeError('pool has no liquidity');
+    const allFees = BigInt(args.lpFeeBps + args.protocolFeeBps);
+    if (allFees >= FEE_DIVIDER)
+        throw new RangeError('fees cannot reach 100%');
+    const effectiveIn = amountIn * (FEE_DIVIDER - allFees);
+    const amountOut = mulDivFloor(reserveOut, effectiveIn, reserveIn * FEE_DIVIDER + effectiveIn);
+    const lpFee = mulDivFloor(amountIn, BigInt(args.lpFeeBps), FEE_DIVIDER);
+    const protocolFee = mulDivFloor(amountIn, BigInt(args.protocolFeeBps), FEE_DIVIDER);
+    return {
+        amountOut,
+        newReserveIn: reserveIn + amountIn - (lpFee + protocolFee),
+        newReserveOut: reserveOut - amountOut,
+        lpFee,
+        protocolFee,
+    };
+}
+/**
+ * The conditions under which the pool refuses a swap.
+ *
+ * Checked before building so the caller sees the reason instead of a bounced
+ * message — or, on the jetton leg, instead of nothing at all.
+ */
+export function swapRejectionReason(args) {
+    if (args.lpTotal <= 0n)
+        return 'the pool has no liquidity yet';
+    const result = swapOutput(args);
+    if (result.amountOut <= 0n)
+        return 'this amount is too small to return anything';
+    if (args.minOut > 0n && args.minOut > result.amountOut) {
+        return `the pool would return ${result.amountOut}, below the requested minimum of ${args.minOut}`;
+    }
+    if (result.newReserveIn >= MAX_COINS)
+        return 'the swap would overflow the pool reserve';
+    if (result.newReserveOut <= 0n)
+        return 'the swap would drain the pool';
+    return null;
+}
+/**
+ * How far the swap moves the price, in basis points.
+ *
+ * Measured against the mid price before the trade, so a tiny trade in a deep
+ * pool reads as ~0 and a trade that eats the pool reads as most of 10000.
+ */
+export function priceImpactBps(args) {
+    if (args.amountIn <= 0n || args.amountOut <= 0n)
+        return 0;
+    const ideal = mulDivFloor(args.amountIn, args.reserveOut, args.reserveIn);
+    if (ideal <= 0n)
+        return 0;
+    const lost = ideal > args.amountOut ? ideal - args.amountOut : 0n;
+    return Number(mulDivFloor(lost, FEE_DIVIDER, ideal));
+}
+/**
+ * LP minted by the very first deposit into a pool.
+ *
+ * `sqrt(x * y)`, less the 10000 units the pool keeps. A first deposit small
+ * enough that `sqrt(x * y) <= 10000` mints the depositor nothing.
+ */
+export function firstDepositLp(x, y) {
+    if (x <= 0n || y <= 0n)
+        throw new RangeError('both sides of the first deposit must be positive');
+    const lpTotal = isqrt(x * y);
+    return {
+        lpTotal,
+        userLp: max(lpTotal - INITIAL_LOCKED_LP, 0n),
+        lockedLp: min(lpTotal, INITIAL_LOCKED_LP),
+    };
+}
+/**
+ * LP minted by a deposit into a pool that already has liquidity.
+ *
+ * The smaller of the two sides decides — supplying more of one asset than the
+ * ratio calls for mints nothing extra for the excess.
+ */
+export function depositLp(args) {
+    if (args.lpTotal <= 0n)
+        throw new RangeError('use firstDepositLp for an empty pool');
+    if (args.reserveX <= 0n || args.reserveY <= 0n)
+        throw new RangeError('pool has no reserves');
+    const fromX = mulDivFloor(args.x, args.lpTotal, args.reserveX);
+    const fromY = mulDivFloor(args.y, args.lpTotal, args.reserveY);
+    return min(fromX, fromY);
+}
+/**
+ * The amounts of each side that match a given amount of the other, at the
+ * pool's current ratio. Use it to fill in the second field of a deposit form.
+ */
+export function matchingDeposit(args) {
+    if (args.reserveX <= 0n || args.reserveY <= 0n)
+        throw new RangeError('pool has no reserves');
+    if (args.x !== undefined) {
+        return { x: args.x, y: mulDivFloor(args.x, args.reserveY, args.reserveX) };
+    }
+    if (args.y !== undefined) {
+        return { x: mulDivFloor(args.y, args.reserveX, args.reserveY), y: args.y };
+    }
+    throw new TypeError('give either x or y');
+}
+/**
+ * What withdrawing `lp` returns, fees included.
+ *
+ * Fees are tracked as a per-share accumulator: the position stores the value
+ * of the accumulator when it last settled, and is owed the growth since.
+ */
+export function withdrawAmounts(args) {
+    if (args.lp <= 0n)
+        throw new RangeError('withdraw amount must be positive');
+    if (args.lp > args.lpTotal)
+        throw new RangeError('cannot withdraw more LP than exists');
+    const deltaX = max(args.feesLp.x - args.checkpoint.x, 0n);
+    const deltaY = max(args.feesLp.y - args.checkpoint.y, 0n);
+    const fees = {
+        x: mulDivFloor(args.lp, deltaX, SCALE),
+        y: mulDivFloor(args.lp, deltaY, SCALE),
+    };
+    const principal = {
+        x: mulDivFloor(args.reserveX, args.lp, args.lpTotal),
+        y: mulDivFloor(args.reserveY, args.lp, args.lpTotal),
+    };
+    return {
+        principal,
+        fees,
+        total: { x: principal.x + fees.x, y: principal.y + fees.y },
+    };
+}
+/** Fees owed to a position right now, without touching its liquidity. */
+export function pendingFees(args) {
+    return {
+        x: mulDivFloor(args.lp, max(args.feesLp.x - args.checkpoint.x, 0n), SCALE),
+        y: mulDivFloor(args.lp, max(args.feesLp.y - args.checkpoint.y, 0n), SCALE),
+    };
+}
+/**
+ * How much the pool-wide fee accumulator grows when a swap collects `lpFee`.
+ *
+ * Mirrors the update the pool makes on every swap.
+ */
+export function feeShareGrowth(lpFee, lpTotal) {
+    if (lpTotal <= 0n)
+        throw new RangeError('no liquidity to distribute fees to');
+    return mulDivFloor(lpFee, SCALE, lpTotal);
+}
+//# sourceMappingURL=cpmm.js.map

package/dist/math/cpmm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpmm.js","sourceRoot":"","sources":["../../src/math/cpmm.ts"],"names":[],"mappings":"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"}

package/dist/math/integer.d.ts

@@ -0,0 +1,10 @@
+/** Integer arithmetic matching the on-chain math bit for bit. */
+/** On-chain `mulDivFloor`: full-precision multiply, then floor division. */
+export declare function mulDivFloor(a: bigint, b: bigint, denominator: bigint): bigint;
+/** Like {@link mulDivFloor}, but rounds up. */
+export declare function mulDivCeil(a: bigint, b: bigint, denominator: bigint): bigint;
+/** Integer square root: the largest `r` such that `r² ≤ value`. */
+export declare function isqrt(value: bigint): bigint;
+export declare function min(a: bigint, b: bigint): bigint;
+export declare function max(a: bigint, b: bigint): bigint;
+//# sourceMappingURL=integer.d.ts.map

package/dist/math/integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/math/integer.ts"],"names":[],"mappings":"AAAA,iEAAiE;AAEjE,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAG7E;AAED,+CAA+C;AAC/C,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAI5E;AAED,mEAAmE;AACnE,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB3C;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD"}