@logswap/sdk 0.5.55 → 0.5.57

package/dist/write.d.ts

@@ -12,7 +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 type { Address, Hash } from "viem";
+import type { Address, Hash, Hex } from "viem";
 import type { LogswapClient } from "./client.js";
 /** Disables the deadline check. Deliberate opt-out, never a default. */
 export declare const NEVER: bigint;
@@ -73,6 +73,18 @@ export declare function sendRouterWrite(c: LogswapClient, args: {
     args: readonly unknown[];
     bufferPct?: bigint;
 }): Promise<Hash>;
+/**
+ * Whether an error is the user saying no in their wallet (EIP-1193 code 4001, viem's
+ * `UserRejectedRequestError`), however deep viem nested it.
+ */
+export declare function isUserRejection(e: unknown): boolean;
+/**
+ * The permit signatures are an optimisation: when they cannot be produced (a wallet without
+ * `signTypedData`, a read that failed) the write goes out plain and relies on a standing
+ * allowance. A REJECTED signature is not that — it was swallowed too, and the user who had just
+ * said no was shown a transaction prompt, which then reverted with a Permit2 error that hid why.
+ */
+export declare function fallBackUnlessRejected(e: unknown): Hex[];
 /** Simulate a router write and return its decoded result, without sending. */
 export declare function simulateRouterWrite<T>(c: LogswapClient, args: {
     abi: readonly unknown[];

package/dist/write.js

@@ -92,6 +92,31 @@ export async function sendRouterWrite(c, args) {
     const gas = (estimate * (100n + (args.bufferPct ?? 30n))) / 100n;
     return c.wallet.writeContract({ ...params, gas });
 }
+/**
+ * Whether an error is the user saying no in their wallet (EIP-1193 code 4001, viem's
+ * `UserRejectedRequestError`), however deep viem nested it.
+ */
+export function isUserRejection(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 === "UserRejectedRequestError" || o.code === 4001)
+            return true;
+    }
+    return false;
+}
+/**
+ * The permit signatures are an optimisation: when they cannot be produced (a wallet without
+ * `signTypedData`, a read that failed) the write goes out plain and relies on a standing
+ * allowance. A REJECTED signature is not that — it was swallowed too, and the user who had just
+ * said no was shown a transaction prompt, which then reverted with a Permit2 error that hid why.
+ */
+export function fallBackUnlessRejected(e) {
+    if (isUserRejection(e))
+        throw e;
+    return [];
+}
 /** Simulate a router write and return its decoded result, without sending. */
 export async function simulateRouterWrite(c, args) {
     const account = args.account ?? c.wallet?.account?.address;
@@ -112,7 +137,7 @@ export async function simulateRouterWrite(c, args) {
  */
 export async function sendRouterWriteWithPermits(c, args, pullTokens) {
     const { permit2SigCalls } = await import("./onboard.js");
-    const sigCalls = await permit2SigCalls(c, pullTokens).catch(() => []);
+    const sigCalls = await permit2SigCalls(c, pullTokens).catch(fallBackUnlessRejected);
     if (sigCalls.length === 0)
         return sendRouterWrite(c, args);
     const { encodeFunctionData } = await import("viem");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.55",
+  "version": "0.5.57",
   "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",
@@ -45,5 +45,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/logswap/logswap-sdk.git"
-  }
+  },
+  "homepage": "https://logswap.org"
 }

package/src/actions.ts

@@ -1,5 +1,5 @@
 /**
- * actions.ts — the router's transaction: a BATCH (decisions 010).
+ * actions.ts — the router's transaction: a BATCH.
  *
  * `execute(actions, settle)` runs a list of actions — mint, burn, update, claim, swap, path, in any
  * order, across any C markets — under ONE manager lock. Each action accrues deltas on the router

package/src/admin.ts

@@ -1,12 +1,12 @@
 /**
  * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
- * constant, decisions 049), the policies a pool may be born with (the registry's), the
+ * constant), the policies a pool may be born with (the registry's), the
  * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
  * the registry and the policies; no router.
  *
- * One vocabulary (decisions 040): both managers call the protocol's cut of the mint fee
+ * One vocabulary: both managers call the protocol's cut of the mint fee
  * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
- * (049). The harvest's cut is the policy's answer at every harvest (decisions 044), set on the
+ * (049). The harvest's cut is the policy's answer at every harvest, set on the
  * policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the release's
  * protocol share likewise (`POT_CUT_MAX`).
  */
@@ -29,12 +29,12 @@ function write(c: LogswapClient, address: Address, abi: readonly unknown[], func
 export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
   return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
 }
-/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18 (decisions 049); there is no setter. */
+/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18; there is no setter. */
 export async function fMintFeeProtocolCut(c: LogswapClient): Promise<bigint> {
   return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" } as never) as Promise<bigint>;
 }
 
-// ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
+// ─── the registry: the LOG authority's, not the collector's ─────────────────
 
 const ZERO = "0x0000000000000000000000000000000000000000" as const;
 
@@ -58,7 +58,7 @@ export async function policyApproved(c: LogswapClient, policy: Address): Promise
 /** One policy on the registry's list, with what it says it is. */
 export interface RegistryEntry {
   policy: Address;
-  /** The policy's own `kind()` tag (decisions 049) — what a pool born under it is. */
+  /** The policy's own `kind()` tag — what a pool born under it is. */
   kind: FPoolKind;
   name: string;
   /** The block it closes to new pools from; 0 = open. */
@@ -68,7 +68,7 @@ export interface RegistryEntry {
 }
 
 /**
- * Every policy listed, sunset ones included — one flat list (decisions 049), each with the kind
+ * Every policy listed, sunset ones included — one flat list, each with the kind
  * it says it is; `kind` narrows it to one, which is what a create form's dropdown reads. Empty
  * with no registry.
  */
@@ -138,7 +138,7 @@ export async function setPolicyApproved(c: LogswapClient, policy: Address, appro
 }
 
 /**
- * Move a pool to another approved policy of the same kind (decisions 046, 049): the registry
+ * Move a pool to another approved policy of the same kind: the registry
  * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
  * takes the authority and the name from the old; the operator and the lists void; no swap lands
  * in the block.

package/src/claims.ts

@@ -91,42 +91,20 @@ export async function checkReadiness(
   owner: Address,
   need: { base?: bigint; quote?: bigint; positions?: boolean } = {},
 ): Promise<Readiness> {
-  const erc20 = [
-    {
-      type: "function",
-      name: "allowance",
-      stateMutability: "view",
-      inputs: [
-        { name: "owner", type: "address" },
-        { name: "spender", type: "address" },
-      ],
-      outputs: [{ type: "uint256" }],
-    },
-  ] as const;
-
-  const [operator, baseAllow, quoteAllow] = await Promise.all([
+  // A token is ready when BOTH legs of its pull path are: the ERC-20 allowance to whoever pulls
+  // (Permit2 when wired) and, with Permit2, its unexpired allowance to the router. This used to
+  // read the ERC-20 allowance to the ROUTER, which on a Permit2 deployment is never granted — so
+  // it said "approve" forever, and approving the router changed nothing.
+  const { checkTokenReadiness } = await import("./onboard.js");
+  const ready = async (token: Address, amount?: bigint) => {
+    if (amount === undefined) return true;
+    const r = await checkTokenReadiness(c, token, owner, amount);
+    return !r.needsTokenApproval && !r.needsPermit2Approval;
+  };
+  const [operator, baseOk, quoteOk] = await Promise.all([
     need.positions ? isRouterApproved(c, owner) : Promise.resolve(true),
-    need.base
-      ? (c.public.readContract({
-          address: key.base,
-          abi: erc20,
-          functionName: "allowance",
-          args: [owner, c.addresses.router],
-        }) as Promise<bigint>)
-      : Promise.resolve(0n),
-    need.quote
-      ? (c.public.readContract({
-          address: key.quote,
-          abi: erc20,
-          functionName: "allowance",
-          args: [owner, c.addresses.router],
-        }) as Promise<bigint>)
-      : Promise.resolve(0n),
+    ready(key.base, need.base),
+    ready(key.quote, need.quote),
   ]);
-
-  return {
-    needsOperator: !operator,
-    needsBaseAllowance: need.base !== undefined && baseAllow < need.base,
-    needsQuoteAllowance: need.quote !== undefined && quoteAllow < need.quote,
-  };
+  return { needsOperator: !operator, needsBaseAllowance: !baseOk, needsQuoteAllowance: !quoteOk };
 }

package/src/client.ts

@@ -24,7 +24,7 @@ export interface LogswapAddresses {
    */
   fPoolManager?: Address;
   /**
-   * The protocol's four F policies, one per kind (decisions 044): every F pool names one in its key,
+   * The protocol's four F policies, one per kind: every F pool names one in its key,
    * and the pool's roles, gates and terms live on it. A deployment predating them carries none.
    */
   publicPolicy?: Address;
@@ -32,7 +32,7 @@ export interface LogswapAddresses {
   polPolicy?: Address;
   padPolicy?: Address;
   /**
-   * The policy registry (decisions 046): what a pool of each kind may be born under, and the
+   * The policy registry: what a pool of each kind may be born under, and the
    * owner that may move a pool between policies. Read from the F manager (`registry()`) when
    * absent; a deployment with none asks nobody.
    */
@@ -52,7 +52,38 @@ export function createLogswapClient(args: {
   wallet?: WalletClient;
   addresses: LogswapAddresses;
 }): LogswapClient {
-  return { public: args.public, wallet: args.wallet, addresses: args.addresses };
+  return { public: args.public, wallet: args.wallet && guardChain(args.wallet, args.public), addresses: args.addresses };
+}
+
+/**
+ * The wallet, with every signing call first checking that it is on the chain the reads come from.
+ *
+ * An injected wallet switched to another network would otherwise estimate and simulate against
+ * the public client's chain and then sign and send on its own — with deterministic deploy
+ * addresses, possibly into a different contract. Checked at each call, not once: a user can
+ * switch networks mid-session.
+ */
+function guardChain(wallet: WalletClient, pub: PublicClient): WalletClient {
+  if (typeof wallet.getChainId !== "function") return wallet; // a test double
+  let readChain: number | undefined = pub.chain?.id;
+  const check = async () => {
+    readChain ??= await pub.getChainId();
+    const walletChain = await wallet.getChainId();
+    if (walletChain !== readChain) {
+      throw new Error(`logswap: the wallet is on chain ${walletChain} but this app reads chain ${readChain} — switch the wallet's network`);
+    }
+  };
+  const guarded = new Set<PropertyKey>(["writeContract", "sendTransaction", "signTypedData"]);
+  return new Proxy(wallet, {
+    get(target, prop, receiver) {
+      const v = Reflect.get(target, prop, receiver);
+      if (!guarded.has(prop) || typeof v !== "function") return v;
+      return async (...a: unknown[]) => {
+        await check();
+        return (v as (...x: unknown[]) => unknown).apply(target, a);
+      };
+    },
+  });
 }
 
 /**
@@ -69,18 +100,18 @@ export function createLogswapClient(args: {
  * manager sailed through `assertVersion` while `FEE_MAX()` still answered on it. Move this in the
  * same change as `CParams.VERSION`, never after it.
  *
- * **3** since 2026-09-03 (contracts `d8406fb`): `burnById` and `update` take an `owner`, `update`
+ * **3** since 2026-09-03: `burnById` and `update` take an `owner`, `update`
  * mints to `to`, `positions()` returns `aps` as uint128 — and a returned quote flow now carries the
- * swept fees (decisions 018), which is why `exit`'s settle-to-one-asset math changed with it.
+ * swept fees, which is why `exit`'s settle-to-one-asset math changed with it.
  *
- * **4** since 2026-09-18 (decisions 042 + 040): `PoolKey` is `(base, quote, tickSpacing, phi)` —
+ * **4** since 2026-09-18: `PoolKey` is `(base, quote, tickSpacing, phi)` —
  * the variance kernel and its two key fields are gone, so every pool id changed; `phiEff` is
  * `phiOf`; `getPool` lost `sigma2Ema`; `Initialize` lost two fields; the cut is
  * `MINT_FEE_PROTOCOL_CUT` / `setFeeParams`.
  */
 export const EXPECTED_VERSION = 4n;
 /**
- * The F manager's own tag (contracts 25a7bcf: 5 — the key's salt, pool names, the sponsor registry;
+ * The F manager's own tag (5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
  *
  * A FLOOR, not an equality — unlike `EXPECTED_VERSION` above. The F primitive is iterating fast and
@@ -92,43 +123,43 @@ export const EXPECTED_VERSION = 4n;
  */
 // 7 (2026-09-15): the reserves are the state and the marks derived, `lockStrike`, the dividend
 // harvest, the relaunch (`dissolve(poolId, successor)`, `rollIn`), the reserve-named seed, the
-// sponsor facet — decisions 025–031.
-// 8 (2026-09-15): the relaunch is in place (decisions 032) — every share id carries the
+// sponsor facet.
+// 8 (2026-09-15): the relaunch is in place — every share id carries the
 // generation (`fPoolShareId(poolId, gen)`), `dissolve(poolId)`, `redeem`, `claim` / `dividendOf`
 // / `rollIn` / `previewRollIn` take the generation, `Pool.gen` replaces `dissolved` and
 // `successor`. A 7 deployment's share ids do not even resolve with this SDK.
-// 9 (2026-09-16): `deepen` is gone, `Pool.leverTheta` is `harvestedTheta` (decisions 034).
+// 9 (2026-09-16): `deepen` is gone, `Pool.leverTheta` is `harvestedTheta`.
 // 10 (2026-09-17): no floor guard — `Pool.minBuffer`, `raiseMinBuffer`, `LEVER_FLOOR` gone;
-// `dissolve` needs an empty bid on every pool (decisions 035); the key bit is the CLASS, `pad`
+// `dissolve` needs an empty bid on every pool; the key bit is the CLASS, `pad`
 // (036): `seed` mints a pad's shares to 0xdead, and the operator, the gates and the list are
 // refused on it — `fPoolLaunch` no longer transfers the seed itself.
-// 11 (2026-09-17): roles and entries (decisions 037) — the operator runs the pool (`harvest`,
+// 11 (2026-09-17): roles and entries — the operator runs the pool (`harvest`,
 // `dissolve`, `setLegs`) and is the authority until appointed, two-step (`acceptOperator`,
 // `Pool.pendingOperator`); `setLegL`/`admitLeg` are gone, `setLegs` edits the next generation's
 // table while unseeded; `fPoolRelaunch` takes `legs`.
 // `getPool` decodes one field fewer, so a 9 deployment's struct no longer matches this SDK.
-// 12 (2026-09-17): one contract (decisions 039) — the sponsor facet is folded back into the
+// 12 (2026-09-17): one contract — the sponsor facet is folded back into the
 // manager; `sponsor()` and the fallback are gone, every entry, error and event unchanged, so
 // `fPoolManagerAbi` is the manager's own ABI and no longer a union. Layout unchanged.
-// 13 (2026-09-18): one vocabulary (decisions 040) — `HARVEST_FEE` is `HARVEST_PROTOCOL_CUT` (a
+// 13 (2026-09-18): one vocabulary — `HARVEST_FEE` is `HARVEST_PROTOCOL_CUT` (a
 // cut of harvested income, not a fee on the harvest) and the exemption is `harvestCutExempt` /
 // `setHarvestCutExempt`; `acceptAuthority` clears the operator, pending and accepted (a mandate
 // is voided by the handover of the role that granted it); `setLegs` needs a generation to have
 // lived (`gen > 0`); `initialize` refuses a codeless base and `mint` refuses `to = address(0)`
 // on both managers. Layout unchanged.
-// 14 (2026-09-20): the policy (decisions 041) — `FPoolKey.policy`, every pool id moves; `dissolve` is
+// 14 (2026-09-20): the policy — `FPoolKey.policy`, every pool id moves; `dissolve` is
 // `retire`, `regenerate` releases the dead shares' pot, `harvestable`/`unharvested` are the
 // readouts; `feePerL`, `edgePerL`, `HARVEST_PROTOCOL_CUT`, `harvestCutExempt` are gone.
-// 15 (2026-09-20): the policy answers every question (decisions 044) — `FPoolKey.authority` is
+// 15 (2026-09-20): the policy answers every question — `FPoolKey.authority` is
 // `creator` (every pool id moves again); the roles, gates and list are the pool's POLICY's
 // (`FPolicyBase` / `PrivatePolicy`), not the manager's: `getPool` has `policy` and `asks` and no
 // role; `proposeAuthority`, `appointOperator`, `setGates`, `setAllowed` (`setMinters` / `setTakers` since 17) are policy writes;
 // `policyApproved(kind, policy)` / `setPolicyApproved(kind, policy, ok)`; `Regenerated` names the payee;
 // `HARVEST_CUT_MAX` / `POT_CUT_MAX` cap what a policy may route to the protocol.
-// 16 (2026-09-21): the word is POLICY (decisions 045) — a rename, no pool id moves: `FPoolKey.policy`,
+// 16 (2026-09-21): the word is POLICY — a rename, no pool id moves: `FPoolKey.policy`,
 // `IFPolicy`, `FPolicyBase`, `PublicPolicy` … `PadPolicy`, `policyApproved` / `setPolicyApproved`,
 // `PolicyApproved`; `PolPolicy.setPolicy` / `PolicySet` are `setRules` / `RulesSet`.
-// 17 (2026-09-21): the registry, the move, the stamp, two lists, one base (decisions 046–048) — no
+// 17 (2026-09-21): the registry, the move, the stamp, two lists, one base — no
 // pool id moves: the F manager takes a `PolicyRegistry` at construction and asks it at a birth
 // (`policyApproved` / `setPolicyApproved` left the manager: `registryApprove` …); the key's policy
 // is the policy at birth, `migrate` moves a pool for the registry's owner; `stamp` / `setAsks` are
@@ -149,7 +180,7 @@ export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSIO
         `against version ${expected}. Upgrade the SDK or point at the matching deployment.`,
     );
   }
-  // the F manager carries its own tag since contracts c782811; assert it the same way when deployed
+  // the F manager carries its own tag; assert it the same way when deployed
   if (c.addresses.fPoolManager) {
     const { fPoolManagerAbi } = await import("./generated.js");
     const gotF = await c.public.readContract({
@@ -164,4 +195,32 @@ export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSIO
       );
     }
   }
+  await assertWiring(c);
+}
+
+/**
+ * The versions say the managers are the right code; this says the rest of the addresses belong
+ * to THEM. A stale router or lens from a previous deployment passes every version check and then
+ * fails in the worst way: approvals go to a router that pulls for another manager, or every pull
+ * reverts because the router's Permit2 is not the one the user approved.
+ */
+export async function assertWiring(c: LogswapClient): Promise<void> {
+  const { logswapRouterAbi, logswapLensAbi } = await import("./generated.js");
+  const rd = (address: Address, abi: readonly unknown[], functionName: string) =>
+    c.public.readContract({ address, abi, functionName } as never) as Promise<Address>;
+  const ZERO = "0x0000000000000000000000000000000000000000";
+  const want: Array<[string, Promise<Address>, Address]> = [
+    ["router.mgr()", rd(c.addresses.router, logswapRouterAbi, "mgr"), c.addresses.cPoolManager],
+    ["router.permit2()", rd(c.addresses.router, logswapRouterAbi, "permit2"), c.addresses.permit2 ?? ZERO],
+    ["lens.mgr()", rd(c.addresses.lens, logswapLensAbi, "mgr"), c.addresses.cPoolManager],
+  ];
+  if (c.addresses.fPoolManager) {
+    want.push(["router.fmgr()", rd(c.addresses.router, logswapRouterAbi, "fmgr"), c.addresses.fPoolManager]);
+    want.push(["lens.fmgr()", rd(c.addresses.lens, logswapLensAbi, "fmgr"), c.addresses.fPoolManager]);
+  }
+  const got = await Promise.all(want.map((w) => w[1]));
+  const bad = want.flatMap(([what, , expected], i) =>
+    got[i]!.toLowerCase() === expected.toLowerCase() ? [] : [`${what} is ${got[i]}, expected ${expected}`],
+  );
+  if (bad.length) throw new Error(`logswap: the deployment's addresses do not belong together — ${bad.join("; ")}`);
 }