@logswap/sdk 0.5.66 → 0.5.67

package/dist/pools.d.ts

@@ -53,6 +53,32 @@ export declare function priceOf(state: Pick<PoolState, "x">, scale?: number): nu
  * it is 1 and nothing changes.
  */
 export declare function priceScale(baseDecimals: number, quoteDecimals: number): number;
+/** The C manager's log-price wall: |x| ≤ 46 on the WEI ratio (`MAX_ABS_FLOOR`). */
+export declare const C_MAX_ABS_X = 46;
+/** The least derived base reserve a C book keeps, in base wei (`MIN_RESERVE`, decisions 023). */
+export declare const C_MIN_RESERVE: bigint;
+/**
+ * The prices a C market can hold, in human units — quote per whole base token (decisions 054).
+ *
+ * - `listMin`, `listMax`: the wall, `10^(base − quote) · e^{∓46}`. A market cannot be initialized,
+ *   and no floor or cap placed, outside it. An 18-dec token against 6-dec USDC cannot list under
+ *   1.05e-8; against an 18-dec quote the same token lists down to 1.05e-20.
+ * - `ceiling`: the highest price the book can trade to with `lActive` of active exposure (quote
+ *   wei): the derived reserve `lActive / p` must stay at or above `C_MIN_RESERVE` base wei, so
+ *   `ceiling = lActive · 10^(base − quote) / 1e6`, capped by `listMax`. In whole units that is
+ *   `L · 10^(base − 6)`: the quote's decimals cancel and the base's set it — harmless on an
+ *   18-dec base, but a WBTC book of 1,000 USDC of depth stops at 100,000. Omit `lActive` for the
+ *   wall alone.
+ *
+ * Floats, for display and warnings; the chain is the authority.
+ */
+export declare function cPriceRange(baseDecimals: number, quoteDecimals: number, lActive?: bigint): {
+    listMin: number;
+    listMax: number;
+    ceiling: number;
+};
+/** Whether a C market can be initialized at `price` (human units) for this pair's decimals. */
+export declare function cListable(price: number, baseDecimals: number, quoteDecimals: number): boolean;
 /**
  * The model-free LP edge, $F - \tfrac12\Sigma$ — the protocol's headline metric, in quote per unit
  * of exposure.

package/dist/pools.js

@@ -55,6 +55,37 @@ export function priceOf(state, scale = 1) {
 export function priceScale(baseDecimals, quoteDecimals) {
     return 10 ** (baseDecimals - quoteDecimals);
 }
+/** The C manager's log-price wall: |x| ≤ 46 on the WEI ratio (`MAX_ABS_FLOOR`). */
+export const C_MAX_ABS_X = 46;
+/** The least derived base reserve a C book keeps, in base wei (`MIN_RESERVE`, decisions 023). */
+export const C_MIN_RESERVE = 10n ** 6n;
+/**
+ * The prices a C market can hold, in human units — quote per whole base token (decisions 054).
+ *
+ * - `listMin`, `listMax`: the wall, `10^(base − quote) · e^{∓46}`. A market cannot be initialized,
+ *   and no floor or cap placed, outside it. An 18-dec token against 6-dec USDC cannot list under
+ *   1.05e-8; against an 18-dec quote the same token lists down to 1.05e-20.
+ * - `ceiling`: the highest price the book can trade to with `lActive` of active exposure (quote
+ *   wei): the derived reserve `lActive / p` must stay at or above `C_MIN_RESERVE` base wei, so
+ *   `ceiling = lActive · 10^(base − quote) / 1e6`, capped by `listMax`. In whole units that is
+ *   `L · 10^(base − 6)`: the quote's decimals cancel and the base's set it — harmless on an
+ *   18-dec base, but a WBTC book of 1,000 USDC of depth stops at 100,000. Omit `lActive` for the
+ *   wall alone.
+ *
+ * Floats, for display and warnings; the chain is the authority.
+ */
+export function cPriceRange(baseDecimals, quoteDecimals, lActive) {
+    const scale = priceScale(baseDecimals, quoteDecimals);
+    const listMin = Math.exp(-C_MAX_ABS_X) * scale;
+    const listMax = Math.exp(C_MAX_ABS_X) * scale;
+    const ceiling = lActive === undefined || lActive === 0n ? listMax : Math.min(listMax, (Number(lActive) / Number(C_MIN_RESERVE)) * scale);
+    return { listMin, listMax, ceiling };
+}
+/** Whether a C market can be initialized at `price` (human units) for this pair's decimals. */
+export function cListable(price, baseDecimals, quoteDecimals) {
+    const { listMin, listMax } = cPriceRange(baseDecimals, quoteDecimals);
+    return price >= listMin && price <= listMax;
+}
 /**
  * The model-free LP edge, $F - \tfrac12\Sigma$ — the protocol's headline metric, in quote per unit
  * of exposure.

package/dist/write.d.ts

@@ -59,6 +59,29 @@ export declare function resolveRecipient(c: LogswapClient, o?: WriteOptions): Ad
  * bound at all because it looks protective.
  */
 export declare function withSlippage(quoted: bigint, bps: number, side: "output" | "input"): bigint;
+type AbiError = {
+    type: "error";
+    name: string;
+    inputs: readonly {
+        type: string;
+    }[];
+};
+/**
+ * Every custom error a router call can revert with that the router's own ABI does not declare: the
+ * C and F managers' (a mint, a swap or a settlement bubbles them up unchanged) and Permit2's.
+ * Without them viem can name only the router's errors, and anything raised in the manager comes
+ * back as a bare selector.
+ */
+export declare const routerRevertErrors: readonly AbiError[];
+/** `abi` plus every error in {@link routerRevertErrors} it does not already declare. */
+export declare function withRevertErrors(abi: readonly unknown[]): readonly unknown[];
+/**
+ * The decoded revert of a contract call, e.g. `SlippageIn()` or `AllowanceExpired(1700000000)`,
+ * found however deep viem nested it; the raw selector when the error is not in the ABI; undefined
+ * when the failure was not a revert. viem's `message` puts the name on its second line, so a UI
+ * that shows only the first line ("The contract function … reverted.") loses it.
+ */
+export declare function revertName(e: unknown): string | undefined;
 /**
  * Send a router write with a gas buffer over an explicit estimate.
  *
@@ -104,3 +127,4 @@ export declare function sendRouterWriteWithPermits(c: LogswapClient, args: {
     args: readonly unknown[];
     bufferPct?: bigint;
 }, pullTokens: Address[]): Promise<Hash>;
+export {};

package/dist/write.js

@@ -12,6 +12,7 @@
  * raw `minOut`/`maxIn` the contract wants. `withSlippage()` derives one from a quote when that is
  * what you have — but the bound is what ships.
  */
+import { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
 /** Disables the deadline check. Deliberate opt-out, never a default. */
 export const NEVER = (1n << 256n) - 1n;
 /** Default deadline window: 20 minutes, the same order as every major DEX front end. */
@@ -70,6 +71,59 @@ export function withSlippage(quoted, bps, side) {
     // an input bound rounds UP: flooring it would put a wei-exact quote at bps = 0 one wei short
     return side === "output" ? (quoted * (10000n - b)) / 10000n : (quoted * (10000n + b) + 9999n) / 10000n;
 }
+/** Permit2's pull errors — Uniswap's and the devnet mock's — which a router write can revert with. */
+const permit2Errors = [
+    { type: "error", name: "AllowanceExpired", inputs: [{ type: "uint256" }] },
+    { type: "error", name: "InsufficientAllowance", inputs: [{ type: "uint256" }] },
+    { type: "error", name: "AllowanceExpired", inputs: [] },
+    { type: "error", name: "NotAllowed", inputs: [] },
+];
+const errorKey = (e) => `${e.name}(${e.inputs.map((i) => i.type).join(",")})`;
+/**
+ * Every custom error a router call can revert with that the router's own ABI does not declare: the
+ * C and F managers' (a mint, a swap or a settlement bubbles them up unchanged) and Permit2's.
+ * Without them viem can name only the router's errors, and anything raised in the manager comes
+ * back as a bare selector.
+ */
+export const routerRevertErrors = (() => {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...cPoolManagerAbi, ...fPoolManagerAbi, ...permit2Errors]) {
+        if (x.type !== "error")
+            continue;
+        const e = x;
+        if (!seen.has(errorKey(e))) {
+            seen.add(errorKey(e));
+            out.push(e);
+        }
+    }
+    return out;
+})();
+/** `abi` plus every error in {@link routerRevertErrors} it does not already declare. */
+export function withRevertErrors(abi) {
+    const have = new Set(abi.filter((x) => x.type === "error").map((x) => errorKey(x)));
+    return [...abi, ...routerRevertErrors.filter((e) => !have.has(errorKey(e)))];
+}
+/**
+ * The decoded revert of a contract call, e.g. `SlippageIn()` or `AllowanceExpired(1700000000)`,
+ * found however deep viem nested it; the raw selector when the error is not in the ABI; undefined
+ * when the failure was not a revert. viem's `message` puts the name on its second line, so a UI
+ * that shows only the first line ("The contract function … reverted.") loses it.
+ */
+export function revertName(e) {
+    const seen = new Set();
+    for (let x = e; x && typeof x === "object" && !seen.has(x); x = x.cause) {
+        seen.add(x);
+        const o = x;
+        if (o.name !== "ContractFunctionRevertedError")
+            continue;
+        if (o.data?.errorName)
+            return `${o.data.errorName}(${(o.data.args ?? []).map(String).join(", ")})`;
+        if (o.signature)
+            return o.signature;
+    }
+    return undefined;
+}
 /**
  * Send a router write with a gas buffer over an explicit estimate.
  *
@@ -82,7 +136,7 @@ export async function sendRouterWrite(c, args) {
     const { account } = requireWallet(c);
     const params = {
         address: c.addresses.router,
-        abi: args.abi,
+        abi: withRevertErrors(args.abi),
         functionName: args.functionName,
         args: args.args,
         account,
@@ -122,7 +176,7 @@ export async function simulateRouterWrite(c, args) {
     const account = args.account ?? c.wallet?.account?.address;
     const { result } = await c.public.simulateContract({
         address: c.addresses.router,
-        abi: args.abi,
+        abi: withRevertErrors(args.abi),
         functionName: args.functionName,
         args: args.args,
         account,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.66",
+  "version": "0.5.67",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/pools.ts

@@ -82,6 +82,46 @@ export function priceScale(baseDecimals: number, quoteDecimals: number): number
   return 10 ** (baseDecimals - quoteDecimals);
 }
 
+/** The C manager's log-price wall: |x| ≤ 46 on the WEI ratio (`MAX_ABS_FLOOR`). */
+export const C_MAX_ABS_X = 46;
+
+/** The least derived base reserve a C book keeps, in base wei (`MIN_RESERVE`, decisions 023). */
+export const C_MIN_RESERVE = 10n ** 6n;
+
+/**
+ * The prices a C market can hold, in human units — quote per whole base token (decisions 054).
+ *
+ * - `listMin`, `listMax`: the wall, `10^(base − quote) · e^{∓46}`. A market cannot be initialized,
+ *   and no floor or cap placed, outside it. An 18-dec token against 6-dec USDC cannot list under
+ *   1.05e-8; against an 18-dec quote the same token lists down to 1.05e-20.
+ * - `ceiling`: the highest price the book can trade to with `lActive` of active exposure (quote
+ *   wei): the derived reserve `lActive / p` must stay at or above `C_MIN_RESERVE` base wei, so
+ *   `ceiling = lActive · 10^(base − quote) / 1e6`, capped by `listMax`. In whole units that is
+ *   `L · 10^(base − 6)`: the quote's decimals cancel and the base's set it — harmless on an
+ *   18-dec base, but a WBTC book of 1,000 USDC of depth stops at 100,000. Omit `lActive` for the
+ *   wall alone.
+ *
+ * Floats, for display and warnings; the chain is the authority.
+ */
+export function cPriceRange(
+  baseDecimals: number,
+  quoteDecimals: number,
+  lActive?: bigint,
+): { listMin: number; listMax: number; ceiling: number } {
+  const scale = priceScale(baseDecimals, quoteDecimals);
+  const listMin = Math.exp(-C_MAX_ABS_X) * scale;
+  const listMax = Math.exp(C_MAX_ABS_X) * scale;
+  const ceiling =
+    lActive === undefined || lActive === 0n ? listMax : Math.min(listMax, (Number(lActive) / Number(C_MIN_RESERVE)) * scale);
+  return { listMin, listMax, ceiling };
+}
+
+/** Whether a C market can be initialized at `price` (human units) for this pair's decimals. */
+export function cListable(price: number, baseDecimals: number, quoteDecimals: number): boolean {
+  const { listMin, listMax } = cPriceRange(baseDecimals, quoteDecimals);
+  return price >= listMin && price <= listMax;
+}
+
 /**
  * The model-free LP edge, $F - \tfrac12\Sigma$ — the protocol's headline metric, in quote per unit
  * of exposure.

package/src/write.ts

@@ -15,6 +15,7 @@
 
 import type { Address, Hash, Hex } from "viem";
 import type { LogswapClient } from "./client.js";
+import { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
 
 /** Disables the deadline check. Deliberate opt-out, never a default. */
 export const NEVER = (1n << 256n) - 1n;
@@ -87,6 +88,64 @@ export function withSlippage(quoted: bigint, bps: number, side: "output" | "inpu
   return side === "output" ? (quoted * (10_000n - b)) / 10_000n : (quoted * (10_000n + b) + 9_999n) / 10_000n;
 }
 
+type AbiError = { type: "error"; name: string; inputs: readonly { type: string }[] };
+
+/** Permit2's pull errors — Uniswap's and the devnet mock's — which a router write can revert with. */
+const permit2Errors: readonly AbiError[] = [
+  { type: "error", name: "AllowanceExpired", inputs: [{ type: "uint256" }] },
+  { type: "error", name: "InsufficientAllowance", inputs: [{ type: "uint256" }] },
+  { type: "error", name: "AllowanceExpired", inputs: [] },
+  { type: "error", name: "NotAllowed", inputs: [] },
+];
+
+const errorKey = (e: AbiError) => `${e.name}(${e.inputs.map((i) => i.type).join(",")})`;
+
+/**
+ * Every custom error a router call can revert with that the router's own ABI does not declare: the
+ * C and F managers' (a mint, a swap or a settlement bubbles them up unchanged) and Permit2's.
+ * Without them viem can name only the router's errors, and anything raised in the manager comes
+ * back as a bare selector.
+ */
+export const routerRevertErrors: readonly AbiError[] = (() => {
+  const seen = new Set<string>();
+  const out: AbiError[] = [];
+  for (const x of [...cPoolManagerAbi, ...fPoolManagerAbi, ...permit2Errors] as readonly { type: string }[]) {
+    if (x.type !== "error") continue;
+    const e = x as AbiError;
+    if (!seen.has(errorKey(e))) {
+      seen.add(errorKey(e));
+      out.push(e);
+    }
+  }
+  return out;
+})();
+
+/** `abi` plus every error in {@link routerRevertErrors} it does not already declare. */
+export function withRevertErrors(abi: readonly unknown[]): readonly unknown[] {
+  const have = new Set(
+    (abi as readonly { type: string }[]).filter((x) => x.type === "error").map((x) => errorKey(x as AbiError)),
+  );
+  return [...abi, ...routerRevertErrors.filter((e) => !have.has(errorKey(e)))];
+}
+
+/**
+ * The decoded revert of a contract call, e.g. `SlippageIn()` or `AllowanceExpired(1700000000)`,
+ * found however deep viem nested it; the raw selector when the error is not in the ABI; undefined
+ * when the failure was not a revert. viem's `message` puts the name on its second line, so a UI
+ * that shows only the first line ("The contract function … reverted.") loses it.
+ */
+export function revertName(e: unknown): string | undefined {
+  const seen = new Set<unknown>();
+  for (let x: unknown = e; x && typeof x === "object" && !seen.has(x); x = (x as { cause?: unknown }).cause) {
+    seen.add(x);
+    const o = x as { name?: string; data?: { errorName?: string; args?: readonly unknown[] }; signature?: string };
+    if (o.name !== "ContractFunctionRevertedError") continue;
+    if (o.data?.errorName) return `${o.data.errorName}(${(o.data.args ?? []).map(String).join(", ")})`;
+    if (o.signature) return o.signature;
+  }
+  return undefined;
+}
+
 /**
  * Send a router write with a gas buffer over an explicit estimate.
  *
@@ -102,7 +161,7 @@ export async function sendRouterWrite(
   const { account } = requireWallet(c);
   const params = {
     address: c.addresses.router,
-    abi: args.abi,
+    abi: withRevertErrors(args.abi),
     functionName: args.functionName,
     args: args.args,
     account,
@@ -147,7 +206,7 @@ export async function simulateRouterWrite<T>(
   const account = args.account ?? c.wallet?.account?.address;
   const { result } = await c.public.simulateContract({
     address: c.addresses.router,
-    abi: args.abi,
+    abi: withRevertErrors(args.abi),
     functionName: args.functionName,
     args: args.args,
     account,