@logswap/sdk 0.5.61 → 0.5.63

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.d.ts

@@ -36,6 +36,13 @@ export interface EventLogsQuery {
     toBlock?: bigint;
     /** Unix seconds: only events at or after this time. On the chain path it becomes a block search. */
     since?: number;
+    /**
+     * Only the newest `latest` events (still returned oldest first) — a pool's tape, not its history.
+     * On the chain path the node is asked for the last {@link LATEST_SCAN_BLOCKS} blocks only.
+     */
+    latest?: number;
+    /** Only events from these transactions — e.g. the `RouterCall`s behind a page of routed swaps. */
+    transactionHashes?: Hex[];
     signal?: AbortSignal;
 }
 /**
@@ -50,3 +57,5 @@ export declare function tableFor(c: LogswapClient, address: Address, event: stri
     field: string;
     type: string;
 };
+/** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
+export declare const LATEST_SCAN_BLOCKS = 5000n;

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;
@@ -97,23 +99,39 @@ async function fromIndexer(c, q) {
         filter.blockNumber = range;
     if (q.since !== undefined)
         filter.blockTimestamp = { greaterThanOrEqualTo: new Date(q.since * 1000).toISOString() };
+    if (q.transactionHashes)
+        filter.txHash = { in: q.transactionHashes.map((h) => h.toLowerCase()) };
+    // a tape is one page from the head, newest first; history is every page from the start
+    const pageSize = q.latest ?? PAGE;
+    const order = q.latest !== undefined ? "[BLOCK_NUMBER_DESC, LOG_INDEX_DESC]" : "PRIMARY_KEY_ASC";
     const selection = [...inputs.map((i) => column(i.name)), "contractAddress", "blockNumber", "blockTimestamp", "txHash", "logIndex"].join(" ");
-    const query = `query History($after: Cursor, $condition: ${type}Condition, $filter: ${type}Filter) {
-    ${field}(first: ${PAGE}, after: $after, orderBy: PRIMARY_KEY_ASC, condition: $condition, filter: $filter) {
-      pageInfo { hasNextPage endCursor } nodes { ${selection} }
+    // 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 = `$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}) {
+      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, condition: Object.keys(condition).length ? condition : null, filter: Object.keys(filter).length ? filter : null }, q.signal);
-        const page = d[field];
-        rows.push(...page.nodes);
-        if (!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();
@@ -130,12 +148,22 @@ async function fromIndexer(c, q) {
         .sort((a, b) => (a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1));
 }
 // ─── the chain path ──────────────────────────────────────────────────────────
+/** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
+export const LATEST_SCAN_BLOCKS = 5000n;
 async function fromChain(c, q) {
     let fromBlock = q.fromBlock ?? 0n;
     const toBlock = q.toBlock ?? (await c.public.getBlockNumber());
     if (q.since !== undefined)
         fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
-    const logs = await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock });
+    if (q.latest !== undefined && toBlock - fromBlock > LATEST_SCAN_BLOCKS)
+        fromBlock = toBlock - LATEST_SCAN_BLOCKS;
+    let logs = (await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock }));
+    if (q.transactionHashes) {
+        const want = new Set(q.transactionHashes.map((h) => h.toLowerCase()));
+        logs = logs.filter((l) => want.has(l.transactionHash.toLowerCase()));
+    }
+    if (q.latest !== undefined)
+        logs = logs.slice(-q.latest);
     return logs.map((l) => ({
         address: q.address,
         args: l.args,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.61",
+  "version": "0.5.63",
   "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

@@ -40,6 +40,13 @@ export interface EventLogsQuery {
   toBlock?: bigint;
   /** Unix seconds: only events at or after this time. On the chain path it becomes a block search. */
   since?: number;
+  /**
+   * Only the newest `latest` events (still returned oldest first) — a pool's tape, not its history.
+   * On the chain path the node is asked for the last {@link LATEST_SCAN_BLOCKS} blocks only.
+   */
+  latest?: number;
+  /** Only events from these transactions — e.g. the `RouterCall`s behind a page of routed swaps. */
+  transactionHashes?: Hex[];
   signal?: AbortSignal;
 }
 
@@ -94,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);
@@ -119,29 +128,40 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
   if (q.toBlock !== undefined) range.lessThanOrEqualTo = q.toBlock.toString();
   if (Object.keys(range).length) filter.blockNumber = range;
   if (q.since !== undefined) filter.blockTimestamp = { greaterThanOrEqualTo: new Date(q.since * 1000).toISOString() };
+  if (q.transactionHashes) filter.txHash = { in: q.transactionHashes.map((h) => h.toLowerCase()) };
+  // a tape is one page from the head, newest first; history is every page from the start
+  const pageSize = q.latest ?? PAGE;
+  const order = q.latest !== undefined ? "[BLOCK_NUMBER_DESC, LOG_INDEX_DESC]" : "PRIMARY_KEY_ASC";
 
   const selection = [...inputs.map((i) => column(i.name!)), "contractAddress", "blockNumber", "blockTimestamp", "txHash", "logIndex"].join(" ");
-  const query = `query History($after: Cursor, $condition: ${type}Condition, $filter: ${type}Filter) {
-    ${field}(first: ${PAGE}, after: $after, orderBy: PRIMARY_KEY_ASC, condition: $condition, filter: $filter) {
-      pageInfo { hasNextPage endCursor } nodes { ${selection} }
+  // 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 = `$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}) {
+      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, condition: Object.keys(condition).length ? condition : null, filter: Object.keys(filter).length ? filter : null },
-      q.signal,
-    );
-    const page: Conn = d[field]!;
-    rows.push(...page.nodes);
-    if (!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();
@@ -160,12 +180,26 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
 
 // ─── the chain path ──────────────────────────────────────────────────────────
 
+/** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
+export const LATEST_SCAN_BLOCKS = 5_000n;
+
 async function fromChain<A>(c: LogswapClient, q: EventLogsQuery): Promise<HistoryLog<A>[]> {
   let fromBlock = q.fromBlock ?? 0n;
   const toBlock = q.toBlock ?? (await c.public.getBlockNumber());
   if (q.since !== undefined) fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
-  const logs = await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock } as never);
-  return (logs as unknown as Array<{ args: A; blockNumber: bigint; transactionHash: Hex; logIndex: number }>).map((l) => ({
+  if (q.latest !== undefined && toBlock - fromBlock > LATEST_SCAN_BLOCKS) fromBlock = toBlock - LATEST_SCAN_BLOCKS;
+  let logs = (await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock } as never)) as unknown as Array<{
+    args: A;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    logIndex: number;
+  }>;
+  if (q.transactionHashes) {
+    const want = new Set(q.transactionHashes.map((h) => h.toLowerCase()));
+    logs = logs.filter((l) => want.has(l.transactionHash.toLowerCase()));
+  }
+  if (q.latest !== undefined) logs = logs.slice(-q.latest);
+  return logs.map((l) => ({
     address: q.address,
     args: l.args,
     blockNumber: l.blockNumber,