@logswap/sdk 0.5.52 → 0.5.54

package/src/liquidity.ts

@@ -46,8 +46,10 @@ import {
   resolveRecipient,
   sendRouterWrite,
   sendRouterWriteWithPermits,
+  withSlippage,
   type WriteOptions,
 } from "./write.js";
+import { quoteExactIn, quoteExactOut } from "./swap.js";
 
 /* mint ====================================================================== */
 
@@ -58,8 +60,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;
 }
 
 /**
@@ -73,7 +81,6 @@ export interface MintArgs extends WriteOptions {
  * costs zero quote too — that is what makes single-asset entry possible in both directions.
  */
 export async function mint(c: LogswapClient, a: MintArgs): Promise<Hash> {
-  const MAX = (1n << 256n) - 1n;
   return sendRouterWriteWithPermits(c, {
     abi: logswapRouterAbi,
     functionName: "mintBlended",
@@ -82,8 +89,8 @@ export async function mint(c: LogswapClient, a: MintArgs): Promise<Hash> {
       a.targetFloor,
       a.cap ?? NO_CAP,
       a.L,
-      a.maxBaseIn ?? MAX,
-      a.maxQuoteIn ?? MAX,
+      a.maxBaseIn,
+      a.maxQuoteIn,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],
@@ -98,8 +105,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;
 }
 
 /**
@@ -111,7 +119,6 @@ export interface CreateMarketArgs extends WriteOptions {
  * uncapped.
  */
 export async function createMarket(c: LogswapClient, a: CreateMarketArgs): Promise<Hash> {
-  const MAX = (1n << 256n) - 1n;
   return sendRouterWriteWithPermits(c, {
     abi: logswapRouterAbi,
     functionName: "createMarket",
@@ -120,8 +127,8 @@ export async function createMarket(c: LogswapClient, a: CreateMarketArgs): Promi
       a.x0,
       a.targetFloor,
       a.L,
-      a.maxBaseIn ?? MAX,
-      a.maxQuoteIn ?? MAX,
+      a.maxBaseIn,
+      a.maxQuoteIn,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],
@@ -133,12 +140,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;
 }
 
 /**
@@ -157,11 +165,11 @@ export async function zapIn(c: LogswapClient, a: ZapArgs): Promise<Hash> {
       a.key,
       a.fundWithBase,
       a.amountIn,
-      a.minSwapOut ?? 0n,
+      a.minSwapOut,
       a.targetFloor,
       a.cap ?? NO_CAP,
       a.L,
-      a.maxIn ?? (1n << 256n) - 1n,
+      a.maxIn,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],
@@ -178,13 +186,13 @@ 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 async function update(c: LogswapClient, a: UpdateArgs): Promise<Hash> {
-  const MAX = (1n << 256n) - 1n;
   return sendRouterWriteWithPermits(c, {
     abi: logswapRouterAbi,
     functionName: "update",
@@ -195,8 +203,8 @@ export async function update(c: LogswapClient, a: UpdateArgs): Promise<Hash> {
       a.toFloor,
       a.toCap ?? NO_CAP,
       a.newL,
-      a.maxBaseIn ?? MAX,
-      a.maxQuoteIn ?? MAX,
+      a.maxBaseIn,
+      a.maxQuoteIn,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],
@@ -209,8 +217,9 @@ export interface MoveArgs extends WriteOptions {
   shares: bigint;
   toFloor: bigint;
   toCap?: bigint;
-  maxBaseIn?: bigint;
-  maxQuoteIn?: bigint;
+  /** Required: see {@link MintArgs}. */
+  maxBaseIn: bigint;
+  maxQuoteIn: bigint;
 }
 
 /**
@@ -218,11 +227,9 @@ export interface MoveArgs extends WriteOptions {
  *
  * **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 async function move(c: LogswapClient, a: MoveArgs): Promise<Hash> {
-  const MAX = (1n << 256n) - 1n;
   return sendRouterWrite(c, {
     abi: logswapRouterAbi,
     functionName: "move",
@@ -232,8 +239,8 @@ export async function move(c: LogswapClient, a: MoveArgs): Promise<Hash> {
       a.shares,
       a.toFloor,
       a.toCap ?? NO_CAP,
-      a.maxBaseIn ?? MAX,
-      a.maxQuoteIn ?? MAX,
+      a.maxBaseIn,
+      a.maxQuoteIn,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],
@@ -252,6 +259,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 {
@@ -277,11 +291,27 @@ export async function previewEdit(
   return { dBase: r[0], dQuote: r[1], fees: r[2] };
 }
 
+/**
+ * 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 function boundsFromFlows(dBase: bigint, dQuote: bigint, bps: number): Required<PairBounds> {
+  const inb = (d: bigint) => (d > 0n ? withSlippage(d, bps, "input") : 0n);
+  const outb = (d: bigint) => (d < 0n ? withSlippage(-d, bps, "output") : 0n);
+  return { maxBaseIn: inb(dBase), maxQuoteIn: inb(dQuote), minBaseOut: outb(dBase), minQuoteOut: outb(dQuote) };
+}
+
 /**
  * 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 async function edit(c: LogswapClient, a: EditArgs & { toFloor: bigint; toCap?: bigint; newL: bigint }): Promise<Hash> {
   const { key } = a;
@@ -290,25 +320,39 @@ export async function edit(c: LogswapClient, a: EditArgs & { toFloor: bigint; to
     updateAction({ key, fromId: a.fromId, shares: a.shares, toFloor: a.toFloor, toCap: a.toCap, newL: a.newL }),
   ];
   const settleIn = a.settleIn ?? "kind";
+  const p = await previewEdit(c, { key, fromId: a.fromId, shares: a.shares, toFloor: a.toFloor, toCap: a.toCap, newL: a.newL });
   let settle: Settle;
   if (settleIn === "kind") {
-    settle = settleInKind(key, recipient, a);
+    settle = settleInKind(key, recipient, { ...boundsFromFlows(p.dBase, p.dQuote, a.slippageBps), ...defined(a) });
   } else {
-    const p = await previewEdit(c, { key, fromId: a.fromId, shares: a.shares, toFloor: a.toFloor, toCap: a.toCap, newL: a.newL });
     // the swept fees ride INSIDE dQuote (the manager burns by owner and nets them; decisions 018),
     // so quote's open delta after the update is dQuote itself — `fees` is reported for display only
     const otherFlow = settleIn === "base" ? p.dQuote : p.dBase; // + = owed, − = released
     const otherIsBase = settleIn === "quote";
-    if (otherFlow < 0n) actions.push(swapExactInAction({ key, baseIn: otherIsBase, amountIn: OPEN_DELTA }));
-    else if (otherFlow > 0n) actions.push(swapExactOutAction({ key, baseOut: otherIsBase, amountOut: OPEN_DELTA }));
+    let own = settleIn === "base" ? p.dBase : p.dQuote;
+    if (otherFlow < 0n) {
+      actions.push(swapExactInAction({ key, baseIn: otherIsBase, amountIn: OPEN_DELTA }));
+      own -= await quoteExactIn(c, key, otherIsBase, -otherFlow);
+    } else if (otherFlow > 0n) {
+      actions.push(swapExactOutAction({ key, baseOut: otherIsBase, amountOut: OPEN_DELTA }));
+      own += await quoteExactOut(c, key, otherIsBase, otherFlow);
+    }
+    const b = settleIn === "base" ? boundsFromFlows(own, 0n, a.slippageBps) : boundsFromFlows(0n, own, a.slippageBps);
     settle = settleOnly(key, recipient, settleIn, {
-      maxIn: settleIn === "base" ? a.maxBaseIn : a.maxQuoteIn,
-      minOut: settleIn === "base" ? a.minBaseOut : a.minQuoteOut,
+      maxIn: settleIn === "base" ? (a.maxBaseIn ?? b.maxBaseIn) : (a.maxQuoteIn ?? b.maxQuoteIn),
+      minOut: settleIn === "base" ? (a.minBaseOut ?? b.minBaseOut) : (a.minQuoteOut ?? b.minQuoteOut),
     });
   }
   return execute(c, { actions, settle, deadline: a.deadline, recipient });
 }
 
+/** The explicit bounds a caller passed, without the undefined ones (so they do not erase derived ones). */
+function defined(b: PairBounds): PairBounds {
+  return Object.fromEntries(
+    (["maxBaseIn", "maxQuoteIn", "minBaseOut", "minQuoteOut"] as const).filter((k) => b[k] !== undefined).map((k) => [k, b[k]]),
+  );
+}
+
 /** The class behind `shares` of `id`: its floor, cap, and the exposure those shares carry. */
 async function classOf(c: LogswapClient, key: PoolKey, id: bigint, shares: bigint) {
   const [d, cls] = await Promise.all([describeId(c, id, key.tickSpacing), getPositionClass(c, id)]);
@@ -405,8 +449,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;
 }
 
 /**
@@ -424,8 +469,8 @@ export async function burn(c: LogswapClient, a: BurnArgs): Promise<Hash> {
       a.key,
       a.ids,
       a.shares,
-      a.minBaseOut ?? 0n,
-      a.minQuoteOut ?? 0n,
+      a.minBaseOut,
+      a.minQuoteOut,
       resolveRecipient(c, a),
       resolveDeadline(a),
     ],

package/src/pools.ts

@@ -15,6 +15,7 @@
 import { formatUnits, type Address, type Hex } from "viem";
 import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
 import type { LogswapClient } from "./client.js";
+import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId, type PoolKey } from "./keys.js";
 
@@ -104,6 +105,8 @@ export interface DiscoveredMarket {
   x0: bigint;
   blockNumber: bigint;
   transactionHash: Hex;
+  /** The manager that emitted the `Initialize` — set when the row came from the indexer. */
+  manager?: Address;
 }
 
 /**
@@ -188,18 +191,10 @@ export async function marketDecimals(
   c: LogswapClient,
   key: PoolKey,
 ): Promise<{ base: number; quote: number }> {
-  const abi = [
-    { type: "function", name: "decimals", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
-  ] as const;
-  const read = async (token: Address): Promise<number> => {
-    try {
-      return Number(await c.public.readContract({ address: token, abi, functionName: "decimals" }));
-    } catch {
-      return 18; // same fallback the manager uses when the token does not implement it
-    }
-  };
-  const [base, quote] = await Promise.all([read(key.base), read(key.quote)]);
-  return { base, quote };
+  // It used to fall back to 18 on ANY failure, a dropped request included — a 6-decimal quote read
+  // as 18 is every amount 10^12 off. `marketTokens` retries and then refuses; so does this.
+  const { base, quote } = await marketTokens(c, key);
+  return { base: base.decimals, quote: quote.decimals };
 }
 
 /** A token as a UI needs it: address, symbol and decimals, all read from the chain. */
@@ -391,7 +386,7 @@ export async function initializeMarket(c: LogswapClient, a: { key: PoolKey; x0:
     abi: cPoolManagerAbi,
     functionName: "initialize",
     args: [a.key, a.x0],
-    account: a.account,
+    account: signerFor(c, a.account),
   } as never);
   return c.wallet!.writeContract(request as never);
 }

package/src/write.ts

@@ -46,6 +46,21 @@ export function resolveDeadline(o: WriteOptions | undefined, now = Date.now()):
  * until someone uses a key the node does not have — a bot, a script, CI, or a real user's wallet.
  * Passing the object lets viem pick the correct path for both kinds.
  */
+/**
+ * The wallet's account OBJECT for a write the caller named by address — see {@link requireWallet}
+ * for why the object and never the address. The F helpers take `account: Address` in their
+ * arguments; passed straight to viem it became a JSON-RPC account and the NODE was asked to sign,
+ * which works only on a dev node holding the key (every agent on the devnet did exactly that).
+ * A named account that is not the wallet's is refused: nothing else could sign for it.
+ */
+export function signerFor(c: LogswapClient, address: Address): NonNullable<LogswapClient["wallet"]>["account"] {
+  const { account } = requireWallet(c);
+  if (account!.address.toLowerCase() !== address.toLowerCase()) {
+    throw new Error(`logswap: the write names ${address} but the wallet signs as ${account!.address}`);
+  }
+  return account;
+}
+
 export function requireWallet(c: LogswapClient): { account: NonNullable<LogswapClient["wallet"]>["account"]; address: Address } {
   const account = c.wallet?.account;
   if (!c.wallet || !account) {
@@ -68,7 +83,8 @@ export function resolveRecipient(c: LogswapClient, o?: WriteOptions): Address {
 export function withSlippage(quoted: bigint, bps: number, side: "output" | "input"): bigint {
   if (bps < 0 || bps > 10_000) throw new Error(`logswap: slippage bps out of range: ${bps}`);
   const b = BigInt(Math.round(bps));
-  return side === "output" ? (quoted * (10_000n - b)) / 10_000n : (quoted * (10_000n + b)) / 10_000n;
+  // an input bound rounds UP: flooring it would put a wei-exact quote at bps = 0 one wei short
+  return side === "output" ? (quoted * (10_000n - b)) / 10_000n : (quoted * (10_000n + b) + 9_999n) / 10_000n;
 }
 
 /**