@coffer_so/sdk 1.0.0

package/dist/math/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fixedPoint"), exports);
+__exportStar(require("./logExp"), exports);
+__exportStar(require("./cubicMath"), exports);
+__exportStar(require("./weightedMath"), exports);
+__exportStar(require("./singleToken"), exports);
+__exportStar(require("./slippage"), exports);
+__exportStar(require("./maxSelloff"), exports);
+__exportStar(require("./lpLoss"), exports);
+// NOTE: "./surgeFee" is deliberately NOT star-exported — its
+// calcSurgeFeePct/calcSurgeFeeAmount would shadow the same-named maxSelloff
+// exports (an ambiguous star re-export silently drops the name, breaking
+// existing consumers). The quote engine imports it by path; only the
+// SurgeCurve type is re-exported from the package root.
+//# sourceMappingURL=index.js.map

package/dist/math/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,2CAAyB;AACzB,8CAA4B;AAC5B,iDAA+B;AAC/B,gDAA8B;AAC9B,6CAA2B;AAC3B,+CAA6B;AAC7B,2CAAyB;AACzB,6DAA6D;AAC7D,4EAA4E;AAC5E,yEAAyE;AACzE,qEAAqE;AACrE,wDAAwD"}

package/dist/math/logExp.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_NATURAL_EXPONENT = 46000000000000000000n;
+export declare const MIN_NATURAL_EXPONENT = -41000000000000000000n;
+export declare function lnFp(a: bigint): bigint;
+export declare function expFp(x: bigint): bigint;
+export declare function powFp(base: bigint, exponent: bigint): bigint;
+//# sourceMappingURL=logExp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logExp.d.ts","sourceRoot":"","sources":["../../src/math/logExp.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,wBAAwB,CAAC;AAC1D,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAmB3D,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAKtC;AACD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBvC;AACD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAa5D"}

package/dist/math/logExp.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_NATURAL_EXPONENT = exports.MAX_NATURAL_EXPONENT = void 0;
+exports.lnFp = lnFp;
+exports.expFp = expFp;
+exports.powFp = powFp;
+/** Exact integer port of cubic-pool log_exp_math.rs (audit-fixes-excluded-SF). */
+const fixedPoint_1 = require("./fixedPoint");
+exports.MAX_NATURAL_EXPONENT = 46000000000000000000n;
+exports.MIN_NATURAL_EXPONENT = -41000000000000000000n;
+const X = [32000000000000000000n, 16000000000000000000n, 8000000000000000000n, 4000000000000000000n, 2000000000000000000n, 1000000000000000000n, 500000000000000000n, 250000000000000000n, 125000000000000000n, 62500000000000000n];
+const A = [78962960182680695161000000000000n, 8886110520507872636760000n, 2980957987041728274740n, 54598150033144239078n, 7389056098930650227n, 2718281828459045235n, 1648721270700128146n, 1284025416687741484n, 1133148453066826316n, 1064494458917859429n];
+function lnPositive(a) {
+    let sum = 0n;
+    for (let i = 0; i < X.length; i++)
+        if (a >= A[i]) {
+            a = (0, fixedPoint_1.mulDivDown)(a, fixedPoint_1.ONE, A[i]);
+            sum += X[i];
+        }
+    const z = (0, fixedPoint_1.mulDivDown)(a - fixedPoint_1.ONE, fixedPoint_1.ONE, (0, fixedPoint_1.assertU128)(a + fixedPoint_1.ONE));
+    const zSq = (0, fixedPoint_1.assertI128)(z * z) / fixedPoint_1.ONE;
+    let num = z, seriesSum = z;
+    for (let k = 1n; k < 6n; k++) {
+        num = (0, fixedPoint_1.assertI128)(num * zSq) / fixedPoint_1.ONE;
+        seriesSum = (0, fixedPoint_1.assertI128)(seriesSum + num / (2n * k + 1n));
+    }
+    return (0, fixedPoint_1.assertI128)(sum + (0, fixedPoint_1.assertI128)(seriesSum * 2n));
+}
+function lnFp(a) {
+    (0, fixedPoint_1.assertU128)(a);
+    if (a === 0n)
+        throw new Error("logExp.ln: divide by zero");
+    return a < fixedPoint_1.ONE ? -lnPositive((0, fixedPoint_1.mulDivDown)(fixedPoint_1.ONE, fixedPoint_1.ONE, a)) : lnPositive(a);
+}
+function expFp(x) {
+    (0, fixedPoint_1.assertI128)(x);
+    if (x < exports.MIN_NATURAL_EXPONENT || x > exports.MAX_NATURAL_EXPONENT)
+        throw new Error("logExp.exp: exponent out of range");
+    if (x < 0n)
+        return (0, fixedPoint_1.mulDivDown)(fixedPoint_1.ONE, fixedPoint_1.ONE, expFp(-x));
+    let product = fixedPoint_1.ONE;
+    for (let i = 0; i < X.length; i++)
+        if (x >= X[i]) {
+            x -= X[i];
+            product = (0, fixedPoint_1.mulDivDown)(product, A[i], fixedPoint_1.ONE);
+        }
+    let sum = (0, fixedPoint_1.assertU128)(fixedPoint_1.ONE + x), term = x;
+    for (let n = 2n; n <= 12n; n++) {
+        term = (0, fixedPoint_1.mulDivDown)(term, x, fixedPoint_1.ONE) / n;
+        sum = (0, fixedPoint_1.assertU128)(sum + term);
+    }
+    return (0, fixedPoint_1.mulDivDown)(product, sum, fixedPoint_1.ONE);
+}
+function powFp(base, exponent) {
+    (0, fixedPoint_1.assertU128)(base);
+    (0, fixedPoint_1.assertU128)(exponent);
+    if (exponent === 0n || base === fixedPoint_1.ONE)
+        return fixedPoint_1.ONE;
+    if (base === 0n)
+        return 0n;
+    const logarithm = lnFp(base);
+    // Rust casts u128 to i128 here. Valid pool weights are far below i128::MAX.
+    const y = BigInt.asIntN(128, exponent);
+    const whole = (0, fixedPoint_1.assertI128)((logarithm / fixedPoint_1.ONE) * y);
+    const fraction = (0, fixedPoint_1.assertI128)((logarithm % fixedPoint_1.ONE) * y) / fixedPoint_1.ONE;
+    return expFp((0, fixedPoint_1.assertI128)(whole + fraction));
+}
+//# sourceMappingURL=logExp.js.map

package/dist/math/logExp.js.map

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

package/dist/math/lpLoss.d.ts

@@ -0,0 +1,44 @@
+export interface PredictLpLossParams {
+    /** Normalized weights in bps (sum = WEIGHT_SCALE). */
+    weightsBps: number[];
+    virtualBalances: bigint[];
+    /** LP-accessible balances: actual − protocolFeesOwed. */
+    lpActualBalances: bigint[];
+    decimals: number[];
+    bptTotalSupply: bigint;
+    swapFeeRate: number;
+    protocolFeeRate: number;
+    tokenInIndex: number;
+    amountIn: bigint;
+    /** Per-token input allocations from the quote (sum = amountIn). */
+    allocations: bigint[];
+    /** Per-leg expected swap outputs (0 for the input token / sidelined). */
+    expectedOuts: bigint[];
+    /** Amounts passed to add_liquidity after proportional capping. */
+    depositedAmounts: bigint[];
+    /** Helper-held excess refunded to the user. */
+    refundAmounts: bigint[];
+    estimatedBpt: bigint;
+    /**
+     * External per-token prices in any common unit. When omitted or incomplete
+     * the pool-spot-implied prices (w_i / V_i) are used instead.
+     */
+    prices?: Array<number | null | undefined>;
+}
+/**
+ * Predicted total value loss of the LP position minted by a single-token
+ * deposit, as a percent of the deposited value, measured AFTER arbitrageurs
+ * rebalance the pool back to external prices — the slippage-proof cost the
+ * depositor actually bears.
+ *
+ * Replays the quote's swap legs and join onto the pool state, then values
+ * the position at the closed-form zero-fee-arb equilibrium: with the
+ * invariant ∏V_i^w_i preserved, equilibrium virtuals are V'_i = λ·w_i/p_i
+ * and actual balances move by the same deltas. Validated against a full
+ * profit-maximizing arbitrage simulation of the contract math (±0.03 pp,
+ * slightly conservative). Float math — ample for percent-level output.
+ *
+ * Returns `null` when the pool is empty or inputs cannot price.
+ */
+export declare function predictLpLoss(params: PredictLpLossParams): number | null;
+//# sourceMappingURL=lpLoss.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lpLoss.d.ts","sourceRoot":"","sources":["../../src/math/lpLoss.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,yEAAyE;IACzE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,kEAAkE;IAClE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,+CAA+C;IAC/C,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CAC3C;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI,CA2GxE"}

package/dist/math/lpLoss.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.predictLpLoss = predictLpLoss;
+const config_1 = require("../config");
+const toWhole = (raw, decimals) => Number(raw) / 10 ** decimals;
+/**
+ * Predicted total value loss of the LP position minted by a single-token
+ * deposit, as a percent of the deposited value, measured AFTER arbitrageurs
+ * rebalance the pool back to external prices — the slippage-proof cost the
+ * depositor actually bears.
+ *
+ * Replays the quote's swap legs and join onto the pool state, then values
+ * the position at the closed-form zero-fee-arb equilibrium: with the
+ * invariant ∏V_i^w_i preserved, equilibrium virtuals are V'_i = λ·w_i/p_i
+ * and actual balances move by the same deltas. Validated against a full
+ * profit-maximizing arbitrage simulation of the contract math (±0.03 pp,
+ * slightly conservative). Float math — ample for percent-level output.
+ *
+ * Returns `null` when the pool is empty or inputs cannot price.
+ */
+function predictLpLoss(params) {
+    const { weightsBps, virtualBalances, lpActualBalances, decimals, bptTotalSupply, swapFeeRate, protocolFeeRate, tokenInIndex, amountIn, allocations, expectedOuts, depositedAmounts, refundAmounts, estimatedBpt, prices: externalPrices, } = params;
+    const n = weightsBps.length;
+    if (virtualBalances.length !== n ||
+        lpActualBalances.length !== n ||
+        decimals.length !== n) {
+        throw new Error("predictLpLoss: length mismatch");
+    }
+    if (tokenInIndex < 0 || tokenInIndex >= n) {
+        throw new Error("predictLpLoss: tokenInIndex out of range");
+    }
+    const supply = Number(bptTotalSupply);
+    const estBpt = Number(estimatedBpt);
+    const amountInWhole = toWhole(amountIn, decimals[tokenInIndex]);
+    if (supply <= 0 || estBpt <= 0 || amountInWhole <= 0)
+        return null;
+    const weights = [];
+    const virtuals = [];
+    const actuals = [];
+    for (let i = 0; i < n; i++) {
+        weights.push(weightsBps[i] / config_1.WEIGHT_SCALE);
+        virtuals.push(toWhole(virtualBalances[i], decimals[i]));
+        actuals.push(toWhole(lpActualBalances[i], decimals[i]));
+    }
+    const externalComplete = externalPrices !== undefined &&
+        externalPrices.length === n &&
+        externalPrices.every((p) => typeof p === "number" && p > 0);
+    const prices = [];
+    for (let i = 0; i < n; i++) {
+        const price = externalComplete
+            ? externalPrices[i]
+            : weights[i] / virtuals[i];
+        if (!Number.isFinite(price) || price <= 0)
+            return null;
+        prices.push(price);
+    }
+    const feeRate = swapFeeRate / config_1.SWAP_FEE_PRECISION;
+    const protoRate = protocolFeeRate / config_1.PROTOCOL_FEE_PRECISION;
+    for (let i = 0; i < n; i++) {
+        if (i === tokenInIndex)
+            continue;
+        const alloc = toWhole(allocations[i] ?? 0n, decimals[tokenInIndex]);
+        const out = toWhole(expectedOuts[i] ?? 0n, decimals[i]);
+        if (alloc <= 0 || out <= 0)
+            continue;
+        const protoFee = alloc * feeRate * protoRate;
+        virtuals[tokenInIndex] += alloc - protoFee;
+        actuals[tokenInIndex] += alloc - protoFee;
+        virtuals[i] -= out;
+        actuals[i] -= out;
+    }
+    const mintRatio = estBpt / supply;
+    for (let i = 0; i < n; i++) {
+        actuals[i] += toWhole(depositedAmounts[i] ?? 0n, decimals[i]);
+        virtuals[i] *= 1 + mintRatio;
+    }
+    let logInvariant = 0;
+    let logTarget = 0;
+    for (let i = 0; i < n; i++) {
+        if (weights[i] <= 0 || virtuals[i] <= 0)
+            return null;
+        logInvariant += weights[i] * Math.log(virtuals[i]);
+        logTarget += weights[i] * Math.log(weights[i] / prices[i]);
+    }
+    const lambda = Math.exp(logInvariant - logTarget);
+    let equilibriumPoolValue = 0;
+    for (let i = 0; i < n; i++) {
+        const equilibriumVirtual = (lambda * weights[i]) / prices[i];
+        const equilibriumActual = Math.max(0, actuals[i] - (virtuals[i] - equilibriumVirtual));
+        equilibriumPoolValue += equilibriumActual * prices[i];
+    }
+    const lpValue = (mintRatio / (1 + mintRatio)) * equilibriumPoolValue;
+    let refundValue = 0;
+    for (let i = 0; i < n; i++) {
+        refundValue += toWhole(refundAmounts[i] ?? 0n, decimals[i]) * prices[i];
+    }
+    const depositValue = amountInWhole * prices[tokenInIndex];
+    if (depositValue <= 0)
+        return null;
+    const loss = 1 - (lpValue + refundValue) / depositValue;
+    return Math.min(100, Math.max(0, loss * 100));
+}
+//# sourceMappingURL=lpLoss.js.map

package/dist/math/lpLoss.js.map

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

package/dist/math/maxSelloff.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Sliding-window cumulative-sell rate limiter + variable sell-off surge fee.
+ *
+ * Port of the v5.1 (post-audit) contracts:
+ *   `programs/cubic-pool/src/math/max_selloff.rs` (`check_and_advance`)
+ *   `programs/cubic-pool/src/math/surge_fee.rs`  (`calc_surge_fee_pct`)
+ *   `programs/cubic-pool/src/instructions/user/swap.rs` (segmented charge)
+ *
+ * All arithmetic is bigint, mirroring the Rust u128 intermediates INCLUDING
+ * integer-division order — do not "simplify" a `a*b/c` into a different
+ * association, parity with the on-chain result depends on it. BN appears
+ * only at the SDK boundary.
+ *
+ * v5.1 curve model: the fee RATE is piecewise-LINEAR in the normalized
+ * window-fill coordinate `t ∈ [0, 1]` (threshold → 100% fill):
+ *   - no kink: low → high over [0, 1]
+ *   - kinked:  low → mid over [0, k], mid → high over [k, 1]
+ * and a swap is charged the AVERAGE rate over the span it crosses
+ * (integral / width), which makes the fee path-independent — splitting a
+ * sell into parts cannot cheapen it (audit M-05). The old exponential
+ * convexity curve (A^t) is gone.
+ */
+import BN from "bn.js";
+/** Mirrors cubic-pool::constants::SURGE_FEE_SEGMENTS. */
+export declare const SURGE_FEE_SEGMENTS = 4;
+export interface SelloffWindowInputs {
+    maxSelloffPct: number;
+    periodLength: number;
+    previousSelloff: BN;
+    currentSelloff: BN;
+    windowStartTimestamp: BN;
+    selloffVbSnapshot: BN;
+    /** Current pre-trade virtual balance of the token. */
+    virtualBalance: BN;
+    /** Unix seconds. */
+    now: number;
+}
+export interface SelloffWindowStatus {
+    /** True when the limiter is configured (`maxSelloffPct > 0`). */
+    enabled: boolean;
+    cap: BN;
+    /** Effective decayed usage WITHOUT a hypothetical trade. */
+    used: BN;
+    /** `max(0, cap - used)`. */
+    remaining: BN;
+    /** `used/cap` in PERCENT_SCALE units (0..10_000+); 0 when disabled/cap=0. */
+    fillPct: number;
+    windowStartTimestamp: BN;
+    periodLength: number;
+    /** Whether the projection at `now` rotated the window vs stored state. */
+    rotated: boolean;
+    /** Snapshot the cap was resolved against (post-projection). */
+    vbSnapshot: BN;
+}
+/** Result of the pure bigint window projection. */
+export interface WindowProjection {
+    opened: boolean;
+    windowStart: bigint;
+    elapsedInWindow: bigint;
+    /** Carried-over previous usage, POST v5.1 snapshot rescale. */
+    previous: bigint;
+    current: bigint;
+    vbSnapshot: bigint;
+    cap: bigint;
+    weightedPrev: bigint;
+    /** weightedPrev + current (decayed effective, WITHOUT a hypothetical trade). */
+    usedWithoutTrade: bigint;
+}
+/**
+ * Pure bigint projection of the sliding window at `now`. Mirrors v5.1
+ * `check_and_advance`'s rotation + snapshot logic (read-only, no
+ * `amount_in`), including the audit addition: when the projection OPENS a
+ * window against a new vb snapshot, the carried-over `previous` usage is
+ * rescaled by `newSnapshot / oldSnapshot` so a liquidity change between
+ * windows doesn't distort the carried percentage.
+ */
+export declare function projectSelloffWindow(params: {
+    maxSelloffPct: number;
+    periodLength: number;
+    previousSelloff: bigint;
+    currentSelloff: bigint;
+    windowStartTimestamp: bigint;
+    selloffVbSnapshot: bigint;
+    virtualBalance: bigint;
+    now: number;
+}): WindowProjection;
+/** Read-only status of a token's max-selloff window at `now`. */
+export declare function computeSelloffWindow(inputs: SelloffWindowInputs): SelloffWindowStatus;
+/**
+ * Average surge-fee percentage (PERCENT_SCALE units, 0..=10_000) charged for
+ * moving the window fill from `effectiveSelloffBefore` to
+ * `effectiveSelloffAfter` against `cap`. Port of v5.1 `calc_surge_fee_pct`:
+ * the rate is INTEGRATED over the crossed span (CEIL), so the charge is
+ * path-independent. When the span is empty (`after <= before`) the point
+ * rate at `after` is returned.
+ */
+export declare function calcSurgeFeePct(effectiveSelloffBefore: bigint, effectiveSelloffAfter: bigint, cap: bigint, thresholdPct: number, slopeLowPct: number, slopeMidPct: number, slopeHighPct: number, kinkPct: number): number;
+/**
+ * CEIL fee application of a known percentage on `amount`, clamped to
+ * `amount`. NOTE: the contract does NOT charge the whole output at one
+ * rate — use {@link calcSegmentedSurgeFeeAmount} to mirror an actual swap.
+ * This helper remains for coarse display math only.
+ */
+export declare function calcSurgeFeeAmount(amountOut: bigint, surgePct: number): bigint;
+export interface SegmentedSurgeFeeParams {
+    /** Window fill before the trade (`usedWithoutTrade`). */
+    effectiveSelloffBefore: bigint;
+    /** Window fill after the trade (`before + amountInNet`). */
+    effectiveSelloffAfter: bigint;
+    cap: bigint;
+    thresholdPct: number;
+    slopeLowPct: number;
+    slopeMidPct: number;
+    slopeHighPct: number;
+    kinkPct: number;
+    /** Post-swap-fee input driving the AMM curve (`amount_in_after_fee`). */
+    amountInAfterFee: bigint;
+    /** Full curve output of the trade (gross, pre-surge). */
+    amountOut: bigint;
+    /**
+     * Cumulative AMM output for an input slice `x ∈ [0, amountInAfterFee]`
+     * against the PRE-TRADE balances (i.e. `calc_out_given_in` with the same
+     * arguments that produced `amountOut`).
+     */
+    curveOut: (amountInSlice: bigint) => bigint;
+    /** Defaults to the contract's SURGE_FEE_SEGMENTS (= 4). */
+    segments?: number;
+}
+/**
+ * Surge fee in OUTPUT-token units for one swap — the exact v5.1 on-chain
+ * charge (swap.rs): only the output produced ABOVE the threshold is taxed,
+ * segment by segment across the taxed span, each segment's REAL curve
+ * output at that segment's average rate (CEIL per segment), total clamped
+ * to `amountOut`. Charging one average rate on the whole output would
+ * re-open the audit M-05 split dodge on asymmetric pools.
+ */
+export declare function calcSegmentedSurgeFeeAmount(p: SegmentedSurgeFeeParams): bigint;
+export interface SelloffState {
+    previousSelloff: bigint;
+    currentSelloff: bigint;
+    windowStartTimestamp: bigint;
+    selloffVbSnapshot: bigint;
+}
+export interface SelloffResult {
+    effectiveSelloffBefore: bigint;
+    effectiveSelloff: bigint;
+    maxSelloffCap: bigint;
+    vbSnapshot: bigint;
+    previousSelloff: bigint;
+    currentSelloff: bigint;
+    windowStartTimestamp: bigint;
+}
+/** Pure: does not modify its input, including on rejection. */
+export declare function checkAndAdvanceSelloff(params: {
+    state: SelloffState;
+    maxSelloffPct: number;
+    period: number;
+    amountIn: bigint;
+    virtualBalance: bigint;
+    now: bigint;
+}): SelloffResult | null;
+/** Mirror of window rescaling after proportional add/remove liquidity. */
+export declare function rescaleSelloffWindow(state: SelloffState, ratio: bigint, isIncrease: boolean, maxSelloffPct: number): SelloffState;
+//# sourceMappingURL=maxSelloff.d.ts.map

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

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