@logswap/sdk 0.5.62 → 0.5.64

package/dist/client.js

@@ -123,30 +123,27 @@ export const EXPECTED_VERSION = 5n;
 // `isTaker`; a pad and a POL hold one base (`OneBase`).
 export const EXPECTED_F_VERSION = 19n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
-    const { cPoolManagerAbi } = await import("./generated.js");
-    const got = await c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "version",
-    });
+    const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");
+    // three independent reads: one round trip, not three in a row
+    const [got, gotF, wiring] = await Promise.all([
+        c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "version" }),
+        // the F manager carries its own tag; assert it the same way when deployed
+        c.addresses.fPoolManager
+            ? c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "version" })
+            : Promise.resolve(null),
+        assertWiring(c).then(() => null, (e) => e),
+    ]);
     if (got !== expected) {
         throw new Error(`logswap: manager at ${c.addresses.cPoolManager} reports version ${got}, but this SDK was built ` +
             `against version ${expected}. Upgrade the SDK or point at the matching deployment.`);
     }
-    // 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({
-            address: c.addresses.fPoolManager,
-            abi: fPoolManagerAbi,
-            functionName: "version",
-        });
-        if (gotF < EXPECTED_F_VERSION) {
-            throw new Error(`logswap: F manager at ${c.addresses.fPoolManager} reports version ${gotF}, but this SDK needs ` +
-                `at least F version ${EXPECTED_F_VERSION}. Upgrade the deployment or point at a newer one.`);
-        }
+    if (gotF !== null && gotF < EXPECTED_F_VERSION) {
+        throw new Error(`logswap: F manager at ${c.addresses.fPoolManager} reports version ${gotF}, but this SDK needs ` +
+            `at least F version ${EXPECTED_F_VERSION}. Upgrade the deployment or point at a newer one.`);
     }
-    await assertWiring(c);
+    // the wiring's error is the less specific one, so a version mismatch is reported first
+    if (wiring)
+        throw wiring;
 }
 /**
  * The versions say the managers are the right code; this says the rest of the addresses belong

package/dist/fpool.d.ts

@@ -1433,11 +1433,13 @@ export interface DiscoveredFPool {
  * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
  * policy, cached. Possible only because the event carries the full key preimage (bases,
  * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
- * exists for exactly this call.
+ * exists for exactly this call. With `indexer`, the logs come from it (the node when it fails):
+ * a scan from block 0 per call is what made the first load wait on the node.
  */
 export declare function discoverFPools(c: LogswapClient, opts?: {
     fromBlock?: bigint;
     toBlock?: bigint;
+    indexer?: string;
 }): Promise<DiscoveredFPool[]>;
 /** A pool an authority controls, with what the policy page shows of it. */
 export interface FPoolControlled {

package/dist/fpool.js

@@ -46,6 +46,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
  */
 export const fPolicyBaseAbi = polPolicyAbi;
 import { fallBackUnlessRejected, signerFor } from "./write.js";
+import { getEventLogs } from "./history.js";
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 /** The optional questions a policy declared at birth, as bits of `Pool.asks`. */
@@ -1044,23 +1045,18 @@ export async function fPoolTransferShares(c, a) {
  * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
  * policy, cached. Possible only because the event carries the full key preimage (bases,
  * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
- * exists for exactly this call.
+ * exists for exactly this call. With `indexer`, the logs come from it (the node when it fails):
+ * a scan from block 0 per call is what made the first load wait on the node.
  */
 export async function discoverFPools(c, opts = {}) {
     const ev = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "FInitialize");
     if (!ev)
         throw new Error("logswap: F Initialize event missing from the generated ABI");
     const seedEv = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "Seeded");
-    const [logs, seeds] = await Promise.all([
-        c.public.getLogs({
-            address: c.addresses.fPoolManager,
-            event: ev,
-            fromBlock: opts.fromBlock ?? 0n,
-            toBlock: opts.toBlock ?? "latest",
-        }),
-        seedEv
-            ? c.public.getLogs({ address: c.addresses.fPoolManager, event: seedEv, fromBlock: opts.fromBlock ?? 0n, toBlock: opts.toBlock ?? "latest" })
-            : Promise.resolve([]),
+    const range = { indexer: opts.indexer, address: c.addresses.fPoolManager, fromBlock: opts.fromBlock, toBlock: opts.toBlock };
+    const [{ logs }, { logs: seeds }] = await Promise.all([
+        getEventLogs(c, { ...range, event: ev }),
+        seedEv ? getEventLogs(c, { ...range, event: seedEv }) : Promise.resolve({ logs: [] }),
     ]);
     const q0Of = new Map();
     for (const l of seeds) {
@@ -1080,7 +1076,7 @@ export async function discoverFPools(c, opts = {}) {
             kind,
             policy: a.policy,
             creator: a.creator,
-            block: l.blockNumber ?? 0n,
+            block: l.blockNumber,
             seeded: q0 !== undefined,
             q0: q0 ?? 0n,
             shape: kind === "pad" ? "launch" : "basket", // the policy's word, not n = 1: a mono POL is a pool 

package/dist/history.js

@@ -66,8 +66,10 @@ function decode(type, v) {
         return getAddress(v);
     return v; // bool, bytes32 (hex string), string
 }
-const PAGE = 1000;
+const PAGE = 1000; // postgraphile's cap
 const MAX_PAGES = 200;
+/** Pages in flight at once, after the first. */
+const PARALLEL_PAGES = 8;
 async function fromIndexer(c, q) {
     const { field, type } = tableFor(c, q.address, q.event.name);
     const inputs = q.event.inputs;
@@ -106,24 +108,30 @@ async function fromIndexer(c, q) {
     // postgraphile refuses a null or an empty filter, so each argument appears only when it has content
     const hasCondition = Object.keys(condition).length > 0;
     const hasFilter = Object.keys(filter).length > 0;
-    const decl = `$after: Cursor${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
-    const argsOf = `first: ${pageSize}, after: $after, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
+    const decl = `$offset: Int${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
+    const argsOf = `first: ${pageSize}, offset: $offset, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
     const query = `query History(${decl}) {
     ${field}(${argsOf}) {
-      pageInfo { hasNextPage endCursor } nodes { ${selection} }
+      totalCount nodes { ${selection} }
     }
   }`;
-    const rows = [];
-    let after = null;
-    for (let i = 0;; i++) {
-        if (i === MAX_PAGES)
+    const page = async (offset) => (await gql(q.indexer, query, { offset, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) }, q.signal))[field];
+    // The first page says how many rows there are; the rest are fetched in parallel by offset, not
+    // one cursor after another: a day of a busy pool is a few pages, and a round trip to a distant
+    // indexer costs more than the page. Ascending by key, rows that land meanwhile append at the end
+    // and shift no earlier offset.
+    const first = await page(0);
+    const rows = [...first.nodes];
+    if (q.latest === undefined && first.totalCount > first.nodes.length) {
+        const pages = Math.ceil(first.totalCount / PAGE);
+        if (pages > MAX_PAGES)
             throw new Error(`history: ${field} has more than ${PAGE * MAX_PAGES} rows`);
-        const d = await gql(q.indexer, query, { after, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) }, q.signal);
-        const page = d[field];
-        rows.push(...page.nodes);
-        if (q.latest !== undefined || !page.pageInfo.hasNextPage || !page.pageInfo.endCursor)
-            break;
-        after = page.pageInfo.endCursor;
+        const offsets = Array.from({ length: pages - 1 }, (_, i) => (i + 1) * PAGE);
+        for (let i = 0; i < offsets.length; i += PARALLEL_PAGES) {
+            const got = await Promise.all(offsets.slice(i, i + PARALLEL_PAGES).map(page));
+            for (const g of got)
+                rows.push(...g.nodes);
+        }
     }
     // a table can hold a previous deployment's rows (an indexer not yet reset): keep this contract's
     const want = q.address.toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.62",
+  "version": "0.5.64",
   "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/client.ts

@@ -168,34 +168,30 @@ export const EXPECTED_VERSION = 5n;
 export const EXPECTED_F_VERSION = 19n;
 
 export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
-  const { cPoolManagerAbi } = await import("./generated.js");
-  const got = await c.public.readContract({
-    address: c.addresses.cPoolManager,
-    abi: cPoolManagerAbi,
-    functionName: "version",
-  });
+  const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");
+  // three independent reads: one round trip, not three in a row
+  const [got, gotF, wiring] = await Promise.all([
+    c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "version" }),
+    // the F manager carries its own tag; assert it the same way when deployed
+    c.addresses.fPoolManager
+      ? c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "version" })
+      : Promise.resolve(null),
+    assertWiring(c).then(() => null, (e: unknown) => e),
+  ]);
   if (got !== expected) {
     throw new Error(
       `logswap: manager at ${c.addresses.cPoolManager} reports version ${got}, but this SDK was built ` +
         `against version ${expected}. Upgrade the SDK or point at the matching deployment.`,
     );
   }
-  // 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({
-      address: c.addresses.fPoolManager,
-      abi: fPoolManagerAbi,
-      functionName: "version",
-    });
-    if (gotF < EXPECTED_F_VERSION) {
-      throw new Error(
-        `logswap: F manager at ${c.addresses.fPoolManager} reports version ${gotF}, but this SDK needs ` +
-          `at least F version ${EXPECTED_F_VERSION}. Upgrade the deployment or point at a newer one.`,
-      );
-    }
+  if (gotF !== null && gotF < EXPECTED_F_VERSION) {
+    throw new Error(
+      `logswap: F manager at ${c.addresses.fPoolManager} reports version ${gotF}, but this SDK needs ` +
+        `at least F version ${EXPECTED_F_VERSION}. Upgrade the deployment or point at a newer one.`,
+    );
   }
-  await assertWiring(c);
+  // the wiring's error is the less specific one, so a version mismatch is reported first
+  if (wiring) throw wiring;
 }
 
 /**

package/src/fpool.ts

@@ -49,6 +49,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
 export const fPolicyBaseAbi = polPolicyAbi;
 import type { LogswapClient } from "./client.js";
 import { fallBackUnlessRejected, signerFor } from "./write.js";
+import { getEventLogs } from "./history.js";
 
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000" as const;
@@ -1474,27 +1475,22 @@ export interface DiscoveredFPool {
  * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
  * policy, cached. Possible only because the event carries the full key preimage (bases,
  * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
- * exists for exactly this call.
+ * exists for exactly this call. With `indexer`, the logs come from it (the node when it fails):
+ * a scan from block 0 per call is what made the first load wait on the node.
  */
 export async function discoverFPools(
   c: LogswapClient,
-  opts: { fromBlock?: bigint; toBlock?: bigint } = {},
+  opts: { fromBlock?: bigint; toBlock?: bigint; indexer?: string } = {},
 ): Promise<DiscoveredFPool[]> {
   type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "FInitialize" }>;
   const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "FInitialize");
   if (!ev) throw new Error("logswap: F Initialize event missing from the generated ABI");
   type SeedEv = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "Seeded" }>;
   const seedEv = fPoolManagerAbi.find((x): x is SeedEv => x.type === "event" && x.name === "Seeded");
-  const [logs, seeds] = await Promise.all([
-    c.public.getLogs({
-      address: c.addresses.fPoolManager!,
-      event: ev,
-      fromBlock: opts.fromBlock ?? 0n,
-      toBlock: opts.toBlock ?? "latest",
-    }),
-    seedEv
-      ? c.public.getLogs({ address: c.addresses.fPoolManager!, event: seedEv, fromBlock: opts.fromBlock ?? 0n, toBlock: opts.toBlock ?? "latest" })
-      : Promise.resolve([]),
+  const range = { indexer: opts.indexer, address: c.addresses.fPoolManager!, fromBlock: opts.fromBlock, toBlock: opts.toBlock };
+  const [{ logs }, { logs: seeds }] = await Promise.all([
+    getEventLogs(c, { ...range, event: ev }),
+    seedEv ? getEventLogs(c, { ...range, event: seedEv }) : Promise.resolve({ logs: [] }),
   ]);
   const q0Of = new Map<string, bigint>();
   for (const l of seeds) {
@@ -1518,7 +1514,7 @@ export async function discoverFPools(
         kind,
         policy: a.policy,
         creator: a.creator,
-        block: l.blockNumber ?? 0n,
+        block: l.blockNumber,
         seeded: q0 !== undefined,
         q0: q0 ?? 0n,
         shape: kind === "pad" ? "launch": "basket", // the policy's word, not n = 1: a mono POL is a pool 

package/src/history.ts

@@ -101,8 +101,10 @@ function decode(type: string, v: unknown): unknown {
   return v; // bool, bytes32 (hex string), string
 }
 
-const PAGE = 1000;
+const PAGE = 1000; // postgraphile's cap
 const MAX_PAGES = 200;
+/** Pages in flight at once, after the first. */
+const PARALLEL_PAGES = 8;
 
 async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<HistoryLog<A>[]> {
   const { field, type } = tableFor(c, q.address, q.event.name);
@@ -135,29 +137,31 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
   // postgraphile refuses a null or an empty filter, so each argument appears only when it has content
   const hasCondition = Object.keys(condition).length > 0;
   const hasFilter = Object.keys(filter).length > 0;
-  const decl = `$after: Cursor${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
-  const argsOf = `first: ${pageSize}, after: $after, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
+  const decl = `$offset: Int${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
+  const argsOf = `first: ${pageSize}, offset: $offset, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
   const query = `query History(${decl}) {
     ${field}(${argsOf}) {
-      pageInfo { hasNextPage endCursor } nodes { ${selection} }
+      totalCount nodes { ${selection} }
     }
   }`;
   type Row = Record<string, unknown>;
-  type Conn = { pageInfo: { hasNextPage: boolean; endCursor: string | null }; nodes: Row[] };
-  const rows: Row[] = [];
-  let after: string | null = null;
-  for (let i = 0; ; i++) {
-    if (i === MAX_PAGES) throw new Error(`history: ${field} has more than ${PAGE * MAX_PAGES} rows`);
-    const d: Record<string, Conn> = await gql<Record<string, Conn>>(
-      q.indexer!,
-      query,
-      { after, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) },
-      q.signal,
-    );
-    const page: Conn = d[field]!;
-    rows.push(...page.nodes);
-    if (q.latest !== undefined || !page.pageInfo.hasNextPage || !page.pageInfo.endCursor) break;
-    after = page.pageInfo.endCursor;
+  type Conn = { totalCount: number; nodes: Row[] };
+  const page = async (offset: number): Promise<Conn> =>
+    (await gql<Record<string, Conn>>(q.indexer!, query, { offset, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) }, q.signal))[field]!;
+  // The first page says how many rows there are; the rest are fetched in parallel by offset, not
+  // one cursor after another: a day of a busy pool is a few pages, and a round trip to a distant
+  // indexer costs more than the page. Ascending by key, rows that land meanwhile append at the end
+  // and shift no earlier offset.
+  const first = await page(0);
+  const rows: Row[] = [...first.nodes];
+  if (q.latest === undefined && first.totalCount > first.nodes.length) {
+    const pages = Math.ceil(first.totalCount / PAGE);
+    if (pages > MAX_PAGES) throw new Error(`history: ${field} has more than ${PAGE * MAX_PAGES} rows`);
+    const offsets = Array.from({ length: pages - 1 }, (_, i) => (i + 1) * PAGE);
+    for (let i = 0; i < offsets.length; i += PARALLEL_PAGES) {
+      const got = await Promise.all(offsets.slice(i, i + PARALLEL_PAGES).map(page));
+      for (const g of got) rows.push(...g.nodes);
+    }
   }
   // a table can hold a previous deployment's rows (an indexer not yet reset): keep this contract's
   const want = q.address.toLowerCase();