smail-sdk 0.1.0 → 0.1.1

package/dist/pool-index.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex } from "viem";
-import { type LogWindowOptions } from "./events.js";
+import type { LogWindowOptions } from "./events.js";
 import { type MerklePath, type PoolDeposit } from "./private.js";
 import type { SmailReadClient } from "./read.js";
 /**
@@ -23,6 +23,13 @@ import type { SmailReadClient } from "./read.js";
  * claimant rehashes its own chunk against the stored chunk root, and the
  * root the path reaches must be one the pool itself knows.
  */
+/**
+ * Blocks asked for in one `eth_getLogs` while reading a pool. Wide on purpose:
+ * a pool's log is sparse, and a node that refuses a range is asked for each
+ * half instead, so a strict node costs a few extra calls and a generous one
+ * answers the pool's whole life in a handful.
+ */
+export declare const POOL_LOG_WINDOW = 1000000;
 export declare const CHUNK_LEVELS = 10;
 export declare const CHUNK_SIZE: number;
 export interface SpentEntry {
@@ -71,6 +78,8 @@ export declare function emptyPoolIndex(pool: Address, firstBlock: bigint): PoolI
  */
 export declare function syncPoolIndex(client: Pick<SmailReadClient, "getLogs" | "getBlockNumber">, base: PoolIndex, options?: LogWindowOptions & {
     onProgress?: (done: bigint, total: bigint) => void;
+    /** Windows read at once. One by default; a terminal with a long way to catch up asks for more. */
+    concurrency?: number;
 }): Promise<PoolIndex>;
 /**
  * The index as a header and two flat binary tables, the same shape for the

package/dist/pool-index.js

@@ -1,7 +1,6 @@
 import { poseidon2 } from "poseidon-lite";
 import { getAbiItem } from "viem";
 import { privateSnailAbi } from "./abi/index.js";
-import { LOG_WINDOW, walkWindows } from "./events.js";
 import { PRIVATE_LEVELS, ZERO_VALUE } from "./private.js";
 /**
  * A private pool's full public history, kept so a claim never has to re-read
@@ -24,6 +23,13 @@ import { PRIVATE_LEVELS, ZERO_VALUE } from "./private.js";
  * claimant rehashes its own chunk against the stored chunk root, and the
  * root the path reaches must be one the pool itself knows.
  */
+/**
+ * Blocks asked for in one `eth_getLogs` while reading a pool. Wide on purpose:
+ * a pool's log is sparse, and a node that refuses a range is asked for each
+ * half instead, so a strict node costs a few extra calls and a generous one
+ * answers the pool's whole life in a handful.
+ */
+export const POOL_LOG_WINDOW = 1_000_000;
 export const CHUNK_LEVELS = 10;
 export const CHUNK_SIZE = 1 << CHUNK_LEVELS;
 const DEPOSIT = getAbiItem({ abi: privateSnailAbi, name: "Deposit" });
@@ -123,11 +129,23 @@ export async function syncPoolIndex(client, base, options = {}) {
     const from = base.toBlock + 1n;
     const added = [];
     const spent = new Map(base.spent);
-    await walkWindows(from, to, options.window ?? LOG_WINDOW, false, async (start, end) => {
-        const [deposits, withdrawals] = await Promise.all([
-            client.getLogs({ address: base.pool, event: DEPOSIT, fromBlock: start, toBlock: end }),
-            client.getLogs({ address: base.pool, event: WITHDRAWAL, fromBlock: start, toBlock: end }),
-        ]);
+    const read = async (start, end) => {
+        let deposits, withdrawals;
+        try {
+            [deposits, withdrawals] = await Promise.all([
+                client.getLogs({ address: base.pool, event: DEPOSIT, fromBlock: start, toBlock: end }),
+                client.getLogs({ address: base.pool, event: WITHDRAWAL, fromBlock: start, toBlock: end }),
+            ]);
+        }
+        catch (cause) {
+            // A node that refuses the range is asked for each half instead.
+            if (start === end)
+                throw cause;
+            const middle = start + (end - start) / 2n;
+            await read(start, middle);
+            await read(middle + 1n, end);
+            return;
+        }
         for (const log of deposits) {
             const args = log.args;
             added.push({
@@ -144,9 +162,24 @@ export async function syncPoolIndex(client, base, options = {}) {
             const args = log.args;
             spent.set(BigInt(args.nullifierHash), { recipient: args.recipient, transactionHash: log.transactionHash ?? "0x" });
         }
-        options.onProgress?.(end - from + 1n, to - from + 1n);
-        return false;
-    });
+    };
+    // The range in windows, read `concurrency` at a time. Order does not matter:
+    // deposits are sorted by leaf index below, and a nullifier is spent once.
+    const width = BigInt(options.window ?? POOL_LOG_WINDOW);
+    const windows = [];
+    for (let start = from; start <= to; start += width)
+        windows.push([start, start + width - 1n < to ? start + width - 1n : to]);
+    let next = 0;
+    let done = 0n;
+    const worker = async () => {
+        while (next < windows.length) {
+            const [start, end] = windows[next++];
+            await read(start, end);
+            done += end - start + 1n;
+            options.onProgress?.(done, to - from + 1n);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(options.concurrency ?? 1, windows.length)) }, worker));
     added.sort((a, b) => a.leafIndex - b.leafIndex);
     const deposits = base.deposits.concat(added);
     for (let i = base.deposits.length; i < deposits.length; i++) {
@@ -154,14 +187,14 @@ export async function syncPoolIndex(client, base, options = {}) {
             throw new PoolIndexMismatch(`Deposit ${i} is missing; the tree cannot be rebuilt.`);
     }
     const chunkRoots = base.chunkRoots.slice();
-    const next = { pool: base.pool, toBlock: to, deposits, spent, chunkRoots };
+    const synced = { pool: base.pool, toBlock: to, deposits, spent, chunkRoots };
     if (added.length) {
         const first = Math.floor(base.deposits.length / CHUNK_SIZE);
         const last = Math.floor((deposits.length - 1) / CHUNK_SIZE);
         for (let chunk = first; chunk <= last; chunk++)
-            chunkRoots[chunk] = chunkRootOf(chunkLeaves(next, chunk));
+            chunkRoots[chunk] = chunkRootOf(chunkLeaves(synced, chunk));
     }
-    return next;
+    return synced;
 }
 const DEPOSIT_BYTES = 66;
 const SPENT_BYTES = 84;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smail-sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Send ETH or USDG as a claim link on Robinhood Chain: keys, links, signatures and contract calls",
   "license": "Apache-2.0",
   "homepage": "https://smail.cash",