@logswap/sdk 0.5.52 → 0.5.54

package/dist/fpool.d.ts

@@ -807,7 +807,12 @@ export interface FPoolSwapArgs {
     /** Leg index into `bases`. */
     j: number;
     amountIn: bigint;
-    minOut?: bigint;
+    /**
+     * The least the swap must return. Required: an F swap is exact-in, and without a floor on the
+     * output a front-run takes the difference. {@link fPoolQuoteSwap} is exact; bound it with
+     * {@link withSlippage} (`"output"`).
+     */
+    minOut: bigint;
     /** Who receives the out leg. Defaults to the account. */
     to?: Address;
     /** Absolute unix seconds. Defaulted to a bounded window, as every router write is. */
@@ -825,10 +830,12 @@ export declare function fPoolSwapBaseForBase(c: LogswapClient, a: FPoolSwapArgs
     k: number;
 }): Promise<`0x${string}`>;
 /** Deposit dL/L of every reserve, receive shares ∝ dL. θ is untouched by construction. */
-export declare function fPoolMint(c: LogswapClient, a: {
+export declare function fPoolMint(c: LogswapClient, 
+/** `maxQuoteIn` is required: the quote leg is Q·dL/L at landing, and Q moves with every swap. */
+a: {
     poolId: Hex;
     dL: bigint;
-    maxQuoteIn?: bigint;
+    maxQuoteIn: bigint;
     account: Address;
     to?: Address;
 }): Promise<`0x${string}`>;
@@ -837,13 +844,28 @@ export declare function fPoolMint(c: LogswapClient, a: {
  * By owner since contracts `c782811` (decisions 019): the account burns its own shares; an
  * operator may pass another owner's address, as on the C manager's `burnById`.
  */
-export declare function fPoolBurn(c: LogswapClient, a: {
+export declare function fPoolBurn(c: LogswapClient, 
+/** `minQuoteOut` is required: the quote slice is Q·shares/S at landing. See {@link fPoolPreviewBurn}. */
+a: {
     poolId: Hex;
     shares: bigint;
-    minQuoteOut?: bigint;
+    minQuoteOut: bigint;
     account: Address;
     owner?: Address;
 }): Promise<`0x${string}`>;
+/**
+ * What burning `shares` returns at today's state — the manager's own arithmetic: every reserve and
+ * the quote pro rata, rounded down (FPoolManager.burn). Exact until the next swap or mint.
+ */
+export declare function fPoolPreviewBurn(st: Pick<FPoolState, "Q" | "reserves" | "totalSupply">, shares: bigint): {
+    quoteOut: bigint;
+    basesOut: bigint[];
+};
+/**
+ * The quote {@link fPoolMint} pulls for `dL` at today's state: Q·dL/L, rounded up (the pool never
+ * under-collects), before any mint fee — so bound it with {@link withSlippage} (`"input"`).
+ */
+export declare function fPoolPreviewMintQuote(st: Pick<FPoolState, "Q" | "L">, dL: bigint): bigint;
 /**
  * Quote needed to zap into exposure `dL`. An UPPER bound: buying each leg raises its mark, so the
  * mint consumes less base than was bought for it and every zap ends with a refund. Size from this
@@ -874,15 +896,28 @@ export declare function fPoolZapIn(c: LogswapClient, a: {
  * cross the floor; only the burn's own quote slice touches the quote leg. Into the quote every
  * base leg is sold, which is the one path a drained quote leg can block.
  */
-export declare function fPoolZapOut(c: LogswapClient, a: {
+export declare function fPoolZapOut(c: LogswapClient, 
+/** `minOut` is required: the sale routes every leg through the curve. See {@link fPoolPreviewZapOut}. */
+a: {
     poolId: Hex;
     shares: bigint;
     tokenOut: Address;
-    minOut?: bigint;
+    minOut: bigint;
     to?: Address;
     account: Address;
     deadline?: bigint;
 }): Promise<`0x${string}`>;
+/**
+ * What {@link fPoolZapOut} returns at today's state: the router's own `zapOut`, simulated as the
+ * holder with no bound. Exact, but it needs what the real call needs — the shares, and the router
+ * as the holder's ERC-6909 operator — so it throws where the zap-out itself would revert.
+ */
+export declare function fPoolPreviewZapOut(c: LogswapClient, a: {
+    poolId: Hex;
+    shares: bigint;
+    tokenOut: Address;
+    account: Address;
+}): Promise<bigint>;
 /**
  * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
  * router under one lock: redeem `shares` of generation `gen` in place — the legs, the quote and

package/dist/fpool.js

@@ -45,6 +45,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
  * in for the base — a call through it to any of the four policies decodes the base's functions.
  */
 export const fPolicyBaseAbi = polPolicyAbi;
+import { signerFor } from "./write.js";
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 /** The optional questions a policy declared at birth (decisions 044), as bits of `Pool.asks`. */
@@ -222,7 +223,7 @@ export function fPoolShareValue(s) {
 async function fSwap(c, a, kind, k = 0) {
     const st = await getFPool(c, a.poolId);
     const pull = kind === FPoolQuoteKind.QuoteIn ? st.quote : st.bases[a.j];
-    return writeRouter(c, "swapExactIn", [a.poolId, kind, BigInt(a.j), BigInt(k), a.amountIn, a.minOut ?? 0n, a.to ?? a.account, a.deadline ?? defaultDeadline()], a.account, [pull]);
+    return writeRouter(c, "swapExactIn", [a.poolId, kind, BigInt(a.j), BigInt(k), a.amountIn, a.minOut, a.to ?? a.account, a.deadline ?? defaultDeadline()], a.account, [pull]);
 }
 export async function fPoolSwapQuoteIn(c, a) {
     return fSwap(c, a, FPoolQuoteKind.QuoteIn);
@@ -240,17 +241,37 @@ export async function fPoolSwapBaseForBase(c, a) {
 }
 // ─── liquidity ────────────────────────────────────────────────────────────────
 /** Deposit dL/L of every reserve, receive shares ∝ dL. θ is untouched by construction. */
-export async function fPoolMint(c, a) {
+export async function fPoolMint(c, 
+/** `maxQuoteIn` is required: the quote leg is Q·dL/L at landing, and Q moves with every swap. */
+a) {
     // shares go to `to` (the account by default); on a gated pool `to` must be allowed
-    return writeFPool(c, a.poolId, "mint", [a.to ?? a.account, a.dL, a.maxQuoteIn ?? 2n ** 256n - 1n], a.account);
+    return writeFPool(c, a.poolId, "mint", [a.to ?? a.account, a.dL, a.maxQuoteIn], a.account);
 }
 /**
  * Burn shares for the pro-rata slice of every reserve. Available at any Q, and after dissolution.
  * By owner since contracts `c782811` (decisions 019): the account burns its own shares; an
  * operator may pass another owner's address, as on the C manager's `burnById`.
  */
-export async function fPoolBurn(c, a) {
-    return writeFPool(c, a.poolId, "burn", [a.owner ?? a.account, a.shares, a.minQuoteOut ?? 0n], a.account);
+export async function fPoolBurn(c, 
+/** `minQuoteOut` is required: the quote slice is Q·shares/S at landing. See {@link fPoolPreviewBurn}. */
+a) {
+    return writeFPool(c, a.poolId, "burn", [a.owner ?? a.account, a.shares, a.minQuoteOut], a.account);
+}
+/**
+ * What burning `shares` returns at today's state — the manager's own arithmetic: every reserve and
+ * the quote pro rata, rounded down (FPoolManager.burn). Exact until the next swap or mint.
+ */
+export function fPoolPreviewBurn(st, shares) {
+    if (st.totalSupply === 0n)
+        return { quoteOut: 0n, basesOut: st.reserves.map(() => 0n) };
+    return { quoteOut: (st.Q * shares) / st.totalSupply, basesOut: st.reserves.map((r) => (r * shares) / st.totalSupply) };
+}
+/**
+ * The quote {@link fPoolMint} pulls for `dL` at today's state: Q·dL/L, rounded up (the pool never
+ * under-collects), before any mint fee — so bound it with {@link withSlippage} (`"input"`).
+ */
+export function fPoolPreviewMintQuote(st, dL) {
+    return st.L === 0n ? 0n : (st.Q * dL + st.L - 1n) / st.L;
 }
 // ─── zaps (on the router — one router, one Permit2 spender) ───────────────────
 /**
@@ -288,9 +309,26 @@ export async function fPoolZapIn(c, a) {
  * cross the floor; only the burn's own quote slice touches the quote leg. Into the quote every
  * base leg is sold, which is the one path a drained quote leg can block.
  */
-export async function fPoolZapOut(c, a) {
+export async function fPoolZapOut(c, 
+/** `minOut` is required: the sale routes every leg through the curve. See {@link fPoolPreviewZapOut}. */
+a) {
     const to = a.to ?? a.account;
-    return writeRouter(c, "zapOut", [a.poolId, a.shares, a.tokenOut, a.minOut ?? 0n, to, a.deadline ?? defaultDeadline()], a.account);
+    return writeRouter(c, "zapOut", [a.poolId, a.shares, a.tokenOut, a.minOut, to, a.deadline ?? defaultDeadline()], a.account);
+}
+/**
+ * What {@link fPoolZapOut} returns at today's state: the router's own `zapOut`, simulated as the
+ * holder with no bound. Exact, but it needs what the real call needs — the shares, and the router
+ * as the holder's ERC-6909 operator — so it throws where the zap-out itself would revert.
+ */
+export async function fPoolPreviewZapOut(c, a) {
+    const { result } = await c.public.simulateContract({
+        address: c.addresses.router,
+        abi: logswapRouterAbi,
+        functionName: "zapOut",
+        args: [a.poolId, a.shares, a.tokenOut, 0n, a.account, defaultDeadline()],
+        account: a.account,
+    });
+    return result;
 }
 /**
  * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
@@ -373,7 +411,7 @@ async function writeFPool(c, poolId, functionName, args, account) {
         // one place all seven helpers share, is what keeps a caller from ever omitting it. The `as
         // never` casts blind tsc to arg counts, so this file's encode test is the real guard.
         args: [poolId, ...args],
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -385,7 +423,7 @@ async function writeFPool0(c, functionName, args, account) {
         abi: fPoolManagerAbi,
         functionName,
         args,
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -410,7 +448,7 @@ pullTokens = []) {
         abi: logswapRouterAbi,
         functionName: fn,
         args: sendArgs,
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -465,7 +503,7 @@ export async function approveRouterForFPool(c, account) {
         abi: fPoolManagerAbi,
         functionName: "setOperator",
         args: [c.addresses.router, true],
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -863,7 +901,7 @@ async function writePolicy(c, abi, a, functionName, args) {
         abi,
         functionName,
         args: [a.poolId, ...args],
-        account: a.account,
+        account: signerFor(c, a.account),
     });
     return wallet.writeContract(request);
 }
@@ -934,7 +972,7 @@ export async function fPoolSetSponsorName(c, a) {
         abi: policyRegistryAbi,
         functionName: "setSponsorName",
         args: [a.who, textToBytes32(a.name)],
-        account: a.account,
+        account: signerFor(c, a.account),
     });
     return wallet.writeContract(request);
 }
@@ -998,7 +1036,7 @@ export async function fPoolTransferShares(c, a) {
         abi: fPoolManagerAbi,
         functionName: "transfer",
         args: [a.to, fPoolShareId(a.poolId, gen), a.shares],
-        account: a.account,
+        account: signerFor(c, a.account),
     });
     return wallet.writeContract(request);
 }

package/dist/indexer.d.ts

@@ -25,7 +25,22 @@ export interface IndexerError {
  * `Syntax Error: Invalid character escape sequence`. Variables carry the value untouched.
  */
 export declare function bytea(hex: Hex): string;
+/** How long an indexer call may take before the caller falls back (to the chain, or an empty view). */
+export declare const INDEXER_TIMEOUT_MS = 8000;
 export declare function gql<T>(url: string, query: string, variables?: Record<string, unknown>, signal?: AbortSignal): Promise<T>;
+/**
+ * Every row of a connection, page by page. A single `first: 1000` silently drops row 1001 onward —
+ * a pool's 1001st position class, a deployment's 1001st market — with nothing to say so. Pages by
+ * cursor in primary-key order, so rows inserted while paging cannot shift the window.
+ */
+export declare function gqlAll<N>(url: string, field: string, selection: string, opts?: {
+    vars?: Record<string, {
+        type: string;
+        value: unknown;
+    }>;
+    condition?: string;
+    signal?: AbortSignal;
+}): Promise<N[]>;
 /** A position class as the chain registered it: the floor/cap geometry, fixed for the id's life. */
 export interface RegisteredId {
     id: bigint;

package/dist/indexer.js

@@ -25,15 +25,24 @@ import { NO_CAP } from "./ids.js";
 export function bytea(hex) {
     return `\\x${hex.replace(/^0x/, "")}`;
 }
+/** How long an indexer call may take before the caller falls back (to the chain, or an empty view). */
+export const INDEXER_TIMEOUT_MS = 8_000;
 export async function gql(url, query, variables, signal) {
+    // A hung indexer must not hang its caller: every consumer has a fallback, and it only runs when
+    // this call ends. The caller's signal, if any, still wins.
     const res = await fetch(url, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ query, variables }),
-        signal,
+        signal: signal ?? AbortSignal.timeout(INDEXER_TIMEOUT_MS),
     });
     if (!res.ok)
         throw new Error(`indexer: HTTP ${res.status} from ${url}`);
+    // an Access login page or a proxy's error page answers 200 with HTML; say so, rather than
+    // "Unexpected token <"
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct.includes("json"))
+        throw new Error(`indexer: ${url} answered ${ct || "no content-type"}, not JSON (a login page?)`);
     const body = (await res.json());
     if (body.errors?.length)
         throw new Error(`indexer: ${body.errors.map((e) => e.message).join("; ")}`);
@@ -41,13 +50,43 @@ export async function gql(url, query, variables, signal) {
         throw new Error("indexer: empty response");
     return body.data;
 }
+const PAGE = 1000;
+const MAX_PAGES = 100;
+/**
+ * Every row of a connection, page by page. A single `first: 1000` silently drops row 1001 onward —
+ * a pool's 1001st position class, a deployment's 1001st market — with nothing to say so. Pages by
+ * cursor in primary-key order, so rows inserted while paging cannot shift the window.
+ */
+export async function gqlAll(url, field, selection, opts = {}) {
+    const vars = opts.vars ?? {};
+    const decl = Object.entries(vars).map(([k, v]) => `, $${k}: ${v.type}`).join("");
+    const cond = opts.condition ? `, condition: ${opts.condition}` : "";
+    const q = `query Page($after: Cursor${decl}) {
+    ${field}(first: ${PAGE}, after: $after, orderBy: PRIMARY_KEY_ASC${cond}) {
+      pageInfo { hasNextPage endCursor } nodes { ${selection} }
+    }
+  }`;
+    const values = Object.fromEntries(Object.entries(vars).map(([k, v]) => [k, v.value]));
+    const out = [];
+    let after = null;
+    for (let i = 0; i < MAX_PAGES; i++) {
+        const d = await gql(url, q, { ...values, after }, opts.signal);
+        const page = d[field];
+        out.push(...page.nodes);
+        if (!page.pageInfo.hasNextPage || !page.pageInfo.endCursor)
+            return out;
+        after = page.pageInfo.endCursor;
+    }
+    throw new Error(`indexer: ${field} has more than ${PAGE * MAX_PAGES} rows`);
+}
 /** Every position class ever registered in a pool. Historical — some may since have burnt to zero. */
 export async function registeredIds(url, poolId, signal) {
-    const q = `query Ids($pool: String!) {
-    allIdRegistereds(condition: {poolId: $pool}, first: 1000) { nodes { id floor cap capped } }
-  }`;
-    const d = await gql(url, q, { pool: bytea(poolId) }, signal);
-    return d.allIdRegistereds.nodes.map((n) => ({
+    const nodes = await gqlAll(url, "allIdRegistereds", "id floor cap capped", {
+        vars: { pool: { type: "String!", value: bytea(poolId) } },
+        condition: "{poolId: $pool}",
+        signal,
+    });
+    return nodes.map((n) => ({
         id: BigInt(n.id),
         floor: BigInt(n.floor),
         cap: BigInt(n.cap),
@@ -99,11 +138,8 @@ export async function indexerHealthy(url, signal) {
  * everywhere else, so a wrong id fails loudly instead of addressing the wrong pool.
  */
 export async function discoverMarketsIndexed(url, signal) {
-    const q = `{ allInitializes(first: 1000) { nodes {
-    poolId base quote tickSpacing phi x0 blockNumber txHash
-  } } }`;
-    const d = await gql(url, q, undefined, signal);
-    return d.allInitializes.nodes.map((n) => {
+    const nodes = await gqlAll(url, "allInitializes", "poolId base quote tickSpacing phi x0 blockNumber txHash contractAddress", { signal });
+    return nodes.map((n) => {
         const key = {
             base: n.base,
             quote: n.quote,
@@ -116,6 +152,7 @@ export async function discoverMarketsIndexed(url, signal) {
             x0: BigInt(n.x0),
             blockNumber: BigInt(n.blockNumber),
             transactionHash: n.txHash,
+            manager: n.contractAddress,
         };
     });
 }
@@ -129,29 +166,15 @@ export async function discoverMarketsBest(c, url, signal) {
     if (url) {
         try {
             const markets = await discoverMarketsIndexed(url, signal);
-            // The indexer is a CACHE and the chain is the truth. After a redeploy the indexer keeps
-            // serving the previous deployment's markets; calling the new manager with those keys makes
-            // every read revert, refresh-proof (it presented as "phiEff reverted", forever). So verify
-            // each candidate against the manager the client is actually pointed at, and keep only the
-            // markets that exist there; if none survive, the chain scan is the answer.
-            if (markets.length) {
-                const alive = (await Promise.all(markets.map(async (m) => {
-                    try {
-                        await c.public.readContract({
-                            address: c.addresses.cPoolManager,
-                            abi: cPoolManagerAbi,
-                            functionName: "phiOf",
-                            args: [m.key],
-                        });
-                        return m;
-                    }
-                    catch {
-                        return null;
-                    }
-                }))).filter((m) => m !== null);
-                if (alive.length)
-                    return { markets: alive, source: "indexer" };
-            }
+            // The indexer is a CACHE and the chain is the truth. After a redeploy it keeps serving the
+            // previous deployment's markets, and calling the new manager with those keys makes every
+            // read revert, refresh-proof. Each row names the manager that emitted it, so keep only the
+            // rows of the manager this client is pointed at — no read per row. None left means the
+            // indexer has not seen this deployment: the chain scan is the answer.
+            const mine = c.addresses.cPoolManager.toLowerCase();
+            const alive = markets.filter((m) => m.manager?.toLowerCase() === mine);
+            if (alive.length)
+                return { markets: alive, source: "indexer" };
         }
         catch {
             /* fall through — a missing indexer must not cost you the market list */

package/dist/liquidity.d.ts

@@ -33,8 +33,14 @@ export interface MintArgs extends WriteOptions {
     cap?: bigint;
     /** Exposure to add. */
     L: bigint;
-    maxBaseIn?: bigint;
-    maxQuoteIn?: bigint;
+    /**
+     * The most the mint may pull, per token. REQUIRED: the pulled amounts depend on spot when the
+     * transaction lands, so an unbounded mint can be sandwiched into depositing far more than the
+     * preview showed. Derive them from the preview with {@link withSlippage} (`"input"`); pass
+     * {@link UNBOUNDED} only where the price cannot move under you.
+     */
+    maxBaseIn: bigint;
+    maxQuoteIn: bigint;
 }
 /**
  * Mint at `targetFloor`, blending across the two adjacent rungs when it is off-grid.
@@ -55,8 +61,9 @@ export interface CreateMarketArgs extends WriteOptions {
     targetFloor: bigint;
     /** The founding exposure; must exceed the manager's `minBackstopL` lock. */
     L: bigint;
-    maxBaseIn?: bigint;
-    maxQuoteIn?: bigint;
+    /** Required, as on {@link mint}. Creation is atomic at `x0`, so the flows are fixed by the arguments; {@link UNBOUNDED} is safe here only for that reason. */
+    maxBaseIn: bigint;
+    maxQuoteIn: bigint;
 }
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
@@ -72,12 +79,13 @@ export interface ZapArgs extends WriteOptions {
     /** Fund entirely from base (true) or entirely from quote (false). */
     fundWithBase: boolean;
     amountIn: bigint;
-    /** The least the swap leg may return (contracts 7c82eed, decisions 043): the zap's own slippage bound, as `swapExactIn`'s. 0 = unbounded. */
-    minSwapOut?: bigint;
+    /** The least the swap leg may return (contracts 7c82eed, decisions 043): the zap's own slippage bound, as `swapExactIn`'s. Required. */
+    minSwapOut: bigint;
     targetFloor: bigint;
     cap?: bigint;
     L: bigint;
-    maxIn?: bigint;
+    /** The most of the funding token the zap may pull. Required. */
+    maxIn: bigint;
 }
 /**
  * Fund a mint from a single asset: the router swaps the imbalanced part through the curve, then
@@ -96,8 +104,9 @@ export interface UpdateArgs extends WriteOptions {
     toCap?: bigint;
     /** New exposure. `0n` exits the position entirely. */
     newL: bigint;
-    maxBaseIn?: bigint;
-    maxQuoteIn?: bigint;
+    /** Required: see {@link MintArgs}. {@link previewEdit} gives the exact flows to bound. */
+    maxBaseIn: bigint;
+    maxQuoteIn: bigint;
 }
 /** The primitive, through the router's named entry: resize and reposition in one call, in kind. */
 export declare function update(c: LogswapClient, a: UpdateArgs): Promise<Hash>;
@@ -107,16 +116,16 @@ export interface MoveArgs extends WriteOptions {
     shares: bigint;
     toFloor: bigint;
     toCap?: bigint;
-    maxBaseIn?: bigint;
-    maxQuoteIn?: bigint;
+    /** Required: see {@link MintArgs}. */
+    maxBaseIn: bigint;
+    maxQuoteIn: bigint;
 }
 /**
  * Reposition at constant exposure — the L-pinned parent of `floor`, `cap` and `shift`; in kind.
  *
  * **Bound it.** The router used to settle this entry with no limit, which meant a reposition that
  * priced differently by inclusion time could pull the whole allowance (security-review2 M-01).
- * The defaults below are unbounded for callers who genuinely want that; pass `maxBaseIn` /
- * `maxQuoteIn` from a preview for anything user-facing.
+ * The bounds are required; {@link UNBOUNDED} is an explicit, visible opt-out.
  */
 export declare function move(c: LogswapClient, a: MoveArgs): Promise<Hash>;
 /** Which token the edit settles in. `kind` moves both legs; `base` / `quote` nets the other side through the curve. */
@@ -128,6 +137,13 @@ export interface EditArgs extends WriteOptions, PairBounds {
     shares: bigint;
     /** Default `kind`. */
     settleIn?: SettleIn;
+    /**
+     * Tolerance in basis points, applied to the flows the edit is expected to move (the lens's
+     * exact preview, plus a quote of the netting swap when `settleIn` is one token). Required: an
+     * edit's flows depend on spot when it lands. An explicit bound in `PairBounds` overrides the one
+     * derived for that token.
+     */
+    slippageBps: number;
 }
 export interface EditPreview {
     /** Signed, + = the caller deposits; the mint fee is inside `dQuote`. */
@@ -146,11 +162,22 @@ export declare function previewEdit(c: LogswapClient, a: {
     toCap?: bigint;
     newL: bigint;
 }): Promise<EditPreview>;
+/**
+ * Bounds for a pair of signed flows (+ = the caller pays, − = the caller receives), at `bps` of
+ * tolerance: a payment is capped from above, a receipt floored from below, and a token that does
+ * not move in that direction is bound to zero.
+ */
+export declare function boundsFromFlows(dBase: bigint, dQuote: bigint, bps: number): Required<PairBounds>;
 /**
  * The general edit as a batch: `[update]`, plus — when `settleIn` is one token — the one swap that
  * nets the other. The other side's flow is read off the preview: released → sold with an exact-in
  * of `OPEN_DELTA`; owed → bought with an exact-out of `OPEN_DELTA`. The settlement then binds the
  * other token to zero both ways, so a stale preview fails loudly rather than moving it.
+ *
+ * **Bounded by default.** The preview gives the edit's exact flows at today's state; `slippageBps`
+ * turns them into the settlement's bounds. With `settleIn` one token, the netting swap is quoted
+ * on today's curve, before the update changes the active liquidity — close for a small edit, and
+ * for a large one a bound that reverts rather than one that lets a sandwich through.
  */
 export declare function edit(c: LogswapClient, a: EditArgs & {
     toFloor: bigint;
@@ -213,8 +240,9 @@ export interface BurnArgs extends WriteOptions {
     key: PoolKey;
     ids: readonly bigint[];
     shares: readonly bigint[];
-    minBaseOut?: bigint;
-    minQuoteOut?: bigint;
+    /** The least of each token the burn must return. Required: a burn's legs depend on spot. */
+    minBaseOut: bigint;
+    minQuoteOut: bigint;
 }
 /**
  * Exit, in kind, across one or more classes. Accrued fees are swept into the same settlement.