@logswap/sdk 0.5.53 → 0.5.54

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`. */
@@ -410,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);
 }
@@ -422,7 +423,7 @@ async function writeFPool0(c, functionName, args, account) {
         abi: fPoolManagerAbi,
         functionName,
         args,
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -447,7 +448,7 @@ pullTokens = []) {
         abi: logswapRouterAbi,
         functionName: fn,
         args: sendArgs,
-        account,
+        account: signerFor(c, account),
     });
     return wallet.writeContract(request);
 }
@@ -502,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);
 }
@@ -900,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);
 }
@@ -971,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);
 }
@@ -1035,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/pools.d.ts

@@ -73,6 +73,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;
 }
 /**
  * Enumerate markets from `Initialize` logs.

package/dist/pools.js

@@ -13,6 +13,7 @@
  */
 import { formatUnits } from "viem";
 import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
+import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId } from "./keys.js";
 /** Read a market's full state by key. */
@@ -137,19 +138,10 @@ export async function isValidFloor(c, key, floor) {
  * magnitude while the contract behaves perfectly — which reads as "the app is broken".
  */
 export async function marketDecimals(c, key) {
-    const abi = [
-        { type: "function", name: "decimals", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
-    ];
-    const read = async (token) => {
-        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 };
 }
 /**
  * Both sides of a market, for labelling and scaling.
@@ -318,7 +310,7 @@ export async function initializeMarket(c, a) {
         abi: cPoolManagerAbi,
         functionName: "initialize",
         args: [a.key, a.x0],
-        account: a.account,
+        account: signerFor(c, a.account),
     });
     return c.wallet.writeContract(request);
 }

package/dist/write.d.ts

@@ -38,6 +38,14 @@ export declare function resolveDeadline(o: WriteOptions | undefined, now?: numbe
  * 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 declare function signerFor(c: LogswapClient, address: Address): NonNullable<LogswapClient["wallet"]>["account"];
 export declare function requireWallet(c: LogswapClient): {
     account: NonNullable<LogswapClient["wallet"]>["account"];
     address: Address;

package/dist/write.js

@@ -32,6 +32,20 @@ export function resolveDeadline(o, 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, address) {
+    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) {
     const account = c.wallet?.account;
     if (!c.wallet || !account) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.53",
+  "version": "0.5.54",
   "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/fpool.ts

@@ -48,6 +48,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
  */
 export const fPolicyBaseAbi = polPolicyAbi;
 import type { LogswapClient } from "./client.js";
+import { signerFor } from "./write.js";
 
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000" as const;
@@ -644,7 +645,7 @@ async function writeFPool(c: LogswapClient, poolId: Hex, functionName: string, a
     // 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),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -657,7 +658,7 @@ async function writeFPool0(c: LogswapClient, functionName: string, args: unknown
     abi: fPoolManagerAbi,
     functionName,
     args,
-    account,
+    account: signerFor(c, account),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -688,7 +689,7 @@ async function writeRouter(
     abi: logswapRouterAbi,
     functionName: fn,
     args: sendArgs,
-    account,
+    account: signerFor(c, account),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -749,7 +750,7 @@ export async function approveRouterForFPool(c: LogswapClient, account: Address)
     abi: fPoolManagerAbi,
     functionName: "setOperator",
     args: [c.addresses.router, true],
-    account,
+    account: signerFor(c, account),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -1269,7 +1270,7 @@ async function writePolicy(c: LogswapClient, abi: readonly unknown[], a: { poolI
     abi,
     functionName,
     args: [a.poolId, ...args],
-    account: a.account,
+    account: signerFor(c, a.account),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -1361,7 +1362,7 @@ export async function fPoolSetSponsorName(c: LogswapClient, a: { who: Address; n
     abi: policyRegistryAbi,
     functionName: "setSponsorName",
     args: [a.who, textToBytes32(a.name)],
-    account: a.account,
+    account: signerFor(c, a.account),
   } as never);
   return wallet.writeContract(request as never);
 }
@@ -1436,7 +1437,7 @@ export async function fPoolTransferShares(
     abi: fPoolManagerAbi,
     functionName: "transfer",
     args: [a.to, fPoolShareId(a.poolId, gen), a.shares],
-    account: a.account,
+    account: signerFor(c, a.account),
   } as never);
   return wallet.writeContract(request as never);
 }

package/src/indexer.ts

@@ -34,25 +34,70 @@ export function bytea(hex: Hex): string {
   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<T>(
   url: string,
   query: string,
   variables?: Record<string, unknown>,
   signal?: AbortSignal,
 ): Promise<T> {
+  // 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()) as { data?: T; errors?: IndexerError[] };
   if (body.errors?.length) throw new Error(`indexer: ${body.errors.map((e) => e.message).join("; ")}`);
   if (!body.data) 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<N>(
+  url: string,
+  field: string,
+  selection: string,
+  opts: { vars?: Record<string, { type: string; value: unknown }>; condition?: string; signal?: AbortSignal } = {},
+): Promise<N[]> {
+  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: N[] = [];
+  let after: string | null = null;
+  for (let i = 0; i < MAX_PAGES; i++) {
+    type Conn = { pageInfo: { hasNextPage: boolean; endCursor: string | null }; nodes: N[] };
+    const d: Record<string, Conn> = await gql<Record<string, Conn>>(url, q, { ...values, after }, opts.signal);
+    const page: Conn = 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`);
+}
+
 /** A position class as the chain registered it: the floor/cap geometry, fixed for the id's life. */
 export interface RegisteredId {
   id: bigint;
@@ -63,16 +108,12 @@ export interface RegisteredId {
 
 /** Every position class ever registered in a pool. Historical — some may since have burnt to zero. */
 export async function registeredIds(url: string, poolId: Hex, signal?: AbortSignal): Promise<RegisteredId[]> {
-  const q = `query Ids($pool: String!) {
-    allIdRegistereds(condition: {poolId: $pool}, first: 1000) { nodes { id floor cap capped } }
-  }`;
-  const d = await gql<{ allIdRegistereds: { nodes: { id: string; floor: string; cap: string; capped: boolean }[] } }>(
-    url,
-    q,
-    { pool: bytea(poolId) },
+  const nodes = await gqlAll<{ id: string; floor: string; cap: string; capped: boolean }>(url, "allIdRegistereds", "id floor cap capped", {
+    vars: { pool: { type: "String!", value: bytea(poolId) } },
+    condition: "{poolId: $pool}",
     signal,
-  );
-  return d.allIdRegistereds.nodes.map((n) => ({
+  });
+  return nodes.map((n) => ({
     id: BigInt(n.id),
     floor: BigInt(n.floor),
     cap: BigInt(n.cap),
@@ -142,15 +183,12 @@ export async function indexerHealthy(url: string, signal?: AbortSignal): Promise
  * everywhere else, so a wrong id fails loudly instead of addressing the wrong pool.
  */
 export async function discoverMarketsIndexed(url: string, signal?: AbortSignal): Promise<DiscoveredMarket[]> {
-  const q = `{ allInitializes(first: 1000) { nodes {
-    poolId base quote tickSpacing phi x0 blockNumber txHash
-  } } }`;
   type Row = {
     poolId: Hex; base: Hex; quote: Hex; tickSpacing: string; phi: string;
-    x0: string; blockNumber: string; txHash: Hex;
+    x0: string; blockNumber: string; txHash: Hex; contractAddress: Hex;
   };
-  const d = await gql<{ allInitializes: { nodes: Row[] } }>(url, q, undefined, signal);
-  return d.allInitializes.nodes.map((n) => {
+  const nodes = await gqlAll<Row>(url, "allInitializes", "poolId base quote tickSpacing phi x0 blockNumber txHash contractAddress", { signal });
+  return nodes.map((n) => {
     const key: PoolKey = {
       base: n.base as Address,
       quote: n.quote as Address,
@@ -163,6 +201,7 @@ export async function discoverMarketsIndexed(url: string, signal?: AbortSignal):
       x0: BigInt(n.x0),
       blockNumber: BigInt(n.blockNumber),
       transactionHash: n.txHash,
+      manager: n.contractAddress,
     };
   });
 }
@@ -181,31 +220,14 @@ export async function discoverMarketsBest(
   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],
-                } as never);
-                return m;
-              } catch {
-                return null;
-              }
-            }),
-          )
-        ).filter((m): m is DiscoveredMarket => 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/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) {