tapimo 0.9.0 → 0.10.1

package/src/apps/data/routes/webhooks.ts

@@ -7,17 +7,17 @@ import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
 import * as Cursor from '../../../internal/Cursor.js'
 import * as Db from '../../../db/Db.js'
+import type * as MetricSink from '../../../internal/MetricSink.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Store from '../../../internal/Store.js'
-import type * as Tidx from '../../../internal/Tidx.js'
 import * as Ttl from '../../../internal/Ttl.js'
 import * as Value from '../../../internal/Value.js'
 import type * as Viem from '../../../internal/Viem.js'
 import * as WebhookDestination from '../../../internal/WebhookDestination.js'
+import * as WebhookTransfer from '../../../internal/WebhookTransfer.js'
 import * as Webhooks from '../../../internal/Webhooks.js'
-import * as Receipts from './receipts.js'
 import * as Transactions from './transactions.js'
 import * as Transfers from './transfers.js'
 
@@ -67,7 +67,7 @@ const eventTypeDescriptions = [
   },
   {
     description:
-      'A transaction included in a block, filterable on every transaction field (sender, recipient, value, calldata, inner account-abstraction calls, fees, nonce) and its execution status.',
+      'A transaction included in a block, filterable on transaction fields such as sender, recipient, value, calldata, inner account-abstraction calls, fees, and nonce.',
     type: 'transaction:included',
   },
 ] as const satisfies readonly { description: string; type: EventType }[]
@@ -233,13 +233,12 @@ export namespace schema {
 
   /**
    * `transaction:included` subscription filters: operators over every column the
-   * `txs` envelope exposes, plus inner account-abstraction `calls`, the
-   * top-level `input` calldata, and the receipt-sourced execution `status`. All
-   * optional and AND-combined; omit every field for the full stream.
+   * `txs` envelope exposes, plus inner account-abstraction `calls` and the
+   * top-level `input` calldata. All optional and AND-combined; omit every field
+   * for the full stream.
    *
    * `address` matches either side (`from` OR `to`); when `includeCalls` is set
    * (default), `to`/`address` also match an inner call target (`calls[].to`).
-   * Set `includeReceipt` to embed the receipt in the delivered payload.
    */
   export const TxFilters = z
     .strictObject({
@@ -269,16 +268,6 @@ export namespace schema {
             z.meta({ examples: [true] }),
           ),
       ),
-      includeReceipt: z.optional(
-        z
-          .boolean()
-          .check(
-            z.describe(
-              'When true, embed the transaction receipt (execution `status`, `gasUsed`, `logs`, …) in the delivered payload under `meta.receipt`. Default false (the receipt is an extra fetch). Mirrors the read endpoint\u2019s `include=receipt`.',
-            ),
-            z.meta({ examples: [true] }),
-          ),
-      ),
       value: z.optional(compare.check(z.describe('Match the transaction value (wei) bounds.'))),
       input: z.optional(
         bytes.check(
@@ -305,9 +294,7 @@ export namespace schema {
       feeToken: z.optional(
         eq(Schema.TokenAddress).check(z.describe('Match the fee token address.')),
       ),
-      feePayer: z.optional(eq(Schema.Address).check(z.describe('Match the fee payer address.'))),
       gasLimit: z.optional(compare.check(z.describe('Match the gas limit bounds.'))),
-      gasUsed: z.optional(compare.check(z.describe('Match the gas used bounds.'))),
       maxFeePerGas: z.optional(compare.check(z.describe('Match the max fee per gas bounds.'))),
       maxPriorityFeePerGas: z.optional(
         compare.check(z.describe('Match the max priority fee per gas bounds.')),
@@ -322,14 +309,6 @@ export namespace schema {
       timestamp: z.optional(
         compare.check(z.describe('Match the block timestamp bounds (unix s).')),
       ),
-      status: z.optional(
-        z
-          .enum(['success', 'reverted'])
-          .check(
-            z.describe('Match the receipt execution status (routes through `receipts`).'),
-            z.meta({ examples: ['success'] }),
-          ),
-      ),
     })
     .check(
       z.describe('Filters that narrow which included transactions trigger this webhook.'),
@@ -685,7 +664,7 @@ export namespace schema {
         .datetime()
         .check(
           z.describe('Block timestamp as an ISO 8601 string.'),
-          z.meta({ examples: ['2026-01-14T18:38:03.000Z'] }),
+          z.meta({ examples: ['2026-01-14T18:38:03.685Z'] }),
         ),
       token: z.optional(
         z
@@ -720,10 +699,21 @@ export namespace schema {
     )
 
   /**
-   * A `transaction` event payload: identical to the `GET /transactions/:hash`
-   * response (the poller reuses the same humanized shape).
+   * A `transaction` event payload using the humanized transaction shape without
+   * opt-in read resources such as receipts.
    */
-  export const TransactionEvent = Transactions.schema.getTransaction.Response
+  export const TransactionEvent = z
+    .object({
+      ...Transactions.schema.Transaction.shape,
+      meta: z
+        .object({
+          rpc: Transactions.schema.Rpc.Transaction.check(
+            z.describe('The original JSON-RPC transaction payload.'),
+          ),
+        })
+        .check(z.describe('Metadata for this transaction webhook event.')),
+    })
+    .check(z.describe('A transaction included in a block.'))
 
   /**
    * A `log:emitted` event payload: the raw contract event log. When a
@@ -800,7 +790,7 @@ export namespace schema {
         .datetime()
         .check(
           z.describe('When the block was produced, as an ISO 8601 timestamp.'),
-          z.meta({ examples: ['2026-01-14T18:38:03.000Z'] }),
+          z.meta({ examples: ['2026-01-14T18:38:03.685Z'] }),
         ),
       topics: z.array(Schema.Hash).check(
         z.describe('Log topics, starting with the event signature hash (topic 0).'),
@@ -830,7 +820,7 @@ export namespace schema {
     })
     .check(z.describe('Payload for a `log:emitted` event (a raw contract event log).'))
 
-  /** Payload for a `block:created` event (a TIDX-derived block header). */
+  /** Payload for a `block:created` event (an RPC-derived block header). */
   export const BlockEvent = z
     .object({
       number: z
@@ -891,7 +881,7 @@ export namespace schema {
         .datetime()
         .check(
           z.describe('When the block was produced, as an ISO 8601 timestamp.'),
-          z.meta({ examples: ['2026-01-14T18:38:03.000Z'] }),
+          z.meta({ examples: ['2026-01-14T18:38:03.685Z'] }),
         ),
     })
     .check(z.describe('Payload for a `block:created` event (a new block header).'))
@@ -1893,15 +1883,9 @@ const scanPageSize = 100
 type ScanItem = { cursor: readonly [number, number]; data: unknown }
 
 /**
- * The result of scanning one subscription page. Two flavours:
- *
- * - **window** (the RPC scanners): `scannedThrough` is the highest block fully
- *   scanned. A batch-limited page omits it, so the poller resumes after the last
- *   dispatched row instead of skipping later matches.
- * - **keyset** (the TIDX legacy scanners): rows come back `LIMIT`-bounded, so
- *   the page only reports whether `hasMore` rows remain past it; the poller
- *   advances only past the last dispatched row (jumping to the window end only
- *   when the page was empty and complete).
+ * The result of scanning one subscription page. `scannedThrough` is the
+ * highest block fully scanned. A batch-limited page omits it, so the poller
+ * resumes after the last dispatched row instead of skipping later matches.
  */
 type ScanPage = {
   hasMore?: boolean | undefined
@@ -1912,11 +1896,63 @@ type ScanPage = {
 /** Per-subscription state retained between fair scan passes. */
 type PollState = {
   cursor: string
+  filters: Record<string, unknown>
   remaining: number
   safeBlock: number
   subscription: Webhooks.Subscription
 }
 
+/** Concurrent per-subscription scans and cursor writes per poll round; caps RPC and DB fan-out. */
+const pollConcurrency = 8
+
+/** Event types scanned together when their combined state fits one existing scan round. */
+const pollEventTypeConcurrency = 2
+
+/** Maximum subscription states retained by concurrent event-type scan batches. */
+const pollStateLimit = WebhookTransfer.scanCohortSize * pollConcurrency
+
+type Schedule = <value>(fn: () => Promise<value>) => Promise<value>
+
+/** Schedules asynchronous work through one shared concurrency bound. */
+function createLimiter(limit: number): Schedule {
+  let active = 0
+  const waiting: (() => void)[] = []
+  return async (fn) => {
+    if (active >= limit) await new Promise<void>((resolve) => waiting.push(resolve))
+    else active++
+    try {
+      return await fn()
+    } finally {
+      const next = waiting.shift()
+      if (next) next()
+      else active--
+    }
+  }
+}
+
+/** Runs `fn` over `items` with at most `limit` in flight, preserving order. */
+async function mapWithLimit<item, value>(
+  items: readonly item[],
+  limit: number,
+  fn: (item: item) => Promise<value>,
+): Promise<PromiseSettledResult<value>[]> {
+  const results: PromiseSettledResult<value>[] = []
+  let next = 0
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, async () => {
+      while (next < items.length) {
+        const index = next++
+        try {
+          results[index] = { status: 'fulfilled', value: await fn(items[index]!) }
+        } catch (reason) {
+          results[index] = { reason, status: 'rejected' }
+        }
+      }
+    }),
+  )
+  return results
+}
+
 /** Returns `candidate` only when it is lexicographically after `current`. */
 function laterCursor(current: string, candidate: string): string {
   const before = Cursor.decode(current, ['int', 'int'])
@@ -1935,13 +1971,9 @@ function laterCursor(current: string, candidate: string): string {
  * matching row, advancing each active subscription's `(block, index)` keyset
  * cursor.
  *
- * The new monitoring event types (`log:emitted`, `block:created`,
- * `transaction:included`) scan a **narrow confirmed window** `[cursor, head -
- * confirmations]` directly over JSON-RPC (`eth_getLogs`, `eth_getBlockByNumber`,
- * `eth_getBlockReceipts`) — the same data sources the indexer itself consumes —
- * so they need no indexer and stay fresh. The pre-existing `token:transfer`
- * type continues to read its humanized shape from TIDX, clamped to the indexed
- * head so it never runs ahead of the indexer.
+ * Every event type scans a **narrow confirmed window** `[cursor, head -
+ * confirmations]` directly over JSON-RPC (`eth_getLogs`,
+ * `eth_getBlockByNumber`) so webhook delivery does not wait for an indexer.
  *
  * The chain head is injectable (tests pin a fixed historical window); only
  * blocks at least `confirmations` behind head are emitted, giving at-least-once,
@@ -1959,37 +1991,51 @@ export async function poll(options: poll.Options): Promise<poll.Result> {
     cache: cache_metadata = Store.memory(),
     chainId,
     client,
-    confirmations = 2,
+    confirmations = 1,
     db,
-    eventTypes = ['token:transfer', 'transaction:included', 'log:emitted', 'block:created'],
+    eventTypes: eventTypes_input = [
+      'token:transfer',
+      'transaction:included',
+      'log:emitted',
+      'block:created',
+    ],
     maxBlocks = 1_000,
-    tidx,
   } = options
   const now = options.now ?? (() => new Date())
+  options.signal?.throwIfAborted()
   // Default (self-host) transport: deliver inline and record the outcome so a
   // sustained-failure subscription auto-disables. On Cloudflare, callers pass a
   // Queue producer instead and the consumer runs `deliverAndRecord`.
   const dispatch =
     options.dispatch ??
     (({ envelope, subscription }) => Webhooks.deliverAndRecord(db, subscription, envelope))
+  const dispatchBatch = options.dispatchBatch
 
-  // Head resolution is lazy and per-source. RPC types work back from the live
-  // RPC head; the legacy TIDX types from the indexed head (never ahead of the
-  // indexer). A pinned `headBlockNumber` (tests) overrides both.
+  // A pinned `headBlockNumber` lets a head subscription supply the exact live
+  // boundary and keeps historical tests deterministic.
   const override = options.headBlockNumber
   let rpcHead: number | undefined = override === undefined ? undefined : Number(override)
   const resolveRpcHead = async () => (rpcHead ??= await getRpcHead(client))
-  let tidxHead: number | undefined = override === undefined ? undefined : Number(override)
-  const resolveTidxHead = async () =>
-    (tidxHead ??= tidx ? await getIndexedHead(tidx, chainId) : await resolveRpcHead())
-
-  const rpcSafeBlock = Math.max(0, (await resolveRpcHead()) - confirmations)
-  // Reclaim expired rows (MPP-owned subscriptions, aged delivery logs) once
-  // per tick; reads filter expiry at query time, so this is hygiene only.
-  await Webhooks.pruneExpired(db, { now }).catch(() => {})
-  // Per-tick lazy cache so multiple subscriptions of the same/related types
-  // share fetched blocks and receipts instead of refetching the same window.
-  const cache = createChainCache(client)
+
+  const headStartedAt = Date.now()
+  const rpcSafeBlock = await (async () => {
+    try {
+      const safeBlock = Math.max(0, (await resolveRpcHead()) - confirmations)
+      options.onStage?.({
+        durationMs: Date.now() - headStartedAt,
+        outcome: 'ok',
+        stage: 'rpc_head',
+      })
+      return safeBlock
+    } catch (error) {
+      options.onStage?.({
+        durationMs: Date.now() - headStartedAt,
+        outcome: 'error',
+        stage: 'rpc_head',
+      })
+      throw error
+    }
+  })()
   const result: poll.Result = {
     chainId,
     dispatched: 0,
@@ -1998,134 +2044,337 @@ export async function poll(options: poll.Options): Promise<poll.Result> {
     scanned: 0,
     subscriptions: 0,
   }
-  const scanErrors: unknown[] = []
-
-  for (const eventType of eventTypes) {
-    const legacy = eventType === 'token:transfer'
-    const safeBlock = legacy ? Math.max(0, (await resolveTidxHead()) - confirmations) : rpcSafeBlock
-    const subscriptions = await Webhooks.listActive(db, chainId, eventType)
-    let states: PollState[] = []
-    for (const subscription of subscriptions) {
-      result.subscriptions++
-      let cursor = await Webhooks.getCursor(db, subscription.id)
-      if (cursor === null) {
-        // Legacy subscriptions without a creation checkpoint anchor at the
-        // current confirmed head, avoiding a genesis backfill.
-        await Webhooks.compareAndSetCursor(db, {
-          cursor: Cursor.encode([safeBlock, endOfBlockIndex]),
-          expectedCursor: null,
-          subscriptionId: subscription.id,
-        })
-        continue
+  let cursorLagBlocks = 0
+  const pollErrors: unknown[] = []
+
+  const eventTypes = [...new Set(eventTypes_input)]
+  const subscriptionsStartedAt = Date.now()
+  const pairs = await Webhooks.listActiveForChain(db, { chainId, eventTypes })
+  options.signal?.throwIfAborted()
+  options.onSubscriptions?.(pairs.length)
+  options.onStage?.({
+    durationMs: Date.now() - subscriptionsStartedAt,
+    outcome: 'ok',
+    stage: 'subscription_read',
+  })
+  const pairsByEventType = Map.groupBy(pairs, (pair) => pair.subscription.eventType)
+  const eventTypes_active = eventTypes.filter(
+    (eventType) => (pairsByEventType.get(eventType)?.length ?? 0) > 0,
+  )
+  const eventTypeConcurrency =
+    pairs.length <= pollStateLimit
+      ? Math.min(pollEventTypeConcurrency, eventTypes_active.length)
+      : Math.min(1, eventTypes_active.length)
+  const scanRoundSize = Math.floor(pollStateLimit / Math.max(1, eventTypeConcurrency))
+  const scheduleScan = createLimiter(pollConcurrency)
+
+  const eventTypeResults = await mapWithLimit(
+    eventTypes_active,
+    eventTypeConcurrency,
+    async (eventType) => {
+      options.signal?.throwIfAborted()
+      const safeBlock = rpcSafeBlock
+      const pairs = pairsByEventType.get(eventType) ?? []
+      const durations = {
+        cursor_write: 0,
+        enrich: 0,
+        scan: 0,
+      } satisfies Record<Exclude<MetricSink.PollStage, 'rpc_head' | 'subscription_read'>, number>
+      const observed = new Set<keyof typeof durations>()
+      let cursorWriteOutcome: 'error' | 'ok' = 'ok'
+      let scanOutcome: 'error' | 'ok' = 'ok'
+      const writeCursor = async (parameters: Webhooks.compareAndSetCursor.Options) => {
+        const startedAt = Date.now()
+        observed.add('cursor_write')
+        try {
+          return await Webhooks.compareAndSetCursor(db, parameters)
+        } catch (error) {
+          cursorWriteOutcome = 'error'
+          pollErrors.push(error)
+          return false
+        } finally {
+          durations.cursor_write += Date.now() - startedAt
+        }
       }
-      const checkpoint = Cursor.decode(cursor, ['int'])
-      if (checkpoint) {
-        // Creation checkpoints record the live head without finalizing it. Rebase
-        // to this poller's confirmed boundary so replacement blocks stay eligible.
-        const confirmedCursor = Cursor.encode([
-          Math.max(0, (checkpoint[0] as number) - confirmations),
-          endOfBlockIndex,
-        ])
-        const committed = await Webhooks.compareAndSetCursor(db, {
-          cursor: confirmedCursor,
-          expectedCursor: cursor,
-          subscriptionId: subscription.id,
+      let states: PollState[] = []
+      for (const pair of pairs) {
+        const { subscription } = pair
+        result.subscriptions++
+        let filters: Record<string, unknown>
+        try {
+          filters = parseFilters(subscription.eventType, subscription.filters)
+        } catch (error) {
+          if (!(error instanceof Webhooks.InvalidFilterError)) throw error
+          options.signal?.throwIfAborted()
+          // A breaking filter-schema removal must not poison every chain poll.
+          // Disable the legacy subscription without widening its match set.
+          await Webhooks.updateSubscription(db, subscription.owner, subscription.id, {
+            status: 'disabled',
+          })
+          continue
+        }
+        let cursor = pair.cursor
+        if (cursor === null) {
+          // Legacy subscriptions without a creation checkpoint anchor at the
+          // current confirmed head, avoiding a genesis backfill.
+          await writeCursor({
+            cursor: Cursor.encode([safeBlock, endOfBlockIndex]),
+            expectedCursor: null,
+            subscriptionId: subscription.id,
+          })
+          continue
+        }
+        const checkpoint = Cursor.decode(cursor, ['int'])
+        if (checkpoint) {
+          // Creation checkpoints record the live head without finalizing it. Rebase
+          // to this poller's confirmed boundary so replacement blocks stay eligible.
+          const confirmedCursor = Cursor.encode([
+            Math.max(0, (checkpoint[0] as number) - confirmations),
+            endOfBlockIndex,
+          ])
+          const committed = await writeCursor({
+            cursor: confirmedCursor,
+            expectedCursor: cursor,
+            subscriptionId: subscription.id,
+          })
+          if (!committed) continue
+          cursor = confirmedCursor
+        }
+        const position = Cursor.decode(cursor, ['int', 'int'])
+        if (position)
+          cursorLagBlocks = Math.max(cursorLagBlocks, safeBlock - (position[0] as number))
+        const window = scanWindow(cursor, safeBlock, maxBlocks)
+        if (window && window.to < safeBlock) result.hasMore = true
+        states.push({
+          cursor,
+          filters,
+          remaining: batchSize,
+          safeBlock: window?.to ?? safeBlock,
+          subscription,
         })
-        if (!committed) continue
-        cursor = confirmedCursor
       }
-      const window = legacy ? undefined : scanWindow(cursor, safeBlock, maxBlocks)
-      states.push({
-        cursor,
-        remaining: batchSize,
-        safeBlock: window?.to ?? safeBlock,
-        subscription,
-      })
-    }
 
-    // Every subscription gets one bounded page before any subscription gets a
-    // continuation page, preserving fairness while allowing catch-up.
-    while (states.length > 0) {
-      const continuations: PollState[] = []
-      for (const state of states) {
-        const { subscription } = state
-        let page: ScanPage
-        try {
-          page = await scanSubscription({
-            batchSize: Math.min(scanPageSize, state.remaining),
-            cache,
+      // Every subscription gets one bounded page before any subscription gets a
+      // continuation page, preserving fairness while allowing catch-up.
+      while (states.length > 0) {
+        options.signal?.throwIfAborted()
+        const continuations: PollState[] = []
+        const round = states
+        for (let offset = 0; offset < round.length; offset += scanRoundSize) {
+          const batch = round.slice(offset, offset + scanRoundSize)
+          const windows = batch.flatMap((state) => {
+            const window = scanWindow(state.cursor, state.safeBlock, maxBlocks)
+            return window ? [window] : []
+          })
+          const maxWindowBlocks = Math.max(
+            0,
+            ...windows.map((window) => window.to - window.from + 1),
+          )
+          const totalWindowBlocks = windows.reduce(
+            (total, window) => total + window.to - window.from + 1,
+            0,
+          )
+          options.onScanCheckpoint?.({
+            concurrency: pollConcurrency,
+            eventType,
+            maxWindowBlocks,
+            phase: 'start',
+            rpcMethod: scanRpcMethod(eventType),
+            subscriptionLimit: scanRoundSize,
+            subscriptionCount: batch.length,
+            totalWindowBlocks,
+          })
+          const scanStartedAt = Date.now()
+          const pages = await scanSubscriptions({
             client,
-            cursor: state.cursor,
+            eventType,
             maxBlocks,
-            safeBlock: state.safeBlock,
-            subscription,
-            tidx,
+            schedule: scheduleScan,
+            states: batch,
           })
-        } catch (error) {
-          scanErrors.push(error)
-          continue
-        }
-        result.scanned += page.items.length
-        state.remaining -= page.items.length
-
-        let accepted: readonly [number, number] | undefined
-        let failed = false
-        for (const item of page.items) {
-          // Token metadata is best-effort for webhooks: transfers use it for display,
-          // while transactions expose fee-token references without blocking delivery.
-          const data =
-            eventType === 'token:transfer'
-              ? await withTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
-              : eventType === 'transaction:included'
-                ? await withFeeTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
-                : item.data
-          const envelope = Webhooks.buildEnvelope({
-            blockNumber: item.cursor[0],
-            createdAt: now(),
-            data,
-            logIndex: item.cursor[1],
-            subscription,
+          options.onScanCheckpoint?.({
+            concurrency: pollConcurrency,
+            durationMs: Date.now() - scanStartedAt,
+            eventType,
+            failedSubscriptions: pages.filter((page) => page.status === 'rejected').length,
+            matchedItems: pages.reduce(
+              (total, page) => total + (page.status === 'fulfilled' ? page.value.items.length : 0),
+              0,
+            ),
+            maxWindowBlocks,
+            outcome: scanResultOutcome(pages),
+            phase: 'complete',
+            rpcMethod: scanRpcMethod(eventType),
+            subscriptionLimit: scanRoundSize,
+            subscriptionCount: batch.length,
+            totalWindowBlocks,
           })
-          const delivered = await dispatch({ envelope, subscription })
-          if (!delivered.ok) {
-            result.failed++
-            failed = true
-            break
+          options.signal?.throwIfAborted()
+          durations.scan += Date.now() - scanStartedAt
+          observed.add('scan')
+          if (pages.some((page) => page.status === 'rejected')) scanOutcome = 'error'
+
+          type Scanned = { page: ScanPage; state: PollState }
+          const busy: Scanned[] = []
+          const idle: Scanned[] = []
+          for (let i = 0; i < batch.length; i++) {
+            const state = batch[i]!
+            const settled = pages[i]!
+            if (settled.status === 'rejected') {
+              pollErrors.push(settled.reason)
+              continue
+            }
+            result.scanned += settled.value.items.length
+            state.remaining -= settled.value.items.length
+            ;(settled.value.items.length > 0 ? busy : idle).push({ page: settled.value, state })
           }
-          accepted = item.cursor
-          result.dispatched++
-        }
 
-        // Persist every accepted page before another subscription begins its
-        // continuation, so a later scan failure retains completed work.
-        const candidate = (() => {
-          if (failed) return accepted ? Cursor.encode([...accepted]) : undefined
-          if (page.scannedThrough !== undefined)
-            return Cursor.encode([page.scannedThrough, endOfBlockIndex])
-          if (accepted) return Cursor.encode([...accepted])
-          if (!page.hasMore) return Cursor.encode([state.safeBlock, endOfBlockIndex])
-          return undefined
-        })()
-        const cursor = candidate ? laterCursor(state.cursor, candidate) : state.cursor
-        const progressed = cursor !== state.cursor
-        let committed = false
-        if (progressed) {
-          committed = await Webhooks.compareAndSetCursor(db, {
-            cursor,
-            expectedCursor: state.cursor,
-            subscriptionId: subscription.id,
+          // Empty pages only advance their cursor: no dispatch order to preserve,
+          // so one statement commits the cohort while retaining per-row CAS semantics.
+          const cursorWritesStartedAt = Date.now()
+          const candidates = idle.flatMap(({ page, state }) => {
+            options.signal?.throwIfAborted()
+            const candidate =
+              page.scannedThrough !== undefined
+                ? Cursor.encode([page.scannedThrough, endOfBlockIndex])
+                : page.hasMore
+                  ? undefined
+                  : Cursor.encode([state.safeBlock, endOfBlockIndex])
+            const cursor = candidate ? laterCursor(state.cursor, candidate) : state.cursor
+            return cursor === state.cursor ? [] : [{ cursor, state }]
           })
-          if (committed) state.cursor = cursor
-        }
+          if (candidates.length > 0) {
+            const committed = await (async () => {
+              try {
+                return await Webhooks.compareAndSetCursors(db, {
+                  cursors: candidates.map(({ cursor, state }) => ({
+                    cursor,
+                    expectedCursor: state.cursor,
+                    subscriptionId: state.subscription.id,
+                  })),
+                })
+              } catch (error) {
+                cursorWriteOutcome = 'error'
+                pollErrors.push(error)
+                return new Set<string>()
+              }
+            })()
+            for (const { cursor, state } of candidates)
+              if (committed.has(state.subscription.id)) state.cursor = cursor
+            durations.cursor_write += Date.now() - cursorWritesStartedAt
+            observed.add('cursor_write')
+          }
 
-        if (!failed && page.hasMore === true && committed && state.remaining > 0)
-          continuations.push(state)
+          for (const { page, state } of busy) {
+            options.signal?.throwIfAborted()
+            const { subscription } = state
+
+            let accepted: readonly [number, number] | undefined
+            let failed = false
+            const buildDispatchable = async (item: ScanItem): Promise<poll.Dispatchable> => {
+              options.signal?.throwIfAborted()
+              // Token metadata is best-effort for webhooks: transfers use it for display,
+              // while transactions expose fee-token references without blocking delivery.
+              const enrichStartedAt = Date.now()
+              const data =
+                eventType === 'token:transfer'
+                  ? await withTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
+                  : eventType === 'transaction:included'
+                    ? await withFeeTokenMetadata(item.data, {
+                        cache: cache_metadata,
+                        chainId,
+                        client,
+                      })
+                    : item.data
+              durations.enrich += Date.now() - enrichStartedAt
+              observed.add('enrich')
+              options.signal?.throwIfAborted()
+              const envelope = Webhooks.buildEnvelope({
+                blockNumber: item.cursor[0],
+                createdAt: now(),
+                data,
+                logIndex: item.cursor[1],
+                subscription,
+              })
+              return { envelope, subscription }
+            }
+
+            if (dispatchBatch) {
+              const dispatchables: poll.Dispatchable[] = []
+              for (const item of page.items) dispatchables.push(await buildDispatchable(item))
+              options.signal?.throwIfAborted()
+              const delivered = await dispatchBatch(dispatchables, { db })
+              if (delivered.ok) {
+                accepted = page.items.at(-1)?.cursor
+                result.dispatched += dispatchables.length
+              } else {
+                result.failed += dispatchables.length
+                failed = true
+              }
+            } else {
+              for (const item of page.items) {
+                const dispatchable = await buildDispatchable(item)
+                const delivered = await dispatch(dispatchable)
+                if (!delivered.ok) {
+                  result.failed++
+                  failed = true
+                  break
+                }
+                accepted = item.cursor
+                result.dispatched++
+              }
+            }
+
+            // Persist every accepted page before another subscription begins its
+            // continuation, so a later scan failure retains completed work.
+            const candidate = (() => {
+              if (failed) return accepted ? Cursor.encode([...accepted]) : undefined
+              if (page.scannedThrough !== undefined)
+                return Cursor.encode([page.scannedThrough, endOfBlockIndex])
+              if (accepted) return Cursor.encode([...accepted])
+              if (!page.hasMore) return Cursor.encode([state.safeBlock, endOfBlockIndex])
+              return undefined
+            })()
+            const cursor = candidate ? laterCursor(state.cursor, candidate) : state.cursor
+            const progressed = cursor !== state.cursor
+            let committed = false
+            if (progressed) {
+              committed = await writeCursor({
+                cursor,
+                expectedCursor: state.cursor,
+                subscriptionId: subscription.id,
+              })
+              if (committed) state.cursor = cursor
+            }
+
+            if (!failed && page.hasMore === true) {
+              if (committed && state.remaining > 0) continuations.push(state)
+              else result.hasMore = true
+            }
+          }
+        }
+        states = continuations
       }
-      states = continuations
-    }
-  }
+      for (const stage of observed) {
+        const outcome = (() => {
+          if (stage === 'cursor_write') return cursorWriteOutcome
+          if (stage === 'scan') return scanOutcome
+          return 'ok'
+        })()
+        options.onStage?.({
+          durationMs: durations[stage],
+          eventType,
+          outcome,
+          stage,
+        })
+      }
+    },
+  )
+  for (const result of eventTypeResults)
+    if (result.status === 'rejected') pollErrors.push(result.reason)
 
-  if (scanErrors.length > 0) throw scanErrors[0]
+  options.onCursorLag?.(cursorLagBlocks)
+  if (pollErrors.length > 0) throw pollErrors[0]
   return result
 }
 
@@ -2145,9 +2394,9 @@ export declare namespace poll {
     cache?: Store.Store | undefined
     /** Chain to poll. Callers loop over chains. */
     chainId: number
-    /** viem RPC client for the chain (used by the RPC monitoring scanners). */
+    /** viem RPC client for the chain. */
     client: Viem.getClient.ReturnType
-    /** Reorg-safety window: only emit blocks this far behind head (default 2). */
+    /** Reorg-safety window: only emit blocks this far behind head (default 1). */
     confirmations?: number | undefined
     /** Database holding subscriptions + cursors. */
     db: Db.Db
@@ -2156,16 +2405,34 @@ export declare namespace poll {
      * on Cloudflare pass a Queue producer so retry/backoff/DLQ are native.
      */
     dispatch?: ((input: Dispatchable) => Promise<Webhooks.Result>) | undefined
+    /** Batch delivery transport. A successful result confirms every row in the input. */
+    dispatchBatch?:
+      | ((input: readonly Dispatchable[], context: DispatchContext) => Promise<Webhooks.Result>)
+      | undefined
     /** Event types to poll (default all). */
     eventTypes?: readonly EventType[] | undefined
     /** Current chain head; the poller emits up to `head - confirmations`. */
     headBlockNumber?: bigint | number | undefined
     /** Backfill cap: most blocks an RPC scanner inspects per tick (default 1000). */
     maxBlocks?: number | undefined
+    /** Records the worst confirmed-head distance without changing the poll result. */
+    onCursorLag?: ((blocks: number) => void) | undefined
+    /** Records bounded scan inputs before allocation and outcomes after completion. */
+    onScanCheckpoint?: ((checkpoint: ScanCheckpoint) => void) | undefined
+    /** Records bounded, per-tick poll-stage timings without subscription identities. */
+    onStage?: ((stage: Stage) => void) | undefined
+    /** Records subscriptions eligible for this poll before any scan runs. */
+    onSubscriptions?: ((count: number) => void) | undefined
     /** Clock for envelope timestamps; injectable for tests. */
     now?: (() => Date) | undefined
-    /** TIDX query client for the legacy `token:transfer` type. */
-    tidx?: Tidx.Client | undefined
+    /** Stops scanning and dispatch when the caller loses its execution lease. */
+    signal?: AbortSignal | undefined
+  }
+
+  /** Runtime context shared with a batch delivery transport. */
+  type DispatchContext = {
+    /** Database instance already resolved for this poll. */
+    db: Db.Db
   }
   /** Summary counters for one poll tick. */
   type Result = {
@@ -2175,6 +2442,8 @@ export declare namespace poll {
     dispatched: number
     /** Rows whose dispatch failed (pausing that subscription). */
     failed: number
+    /** True when a bounded scan left committed work behind the same head. */
+    hasMore?: boolean | undefined
     /** Highest confirmed block emitted this tick (`head - confirmations`). */
     safeBlock: number
     /** Total rows scanned across all subscriptions. */
@@ -2182,6 +2451,44 @@ export declare namespace poll {
     /** Active subscriptions visited. */
     subscriptions: number
   }
+  /** One scan boundary used to correlate production memory failures with workload shape. */
+  type ScanCheckpoint = {
+    /** Shared upper bound for concurrent upstream scans across event types. */
+    concurrency: number
+    /** Scan duration, present only after completion. */
+    durationMs?: number | undefined
+    /** Subscription event type scanned by this batch. */
+    eventType: EventType
+    /** Subscriptions whose scan rejected, present only after completion. */
+    failedSubscriptions?: number | undefined
+    /** Matching rows retained by completed pages, present only after completion. */
+    matchedItems?: number | undefined
+    /** Largest block window requested by one subscription. */
+    maxWindowBlocks: number
+    /** Whether the checkpoint precedes allocation or follows scan completion. */
+    phase: 'complete' | 'start'
+    /** Outcome of the completed RPC-backed scan. */
+    outcome?: 'empty' | 'error' | 'missing' | 'ok' | undefined
+    /** JSON-RPC method used by this event type's scanner. */
+    rpcMethod: 'eth_getBlockByNumber' | 'eth_getLogs'
+    /** Subscriptions retained in this scan batch. */
+    subscriptionCount: number
+    /** Maximum subscriptions retained by this event-type batch. */
+    subscriptionLimit: number
+    /** Sum of subscription block windows in this scan batch. */
+    totalWindowBlocks: number
+  }
+  /** One bounded poll-stage timing observation. */
+  type Stage = {
+    /** Stage duration in milliseconds. */
+    durationMs: number
+    /** Event type being processed, omitted for the shared RPC-head stage. */
+    eventType?: EventType | undefined
+    /** Whether the stage completed. */
+    outcome: 'error' | 'ok'
+    /** Bounded stage name. */
+    stage: MetricSink.PollStage
+  }
 }
 
 /**
@@ -2270,7 +2577,7 @@ function withResolvedFeeToken(data: Record<string, unknown>, metadata: Map<strin
   return result
 }
 
-/** Adds best-effort fee-token references to a transaction and its embedded receipt. */
+/** Adds a best-effort fee-token reference to a transaction. */
 async function withFeeTokenMetadata(
   data: unknown,
   deps: {
@@ -2281,37 +2588,12 @@ async function withFeeTokenMetadata(
 ): Promise<unknown> {
   if (typeof data !== 'object' || data === null) return data
   const transaction = data as Record<string, unknown>
-  const meta = transaction['meta']
-  const receipt =
-    typeof meta === 'object' && meta !== null
-      ? (meta as Record<string, unknown>)['receipt']
-      : undefined
-  const addresses = new Set<string>()
-  const transactionAddress = feeTokenAddress(transaction['feeToken'])
-  if (transactionAddress) addresses.add(transactionAddress.toLowerCase())
-  if (typeof receipt === 'object' && receipt !== null) {
-    const receiptAddress = feeTokenAddress((receipt as Record<string, unknown>)['feeToken'])
-    if (receiptAddress) addresses.add(receiptAddress.toLowerCase())
-  }
-  if (addresses.size === 0) return data
-
-  const resolved = await Promise.all(
-    [...addresses].map(
-      async (address) => [address, await resolveTokenMetadata(address, deps)] as const,
-    ),
-  )
-  const metadata = new Map(
-    resolved.filter((entry): entry is readonly [string, TokenMetadata] => entry[1] !== undefined),
-  )
-  const result = withResolvedFeeToken(transaction, metadata)
-  if (typeof receipt !== 'object' || receipt === null) return result
-  return {
-    ...result,
-    meta: {
-      ...(meta as Record<string, unknown>),
-      receipt: withResolvedFeeToken(receipt as Record<string, unknown>, metadata),
-    },
-  }
+  const address = feeTokenAddress(transaction['feeToken'])
+  if (!address) return data
+  const token = await resolveTokenMetadata(address, deps)
+  const metadata = new Map<string, TokenMetadata>()
+  if (token) metadata.set(address.toLowerCase(), token)
+  return withResolvedFeeToken(transaction, metadata)
 }
 
 /** Returns the live RPC head block number for the chain. */
@@ -2319,81 +2601,74 @@ export async function getRpcHead(client: Viem.getClient.ReturnType): Promise<num
   return Number(await client.getBlockNumber())
 }
 
-/**
- * Returns the highest block number TIDX has indexed for a chain (0 when none).
- * The legacy `token:transfer` type works back from this so it never scans past
- * the indexer.
- */
-export async function getIndexedHead(tidx: Tidx.Client, chainId: number): Promise<number> {
-  const result = await tidx.fetch({
-    chainId,
-    query: 'SELECT num FROM blocks ORDER BY num DESC LIMIT 1' as string,
-  })
-  return Value.toNumber(result.rows[0]?.['num']) ?? 0
-}
-
-/**
- * Scans new events for one subscription. The RPC monitoring types
- * (`log:emitted` / `block:created` / `transaction:included`) read a confirmed
- * window directly over JSON-RPC; the legacy `token:transfer` type dispatches to
- * its TIDX read core (`Transfers.scan`).
- */
-async function scanSubscription(options: {
-  batchSize: number
-  cache: ChainCache
+/** Groups aligned cursors only when their bounded upstream scans are equivalent. */
+async function scanSubscriptions(options: {
   client: Viem.getClient.ReturnType
-  cursor: string | undefined
+  eventType: EventType
   maxBlocks: number
-  safeBlock: number
-  subscription: Webhooks.Subscription
-  tidx: Tidx.Client | undefined
-}): Promise<ScanPage> {
-  const { batchSize, cache, client, cursor, maxBlocks, safeBlock, subscription, tidx } = options
-  // Stored `chainId` was validated against `Schema.ChainId` at create time.
-  const chainId = subscription.chainId as z.output<typeof Schema.ChainId>
-
-  if (subscription.eventType === 'log:emitted')
-    return scanLogs({
-      batchSize,
-      cache,
-      client,
-      cursor,
-      filters: parseFilters('log:emitted', subscription.filters),
-      maxBlocks,
-      safeBlock,
-    })
+  schedule: Schedule
+  states: readonly PollState[]
+}): Promise<PromiseSettledResult<ScanPage>[]> {
+  const { client, eventType, maxBlocks, schedule, states } = options
+  if (eventType !== 'token:transfer')
+    return scanIndependent({ client, eventType, maxBlocks, schedule, states })
+  return WebhookTransfer.scan({
+    client,
+    concurrency: pollConcurrency,
+    maxBlocks,
+    schedule,
+    states: states.map((state) => ({
+      filters: state.filters,
+      limit: Math.min(scanPageSize, state.remaining),
+      window: scanWindow(state.cursor, state.safeBlock, maxBlocks),
+    })),
+  })
+}
 
-  if (subscription.eventType === 'block:created')
-    return scanBlocks({
-      batchSize,
-      cache,
-      cursor,
-      filters: parseFilters('block:created', subscription.filters),
-      maxBlocks,
-      safeBlock,
-    })
+/** Returns the bounded JSON-RPC method used by an event scanner. */
+function scanRpcMethod(eventType: EventType): poll.ScanCheckpoint['rpcMethod'] {
+  return eventType === 'block:created' || eventType === 'transaction:included'
+    ? 'eth_getBlockByNumber'
+    : 'eth_getLogs'
+}
 
-  if (subscription.eventType === 'transaction:included')
-    return scanTxs({
-      batchSize,
-      cache,
-      cursor,
-      filters: parseFilters('transaction:included', subscription.filters),
-      maxBlocks,
-      safeBlock,
-    })
+/** Classifies a completed batch without exposing an unbounded upstream error. */
+function scanResultOutcome(
+  pages: readonly PromiseSettledResult<ScanPage>[],
+): NonNullable<poll.ScanCheckpoint['outcome']> {
+  const rejected = pages.filter((page) => page.status === 'rejected')
+  if (rejected.some((page) => page.reason instanceof BlockUnavailableError)) return 'missing'
+  if (rejected.length > 0) return 'error'
+  return pages.every((page) => page.status === 'fulfilled' && page.value.items.length === 0)
+    ? 'empty'
+    : 'ok'
+}
 
-  // Legacy TIDX-backed type.
-  if (!tidx) return { hasMore: false, items: [] }
-  const filters = transferFilters(subscription.filters)
-  const page = await Transfers.scan(
-    { tidx },
-    { chainId, cursor, limit: batchSize, order: 'asc', toBlock: safeBlock, ...filters },
+/** Scans CPU-matched streams per subscription while sharing concurrent block reads. */
+function scanIndependent(options: {
+  client: Viem.getClient.ReturnType
+  eventType: Exclude<EventType, 'token:transfer'>
+  maxBlocks: number
+  schedule: Schedule
+  states: readonly PollState[]
+}): Promise<PromiseSettledResult<ScanPage>[]> {
+  const { client, eventType, maxBlocks, schedule, states } = options
+  const cache = createChainCache(client)
+  return mapWithLimit(states, pollConcurrency, (state) =>
+    schedule(() => {
+      const shared = {
+        batchSize: Math.min(scanPageSize, state.remaining),
+        cache,
+        cursor: state.cursor,
+        filters: state.filters,
+        maxBlocks,
+        safeBlock: state.safeBlock,
+      }
+      if (eventType === 'block:created') return scanBlocks(shared)
+      if (eventType === 'log:emitted') return scanLogs({ ...shared, client })
+      return scanTxs(shared)
+    }),
   )
-  // A cap-truncated fallback sample is an arbitrary subset: dispatching it
-  // would advance the cursor past unseen matches. Hold position and retry.
-  if (page.capped) return { hasMore: true, items: [] }
-  return { hasMore: page.hasMore, items: page.items }
 }
 
 const filterSchemas = {
@@ -2422,18 +2697,6 @@ export function parseFilters(
   return result.data as Record<string, unknown>
 }
 
-/** Narrows stored `transfer` filters into validated `Transfers.scan` predicates. */
-function transferFilters(filters: Record<string, unknown>) {
-  const parsed = schema.TransferFilters.safeParse(filters)
-  const { address, recipient, sender, token } = parsed.success ? parsed.data : {}
-  return {
-    ...(address === undefined ? {} : { eitherSide: address }),
-    ...(recipient === undefined ? {} : { recipient }),
-    ...(sender === undefined ? {} : { sender }),
-    ...(token === undefined ? {} : { token }),
-  }
-}
-
 /** Recursively lowercases string leaves of a filter operator (for address args). */
 function lowercaseLeaves(op: unknown): unknown {
   if (typeof op === 'string') return op.toLowerCase()
@@ -2573,62 +2836,49 @@ function atOrBefore(block: number, index: number, skip: readonly [number, number
 /** A viem-formatted block header (no transactions), as returned by `getBlock`. */
 type RpcBlock = Awaited<ReturnType<Viem.getClient.ReturnType['getBlock']>>
 
-/** Per-tick lazy cache of fetched block headers, full blocks, and receipts. */
+/** Per-batch single-flight cache for chain RPC reads. */
 type ChainCache = {
   /** Full raw block (with transactions) via `eth_getBlockByNumber(n, true)`. */
   block(n: number): Promise<Record<string, unknown>>
   /** Viem-formatted block header (transaction hashes only) via `getBlock`. */
   header(n: number): Promise<RpcBlock | undefined>
-  /** Receipts for a block keyed by lowercased transaction hash. */
-  receipts(n: number): Promise<Map<string, Record<string, unknown>>>
 }
 
-/** Builds a per-tick {@link ChainCache} bound to a viem client. */
+/** Builds a per-batch {@link ChainCache} bound to a viem client. */
 function createChainCache(client: Viem.getClient.ReturnType): ChainCache {
   const headers = new Map<number, Promise<RpcBlock | undefined>>()
   const blocks = new Map<number, Promise<Record<string, unknown>>>()
-  const receipts = new Map<number, Promise<Map<string, Record<string, unknown>>>>()
+
+  const singleFlight = <key, value>(
+    pending: Map<key, Promise<value>>,
+    key: key,
+    load: () => Promise<value>,
+  ) => {
+    const existing = pending.get(key)
+    if (existing) return existing
+    const promise = load().finally(() => pending.delete(key))
+    pending.set(key, promise)
+    return promise
+  }
+
   return {
     block(n) {
-      let p = blocks.get(n)
-      if (!p) {
+      return singleFlight(blocks, n, () =>
         // The transaction payload reuses `humanizeTransaction`, which consumes
         // the raw RPC tx shape, so the full block stays on the untyped path.
-        p = rpc<Record<string, unknown> | null>(client, 'eth_getBlockByNumber', [
+        rpc<Record<string, unknown> | null>(client, 'eth_getBlockByNumber', [
           blockTag(n),
           true,
         ]).then((block) => {
           if (!block) throw new BlockUnavailableError(n)
           return block
-        })
-        blocks.set(n, p)
-      }
-      return p
+        }),
+      )
     },
     header(n) {
-      let p = headers.get(n)
-      if (!p) {
-        p = client.getBlock({ blockNumber: BigInt(n), includeTransactions: false })
-        headers.set(n, p)
-      }
-      return p
-    },
-    receipts(n) {
-      let p = receipts.get(n)
-      if (!p) {
-        p = rpc<Record<string, unknown>[]>(client, 'eth_getBlockReceipts', [blockTag(n)]).then(
-          (list) => {
-            const map = new Map<string, Record<string, unknown>>()
-            for (const receipt of list ?? []) {
-              const hash = receipt['transactionHash']
-              if (typeof hash === 'string') map.set(hash.toLowerCase(), receipt)
-            }
-            return map
-          },
-        )
-        receipts.set(n, p)
-      }
-      return p
+      return singleFlight(headers, n, () =>
+        client.getBlock({ blockNumber: BigInt(n), includeTransactions: false }),
+      )
     },
   }
 }
@@ -2788,7 +3038,7 @@ function pushTopics(f: z.output<typeof schema.LogFilters>, event: AbiEvent | und
     pushHex(f.topic2),
     pushHex(f.topic3),
   ]
-  while (topics.at(-1) === undefined) topics.pop()
+  while (topics.length > 0 && topics.at(-1) === undefined) topics.pop()
   return topics.map((topic) => topic ?? null)
 }
 
@@ -2824,17 +3074,7 @@ function decodeScanLog(log: ScanLog, event: AbiEvent): ScanLog {
   }
 }
 
-/**
- * Scans contract event logs over the confirmed window via `eth_getLogs`,
- * then re-checks **every** filter in JS. Operators the RPC cannot express
- * (`not`, ranges, non-indexed `args`) still apply. Two modes:
- * - **raw** (no `signature`): `topic0..3` are matched directly.
- * - **decoded** (`signature` present): the selector, raw topics, and supported
- *   indexed `args` are pushed down before the JS pass matches decoded values.
- *
- * Exact and membership address/topic operators are pushed down to the node;
- * all operators are re-checked in JS over the narrow window.
- */
+/** Scans contract logs for one subscription, then re-checks every filter in memory. */
 async function scanLogs(options: {
   batchSize: number
   cache: ChainCache
@@ -2856,8 +3096,6 @@ async function scanLogs(options: {
     ])
 
   const address = pushAddress(f.address)
-  const fromBlock = BigInt(window.from)
-  const toBlock = BigInt(window.to)
   const topics = pushTopics(f, event)
   const hasRawTopics = topics.slice(1).some((topic) => topic !== null)
   const args = event ? pushEventArgs(f.args, event) : {}
@@ -2878,16 +3116,13 @@ async function scanLogs(options: {
         ...(address ? { address } : {}),
         ...(Object.keys(args).length > 0 ? { args: args as never } : {}),
         event,
-        fromBlock,
+        fromBlock: BigInt(window.from),
         strict: false,
-        toBlock,
+        toBlock: BigInt(window.to),
       })) as unknown as ScanLog[]
-
   logs.sort((a, b) => {
-    const ab = Number(a.blockNumber ?? 0n)
-    const bb = Number(b.blockNumber ?? 0n)
-    if (ab !== bb) return ab - bb
-    return (a.logIndex ?? 0) - (b.logIndex ?? 0)
+    const block = Number(a.blockNumber ?? 0n) - Number(b.blockNumber ?? 0n)
+    return block || (a.logIndex ?? 0) - (b.logIndex ?? 0)
   })
 
   const items: ScanItem[] = []
@@ -2897,9 +3132,12 @@ async function scanLogs(options: {
     if (blockNumber === undefined || logIndex === undefined) continue
     if (atOrBefore(blockNumber, logIndex, window.skip)) continue
     if (!matchesLog(log, f, event)) continue
-    const header = await cache.header(blockNumber)
-    const timestamp = blockIso(header)
-    const data = toLogEvent(log, timestamp, f.signature, event)
+    const data = toLogEvent(
+      log,
+      Value.blockToIso(await cache.header(blockNumber)),
+      f.signature,
+      event,
+    )
     if (data) {
       items.push({ cursor: [data.blockNumber, data.logIndex], data })
       if (items.length >= batchSize) return { hasMore: true, items }
@@ -2915,6 +3153,10 @@ function matchesLog(
   event: AbiEvent | undefined,
 ): boolean {
   const topics = log.topics
+  if (event) {
+    const selector = encodeEventTopics({ abi: [event] })[0]
+    if (topics[0]?.toLowerCase() !== selector.toLowerCase()) return false
+  }
   if (f.address !== undefined && !matchesOperator(log.address, f.address)) return false
   if (
     f.blockNumber !== undefined &&
@@ -2949,12 +3191,6 @@ function matchesLog(
 
 // block:created (getBlock)
 
-/** Converts a viem block's `timestamp` (seconds) to an ISO 8601 string. */
-function blockIso(block: RpcBlock | undefined): string | undefined {
-  if (!block || typeof block.timestamp !== 'bigint') return undefined
-  return new Date(Number(block.timestamp) * 1000).toISOString()
-}
-
 type BlockEventData = {
   number: number
   hash: string
@@ -2974,7 +3210,7 @@ function toBlockEvent(block: RpcBlock): BlockEventData | undefined {
   const miner = Schema.Address.safeParse(block.miner)
   const gasUsed = typeof block.gasUsed === 'bigint' ? Number(block.gasUsed) : undefined
   const gasLimit = typeof block.gasLimit === 'bigint' ? Number(block.gasLimit) : undefined
-  const timestamp = blockIso(block)
+  const timestamp = Value.blockToIso(block)
   const transactionCount = Array.isArray(block.transactions) ? block.transactions.length : 0
   if (
     number === undefined ||
@@ -2998,11 +3234,7 @@ function toBlockEvent(block: RpcBlock): BlockEventData | undefined {
   }
 }
 
-/**
- * Scans new blocks over the confirmed window via viem's `getBlock`. One row per
- * block (the keyset index is always 0); filters match block-level metadata. An
- * empty filter is a per-block heartbeat.
- */
+/** Scans new blocks over one subscription's confirmed window. */
 async function scanBlocks(options: {
   batchSize: number
   cache: ChainCache
@@ -3017,9 +3249,9 @@ async function scanBlocks(options: {
   if (!window) return { items: [], scannedThrough: undefined }
 
   const items: ScanItem[] = []
-  for (let n = window.from; n <= window.to; n++) {
-    if (atOrBefore(n, 0, window.skip)) continue
-    const block = await cache.header(n)
+  for (let blockNumber = window.from; blockNumber <= window.to; blockNumber++) {
+    if (atOrBefore(blockNumber, 0, window.skip)) continue
+    const block = await cache.header(blockNumber)
     if (!block) continue
     if (!matchesBlock(block, f)) continue
     const data = toBlockEvent(block)
@@ -3053,7 +3285,7 @@ function matchesBlock(block: RpcBlock, f: z.output<typeof schema.BlockFilters>):
   return true
 }
 
-// transaction:included (eth_getBlockByNumber + eth_getBlockReceipts)
+// transaction:included (eth_getBlockByNumber)
 
 /** Maps a `transaction:included` scalar filter field to its raw-tx field + kind. */
 const txFields = {
@@ -3071,13 +3303,7 @@ const txFields = {
   value: { field: 'value', kind: 'number' },
 } as const satisfies Record<string, { field: string; kind: 'number' | 'string' }>
 
-/**
- * Scans included transactions over the confirmed window. Each block is fetched
- * with full transactions via `eth_getBlockByNumber(n, true)`; receipts are
- * fetched lazily (only when a `status`/`gasUsed`/`feePayer` filter needs them).
- * The delivered payload starts from `Transactions.humanizeTransaction`; the
- * poller then resolves its fee-token references.
- */
+/** Scans included transactions over one subscription's confirmed window. */
 async function scanTxs(options: {
   batchSize: number
   cache: ChainCache
@@ -3092,55 +3318,37 @@ async function scanTxs(options: {
   if (!window) return { items: [], scannedThrough: undefined }
 
   const includeCalls = f.includeCalls ?? true
-  const includeReceipt = f.includeReceipt ?? false
-  // Filter-driven receipt need gates matching; `includeReceipt` only enriches the
-  // payload, so it never drops a row when the receipt is missing.
-  const needsReceipt = f.status !== undefined || f.gasUsed !== undefined || f.feePayer !== undefined
-
   const items: ScanItem[] = []
-  for (let n = window.from; n <= window.to; n++) {
-    const block = await cache.block(n)
-    const txs = Array.isArray(block['transactions']) ? (block['transactions'] as unknown[]) : []
-    if (txs.length === 0) continue
-    const receipts = needsReceipt || includeReceipt ? await cache.receipts(n) : undefined
+  for (let blockNumber = window.from; blockNumber <= window.to; blockNumber++) {
+    const block = await cache.block(blockNumber)
+    const transactions = Array.isArray(block['transactions'])
+      ? (block['transactions'] as unknown[])
+      : []
     const timestamp = asString(block['timestamp'])
-
-    for (let i = 0; i < txs.length; i++) {
-      const tx = txs[i] as Record<string, unknown>
-      const index = Value.hexToNumber(tx['transactionIndex']) ?? i
-      if (atOrBefore(n, index, window.skip)) continue
-      const receipt = receipts?.get(String(tx['hash']).toLowerCase())
-      if (needsReceipt && !receipt) continue
-      if (!matchesTx(tx, f, includeCalls, receipt, timestamp, n)) continue
-      const parsed = Transactions.schema.Rpc.Transaction.safeParse(tx)
+    // A transaction's own `blockTimestamp` is seconds-only, so the delivered
+    // timestamp comes from the enclosing block, which carries milliseconds.
+    const blockTime = Value.blockToIso(block)
+    for (let offset = 0; offset < transactions.length; offset++) {
+      const transaction = transactions[offset] as Record<string, unknown>
+      const transactionIndex = Value.hexToNumber(transaction['transactionIndex']) ?? offset
+      if (atOrBefore(blockNumber, transactionIndex, window.skip)) continue
+      if (!matchesTx(transaction, f, includeCalls, timestamp, blockNumber)) continue
+      const parsed = Transactions.schema.Rpc.Transaction.safeParse(transaction)
       if (!parsed.success) continue
-      let data: Record<string, unknown> = Transactions.humanizeTransaction(parsed.data)
-      // Embed the humanized receipt under `meta.receipt`, matching the read
-      // endpoint's `include=receipt` shape so `data` stays a valid envelope.
-      if (includeReceipt && receipt) {
-        const r = Receipts.schema.Rpc.Receipt.safeParse(receipt)
-        if (r.success)
-          data = {
-            ...data,
-            meta: {
-              ...(data['meta'] as Record<string, unknown>),
-              receipt: Receipts.humanizeReceipt(r.data),
-            },
-          }
-      }
-      items.push({ cursor: [n, index], data })
+      const humanized = Transactions.humanizeTransaction(parsed.data)
+      const data = blockTime === undefined ? humanized : { ...humanized, timestamp: blockTime }
+      items.push({ cursor: [blockNumber, transactionIndex], data })
       if (items.length >= batchSize) return { hasMore: true, items }
     }
   }
   return { items, scannedThrough: window.to }
 }
 
-/** Re-checks all transaction filters in JS against the raw RPC tx (+ receipt). */
+/** Re-checks transaction filters against the raw RPC transaction. */
 function matchesTx(
   tx: Record<string, unknown>,
   f: z.output<typeof schema.TxFilters>,
   includeCalls: boolean,
-  receipt: Record<string, unknown> | undefined,
   timestamp: string | undefined,
   blockNumber: number,
 ): boolean {
@@ -3176,19 +3384,6 @@ function matchesTx(
 
   if (f.timestamp !== undefined && !matchesOperator(timestamp, f.timestamp, 'number')) return false
 
-  if (receipt) {
-    if (f.feePayer !== undefined && !matchesOperator(asString(receipt['feePayer']), f.feePayer))
-      return false
-    if (
-      f.gasUsed !== undefined &&
-      !matchesOperator(asString(receipt['gasUsed']), f.gasUsed, 'number')
-    )
-      return false
-    if (f.status !== undefined) {
-      const ok = Value.hexToNumber(receipt['status']) === 1
-      if ((f.status === 'success') !== ok) return false
-    }
-  }
   return true
 }
 
@@ -3298,6 +3493,202 @@ function unauthorized(c: Context<App.Environment>) {
   })
 }
 
+// Pure per-block scanning (no RPC, no cursors, no pagination).
+
+// Pure over its inputs: the caller fetches the raw block (with transactions)
+// and its logs; enrichment happens downstream. Rows require a parsable block number.
+/**
+ * Matches one fetched block against a subscription set, producing the rows
+ * each event type delivers. Invalid stored filters fail closed into `invalid`.
+ */
+export function scanBlock<const subscription extends scanBlock.Subscription>(
+  options: scanBlock.Options<subscription>,
+): scanBlock.Result<subscription> {
+  const { block, logs, subscriptions } = options
+  const blockNumber = Value.hexToNumber(block['number'])
+  const timestamp = Value.blockToIso(block)
+  const header = toScanHeader(block)
+  const viemLogs = logs.map(fromRpcLog)
+  const matches: scanBlock.Match<subscription>[] = []
+  const invalid: scanBlock.Invalid<subscription>[] = []
+
+  for (const subscription of subscriptions) {
+    const filters = (() => {
+      try {
+        return parseFilters(subscription.eventType, subscription.filters)
+      } catch (error) {
+        invalid.push({ error, subscription })
+        return undefined
+      }
+    })()
+    if (filters === undefined) continue
+    const matched = matches.length
+    const push = (data: unknown, logIndex: number) => {
+      if (blockNumber !== undefined) matches.push({ blockNumber, data, logIndex, subscription })
+    }
+
+    // A throwing matcher invalidates only this subscription, rolling back any
+    // rows it matched before the failure.
+    try {
+      switch (subscription.eventType) {
+        case 'block:created': {
+          const f = filters as z.output<typeof schema.BlockFilters>
+          if (!matchesBlock(header, f)) break
+          const data = toBlockEvent(header)
+          if (data) push(data, 0)
+          break
+        }
+        case 'log:emitted': {
+          const f = filters as z.output<typeof schema.LogFilters>
+          const event = parseEvent(f.signature)
+          if (f.signature && (!event || !/^[A-Za-z_]\w*$/.test(event.name))) {
+            invalid.push({
+              error: new Webhooks.InvalidFilterError('log:emitted', [
+                { message: 'Unsupported event signature.', path: ['signature'] },
+              ]),
+              subscription,
+            })
+            break
+          }
+          // Validate arg names up front so a bad filter fails closed even
+          // when the block has no decodable logs.
+          const unknown =
+            event && f.args
+              ? Object.keys(f.args).find(
+                  (name) => !event.inputs.some((input) => input.name === name),
+                )
+              : undefined
+          if (unknown !== undefined) {
+            invalid.push({
+              error: new Webhooks.InvalidFilterError('log:emitted', [
+                { message: `Unknown event argument: ${unknown}.`, path: ['args', unknown] },
+              ]),
+              subscription,
+            })
+            break
+          }
+          for (const log of viemLogs) {
+            const decoded = event ? decodeScanLog(log, event) : log
+            const logIndex = decoded.logIndex ?? undefined
+            if (logIndex === undefined) continue
+            if (!matchesLog(decoded, f, event)) continue
+            const data = toLogEvent(decoded, timestamp, f.signature, event)
+            if (data) push(data, logIndex)
+          }
+          break
+        }
+        case 'token:transfer': {
+          if (timestamp === undefined) break
+          const f = filters as WebhookTransfer.Filters
+          for (const log of logs) {
+            const data = WebhookTransfer.decode(log, timestamp)
+            if (!data || !WebhookTransfer.matches(data, f)) continue
+            push(data, data.logIndex)
+          }
+          break
+        }
+        case 'transaction:included': {
+          const f = filters as z.output<typeof schema.TxFilters>
+          const includeCalls = f.includeCalls ?? true
+          const transactions = Array.isArray(block['transactions'])
+            ? (block['transactions'] as unknown[])
+            : []
+          const rawTimestamp = asString(block['timestamp'])
+          for (let offset = 0; offset < transactions.length; offset++) {
+            const transaction = transactions[offset]
+            if (!transaction || typeof transaction !== 'object') continue
+            const tx = transaction as Record<string, unknown>
+            const transactionIndex = Value.hexToNumber(tx['transactionIndex']) ?? offset
+            if (!matchesTx(tx, f, includeCalls, rawTimestamp, blockNumber ?? 0)) continue
+            const parsed = Transactions.schema.Rpc.Transaction.safeParse(tx)
+            if (!parsed.success) continue
+            const humanized = Transactions.humanizeTransaction(parsed.data)
+            // A transaction's own timestamp is seconds-only; the enclosing
+            // block carries milliseconds.
+            push(
+              timestamp === undefined ? humanized : { ...humanized, timestamp },
+              transactionIndex,
+            )
+          }
+          break
+        }
+      }
+    } catch (error) {
+      matches.length = matched
+      invalid.push({ error, subscription })
+    }
+  }
+  return { invalid, matches }
+}
+
+/** Normalizes a raw RPC header to the viem-shaped fields the block matchers read. */
+function toScanHeader(block: Record<string, unknown>): RpcBlock {
+  const quantity = (value: unknown) => {
+    try {
+      return typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint'
+        ? BigInt(value)
+        : undefined
+    } catch {
+      return undefined
+    }
+  }
+  return {
+    ...block,
+    gasLimit: quantity(block['gasLimit']),
+    gasUsed: quantity(block['gasUsed']),
+    number: quantity(block['number']),
+    timestamp: quantity(block['timestamp']),
+  } as RpcBlock
+}
+
+export declare namespace scanBlock {
+  /** The subscription fields matching consumes; extra fields flow through. */
+  type Subscription = {
+    /** Event type selecting the matcher and payload shape. */
+    eventType: EventType
+    /** Stored filter predicates, validated fail-closed per event type. */
+    filters: Record<string, unknown>
+  }
+
+  /** One fetched block plus the subscriptions to match it against. */
+  type Options<subscription extends Subscription> = {
+    /** Raw `eth_getBlockByNumber(_, true)` result: header plus raw transactions. */
+    block: Record<string, unknown>
+    /** Raw `eth_getLogs` entries for exactly this block, in log order. */
+    logs: readonly RpcLog[]
+    /** Active subscriptions for the chain; any mix of event types. */
+    subscriptions: readonly subscription[]
+  }
+
+  /** One deliverable row for one subscription. */
+  type Match<subscription extends Subscription> = {
+    /** Block the row was produced from. */
+    blockNumber: number
+    /** Payload the matching read endpoint returns (pre-enrichment). */
+    data: unknown
+    /** Row position within the block (log or transaction index; 0 for blocks). */
+    logIndex: number
+    /** The matched subscription, passed through verbatim. */
+    subscription: subscription
+  }
+
+  /** A subscription whose stored filters failed validation. */
+  type Invalid<subscription extends Subscription> = {
+    /** The validation failure. */
+    error: unknown
+    /** The subscription with invalid filters. */
+    subscription: subscription
+  }
+
+  /** Matches plus fail-closed filter rejections. */
+  type Result<subscription extends Subscription> = {
+    /** Subscriptions skipped because their stored filters failed validation. */
+    invalid: readonly Invalid<subscription>[]
+    /** Deliverable rows in subscription order, block order within each type. */
+    matches: readonly Match<subscription>[]
+  }
+}
+
 class BlockUnavailableError extends Error {
   override name = 'Webhooks.BlockUnavailableError'