tapimo 0.9.0 → 0.10.1

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

@@ -1,8 +1,7 @@
-import { type Db, Webhooks as Core } from 'tapimo'
+import { type Db, Store, Webhooks as Core } from 'tapimo'
 import * as z from 'zod/mini'
 
 import * as Cursor from '../../../internal/Cursor.js'
-import * as Tidx from '../../../internal/Tidx.js'
 import * as Viem from '../../../internal/Viem.js'
 import * as TestApp from '../../../../test/App.js'
 import * as Mppx from '../../../../test/Mppx.js'
@@ -1209,16 +1208,13 @@ describe('OpenAPI visibility', () => {
             "from",
             "to",
             "includeCalls",
-            "includeReceipt",
             "value",
             "input",
             "calls",
             "callCount",
             "txType",
             "feeToken",
-            "feePayer",
             "gasLimit",
-            "gasUsed",
             "maxFeePerGas",
             "maxPriorityFeePerGas",
             "nonce",
@@ -1227,7 +1223,6 @@ describe('OpenAPI visibility', () => {
             "validAfter",
             "blockNumber",
             "timestamp",
-            "status",
           ],
           "title": "Included-transaction subscription",
         },
@@ -1261,6 +1256,10 @@ describe('OpenAPI visibility', () => {
 })
 
 describe('envelope schema', () => {
+  test('transaction events exclude receipt metadata', () => {
+    expect(Object.keys(Webhooks.schema.TransactionEvent.shape.meta.shape)).toEqual(['rpc'])
+  })
+
   /** A `transfer` subscription used to build representative envelopes. */
   async function transferSubscription() {
     const db = TestApp.database()
@@ -1352,10 +1351,9 @@ describe('MPP access (disabled for now — API-key-only)', () => {
   })
 })
 
-// The poll tests pin a FIXED immutable historical window on testnet chain 42431
-// (real TIDX + `rpc.testnet.tempo.xyz`). Under `localnet`, the test RPC client is
-// redirected to the disposable local chain, which lacks that history, so the
-// whole block is testnet-only.
+// The poll tests pin a fixed immutable historical window on testnet chain 42431.
+// Under `localnet`, the test RPC client is redirected to the disposable local
+// chain, which lacks that history, so the whole block is testnet-only.
 describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
   /** Decodes an opaque creation checkpoint or `(block, index)` poller cursor. */
   function decodeCursor(token: string | null): number[] | null {
@@ -1372,17 +1370,8 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
   /** End-of-block index sentinel (matches the poller's own cursor sentinel). */
   const endOfBlockIndex = 2_147_483_647
 
-  // The poller scans real TIDX, so the tests pin a FIXED historical block window
-  // on chain 42431. Chain history is immutable, so a narrow `sender` filter over
-  // this window yields a deterministic, snapshot-stable row set while exercising
-  // the real keyset/`toBlock` SQL and decode path end to end — no fabricated rows.
-  const realTidx = Tidx.getClient({
-    chainId: 42431,
-    tidx: { auth: process.env.TIDX_AUTH, baseUrl: 'https://tidx.tempo.xyz' },
-  })
-  // The monitoring scanners (`log:emitted`/`block:created`/`transaction:included`)
-  // read the same immutable historical window over real RPC (chain 42431 →
-  // `rpc.testnet.tempo.xyz`), so their results are snapshot-stable too.
+  // Every scanner reads this immutable window over real RPC (chain 42431 to
+  // `rpc.testnet.tempo.xyz`), so the results remain snapshot-stable.
   const client = Viem.getClient({ chainId: 42431, rpc: TestApp.rpc })
   // Confirmed scan window `[windowFrom, windowTo]`: anchor the cursor just below
   // `windowFrom`, and pass `headBlockNumber = windowTo + confirmations` so the
@@ -1390,10 +1379,11 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
   const windowFrom = 1_000_000
   const windowTo = 1_000_002
   const windowCursor = encodeCursor([windowFrom - 1, endOfBlockIndex])
-  const windowHead = windowTo + 2
+  const windowHead = windowTo + 1
   // A sender whose only transfers in `[windowFrom, windowTo]` are exactly two
   // rows, both in block 1,000,002 (`log_idx` 0 then 1): a TIP-20 transfer
   // followed by its fee payment. Filtering on it makes the scan deterministic.
+  const windowRecipient = '0x9e39034aae71fb89f66061a2602eb6efec271754'
   const windowSender = '0xe7687128b0a808c2831ff94d4f7b2fb35c65af38'
   // This token has 226 transfers across blocks 1,000,000 through 1,000,003.
   const volumeHead = 1_000_005
@@ -1428,17 +1418,28 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     await Core.setCursor(db, subscription.id, windowCursor)
 
     const dispatched: Webhooks.poll.Dispatchable[] = []
+    const scanCheckpoints: Webhooks.poll.ScanCheckpoint[] = []
+    const stages: Webhooks.poll.Stage[] = []
+    let cursorLagBlocks: number | undefined
     const result = await Webhooks.poll({
       chainId: 42431,
       dispatch: async (input) => {
         dispatched.push(input)
         return { ok: true }
       },
-      eventTypes: ['token:transfer'],
+      eventTypes: ['token:transfer', 'token:transfer'],
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
+      onCursorLag(blocks) {
+        cursorLagBlocks = blocks
+      },
+      onScanCheckpoint(checkpoint) {
+        scanCheckpoints.push(checkpoint)
+      },
+      onStage(stage) {
+        stages.push(stage)
+      },
     })
 
     expect(result).toMatchInlineSnapshot(`
@@ -1451,9 +1452,68 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         "subscriptions": 1,
       }
     `)
+    expect(cursorLagBlocks).toBe(3)
+    expect(scanCheckpoints.map(({ durationMs: _, ...checkpoint }) => checkpoint))
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "concurrency": 8,
+          "eventType": "token:transfer",
+          "maxWindowBlocks": 3,
+          "phase": "start",
+          "rpcMethod": "eth_getLogs",
+          "subscriptionCount": 1,
+          "subscriptionLimit": 256,
+          "totalWindowBlocks": 3,
+        },
+        {
+          "concurrency": 8,
+          "eventType": "token:transfer",
+          "failedSubscriptions": 0,
+          "matchedItems": 2,
+          "maxWindowBlocks": 3,
+          "outcome": "ok",
+          "phase": "complete",
+          "rpcMethod": "eth_getLogs",
+          "subscriptionCount": 1,
+          "subscriptionLimit": 256,
+          "totalWindowBlocks": 3,
+        },
+      ]
+    `)
+    expect(stages.map(({ eventType, outcome, stage }) => ({ eventType, outcome, stage })))
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "eventType": undefined,
+          "outcome": "ok",
+          "stage": "rpc_head",
+        },
+        {
+          "eventType": undefined,
+          "outcome": "ok",
+          "stage": "subscription_read",
+        },
+        {
+          "eventType": "token:transfer",
+          "outcome": "ok",
+          "stage": "scan",
+        },
+        {
+          "eventType": "token:transfer",
+          "outcome": "ok",
+          "stage": "enrich",
+        },
+        {
+          "eventType": "token:transfer",
+          "outcome": "ok",
+          "stage": "cursor_write",
+        },
+      ]
+    `)
     expect(dispatched).toHaveLength(2)
-    // The envelope carries the read-endpoint transfer row verbatim — here the
-    // first of the two pinned-window transfers from `windowSender`.
+    // The envelope carries the decoded RPC transfer row, here the first of the
+    // two pinned-window transfers from `windowSender`.
     expect(dispatched[0]?.envelope.data).toMatchInlineSnapshot(`
       {
         "address": "0x20c00000000000000000000071de0cd31ab0d105",
@@ -1462,7 +1522,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         "logIndex": 0,
         "recipient": "0x9e39034aae71fb89f66061a2602eb6efec271754",
         "sender": "0xe7687128b0a808c2831ff94d4f7b2fb35c65af38",
-        "timestamp": "2026-01-14T18:38:03.000Z",
+        "timestamp": "2026-01-14T18:38:03.685Z",
         "token": {
           "decimals": 6,
           "symbol": "QKSUSD",
@@ -1480,6 +1540,221 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     `)
   })
 
+  test('delivers collision-shaped token metadata from a cache hit', async () => {
+    const db = TestApp.database()
+    const subscription = await createTransferSubscription(db)
+    await Core.setCursor(db, subscription.id, windowCursor)
+    const cache = Store.memory()
+    const address = '0x20c00000000000000000000071de0cd31ab0d105'
+    await Store.memoize(
+      async () => ({
+        currency: 'USD',
+        decimals: 6,
+        name: 'Collision token',
+        symbol: '123#__bigint',
+      }),
+      {
+        key: `webhook:token-meta:v2:42431:${address}`,
+        store: cache,
+        ttl: 60_000,
+      },
+    )
+    const bodies: string[] = []
+    const fetch = (async (_input, init) => {
+      bodies.push(typeof init?.body === 'string' ? init.body : '')
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await Webhooks.poll({
+      cache,
+      chainId: 42431,
+      client,
+      db,
+      dispatch: ({ envelope, subscription }) =>
+        Core.deliverAndRecord(db, subscription, envelope, { fetch }),
+      eventTypes: ['token:transfer'],
+      headBlockNumber: windowHead,
+    })
+
+    const payloads = bodies.map((body) => Webhooks.schema.Envelope.parse(JSON.parse(body)))
+    const delivered = payloads.find(
+      (payload) => payload.type === 'token:transfer' && payload.data.address === address,
+    )
+    expect(result.dispatched).toBe(2)
+    expect(delivered?.type === 'token:transfer' ? delivered.data.token?.symbol : undefined).toBe(
+      '123#__bigint',
+    )
+  })
+
+  test('scans event types concurrently without increasing scan bounds', async () => {
+    const db = TestApp.database()
+    const transfer = await createTransferSubscription(db)
+    const block = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/block' },
+      eventType: 'block:created',
+      filters: {},
+      owner: { orgId: 'org_block', type: 'api_key' },
+    })
+    await Promise.all([
+      Core.setCursor(db, transfer.id, windowCursor),
+      Core.setCursor(db, block.id, windowCursor),
+    ])
+
+    const active = new Map<
+      Webhooks.EventType,
+      Pick<Webhooks.poll.ScanCheckpoint, 'concurrency' | 'subscriptionLimit'>
+    >()
+    let maxConcurrency = 0
+    let maxEventTypes = 0
+    let maxSubscriptionLimit = 0
+    await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatch: async () => ({ ok: true }),
+      eventTypes: ['token:transfer', 'block:created'],
+      headBlockNumber: windowHead,
+      onScanCheckpoint(checkpoint) {
+        expect(checkpoint.subscriptionCount).toBeLessThanOrEqual(checkpoint.subscriptionLimit)
+        if (checkpoint.phase === 'start')
+          active.set(checkpoint.eventType, {
+            concurrency: checkpoint.concurrency,
+            subscriptionLimit: checkpoint.subscriptionLimit,
+          })
+        else active.delete(checkpoint.eventType)
+        maxConcurrency = Math.max(
+          maxConcurrency,
+          ...[...active.values()].map((value) => value.concurrency),
+        )
+        maxEventTypes = Math.max(maxEventTypes, active.size)
+        maxSubscriptionLimit = Math.max(
+          maxSubscriptionLimit,
+          [...active.values()].reduce((total, value) => total + value.subscriptionLimit, 0),
+        )
+      },
+    })
+
+    expect(active.size).toBe(0)
+    expect(maxConcurrency).toBe(8)
+    expect(maxEventTypes).toBe(2)
+    expect(maxSubscriptionLimit).toBe(256)
+  })
+
+  test('dispatches a page as one batch and advances the cursor', async () => {
+    const db = TestApp.database()
+    const subscription = await createTransferSubscription(db)
+    await Core.setCursor(db, subscription.id, windowCursor)
+
+    const batches: Webhooks.poll.Dispatchable[][] = []
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatchBatch: async (dispatchables, context) => {
+        expect(context.db).toBe(db)
+        batches.push([...dispatchables])
+        return { ok: true }
+      },
+      eventTypes: ['token:transfer'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.dispatched).toBe(2)
+    expect(batches.map((batch) => batch.length)).toEqual([2])
+    expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([windowTo, 1])
+  })
+
+  test('keeps the cursor unchanged when a batch dispatch fails', async () => {
+    const db = TestApp.database()
+    const subscription = await createTransferSubscription(db)
+    await Core.setCursor(db, subscription.id, windowCursor)
+
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatchBatch: async () => ({ error: 'unreachable', ok: false }),
+      eventTypes: ['token:transfer'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.dispatched).toBe(0)
+    expect(result.failed).toBe(2)
+    expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([
+      windowFrom - 1,
+      endOfBlockIndex,
+    ])
+  })
+
+  test('matches the either-side address filter through Viem log filters', async () => {
+    const db = TestApp.database()
+    const subscription = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/address' },
+      eventType: 'token:transfer',
+      filters: { address: windowSender },
+      owner: { orgId: 'org_address', type: 'api_key' },
+    })
+    await Core.setCursor(db, subscription.id, windowCursor)
+
+    const positions: string[] = []
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatch: async ({ envelope }) => {
+        const data = envelope.data as { blockNumber: number; logIndex: number }
+        positions.push(`${data.blockNumber}:${data.logIndex}`)
+        return { ok: true }
+      },
+      eventTypes: ['token:transfer'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.dispatched).toBe(2)
+    expect(positions).toEqual(['1000002:0', '1000002:1'])
+  })
+
+  test('keeps distinct transfer pushdowns isolated', async () => {
+    const db = TestApp.database()
+    const recipient = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/recipient' },
+      eventType: 'token:transfer',
+      filters: { recipient: windowRecipient },
+      owner: { orgId: 'org_recipient', type: 'api_key' },
+    })
+    const sender = await createTransferSubscription(db)
+    await Promise.all([
+      Core.setCursor(db, recipient.id, windowCursor),
+      Core.setCursor(db, sender.id, windowCursor),
+    ])
+
+    const dispatched: Webhooks.poll.Dispatchable[] = []
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatch: async (input) => {
+        dispatched.push(input)
+        return { ok: true }
+      },
+      eventTypes: ['token:transfer'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.dispatched).toBe(3)
+    expect(
+      Object.fromEntries(
+        [...Map.groupBy(dispatched, ({ subscription }) => subscription.id)].map(([id, items]) => [
+          id,
+          items.length,
+        ]),
+      ),
+    ).toEqual({ [recipient.id]: 1, [sender.id]: 2 })
+  })
+
   test('pauses the cursor at the last success when dispatch fails', async () => {
     const db = TestApp.database()
     const subscription = await createTransferSubscription(db)
@@ -1494,7 +1769,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.dispatched).toMatchInlineSnapshot(`1`)
@@ -1522,7 +1796,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.dispatched).toMatchInlineSnapshot(`0`)
@@ -1537,6 +1810,31 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     `)
   })
 
+  test('stops dispatching when the poll signal is aborted', async () => {
+    const db = TestApp.database()
+    const subscription = await createTransferSubscription(db)
+    await Core.setCursor(db, subscription.id, windowCursor)
+
+    const abort = new AbortController()
+    let calls = 0
+    await expect(
+      Webhooks.poll({
+        chainId: 42431,
+        client,
+        db,
+        dispatch: async () => {
+          calls++
+          abort.abort(new Error('lease lost'))
+          return { ok: true }
+        },
+        eventTypes: ['token:transfer'],
+        headBlockNumber: windowHead,
+        signal: abort.signal,
+      }),
+    ).rejects.toThrow('lease lost')
+    expect(calls).toBe(1)
+  })
+
   test('drains two bounded transfer pages per tick without gaps', async () => {
     const db = TestApp.database()
     const subscription = await createVolumeSubscription(db)
@@ -1547,6 +1845,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       Webhooks.poll({
         chainId: 42431,
         client,
+        confirmations: 2,
         db,
         dispatch: async ({ envelope }) => {
           const data = envelope.data as { blockNumber: number; logIndex: number }
@@ -1555,7 +1854,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         },
         eventTypes: ['token:transfer'],
         headBlockNumber: volumeHead,
-        tidx: realTidx,
       })
 
     expect((await tick()).dispatched).toBe(200)
@@ -1577,11 +1875,11 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     const first = await Webhooks.poll({
       chainId: 42431,
       client,
+      confirmations: 2,
       db,
       dispatch: async () => (++calls === 101 ? { error: 'unreachable', ok: false } : { ok: true }),
       eventTypes: ['token:transfer'],
       headBlockNumber: volumeHead,
-      tidx: realTidx,
     })
 
     expect(first.dispatched).toBe(100)
@@ -1593,6 +1891,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       batchSize: 1,
       chainId: 42431,
       client,
+      confirmations: 2,
       db,
       dispatch: async ({ envelope }) => {
         const data = envelope.data as { blockNumber: number; logIndex: number }
@@ -1601,7 +1900,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       },
       eventTypes: ['token:transfer'],
       headBlockNumber: volumeHead,
-      tidx: realTidx,
     })
     expect(resumed).toEqual([1_000_002, 10])
   })
@@ -1618,6 +1916,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     await Webhooks.poll({
       chainId: 42431,
       client,
+      confirmations: 2,
       db,
       dispatch: async ({ subscription }) => {
         order.push(subscription.id)
@@ -1625,7 +1924,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       },
       eventTypes: ['token:transfer'],
       headBlockNumber: volumeHead,
-      tidx: realTidx,
     })
 
     expect(order).toHaveLength(400)
@@ -1651,7 +1949,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       client,
       db,
       // Rows exist in history, but a brand-new subscription must not replay them.
-      tidx: realTidx,
     })
 
     // Nothing scanned or dispatched on the first tick; the cursor is anchored at
@@ -1689,7 +1986,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: creationHead + 3,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.dispatched).toBe(2)
@@ -1729,15 +2025,14 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(decodeCursor(await Core.getCursor(db, transfer.id))).toEqual([
-      startBlockNumber - 2,
+      startBlockNumber - 1,
       endOfBlockIndex,
     ])
     expect(decodeCursor(await Core.getCursor(db, block.id))).toEqual([
-      startBlockNumber - 2,
+      startBlockNumber - 1,
       endOfBlockIndex,
     ])
   })
@@ -1754,10 +2049,9 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       chainId: 42431,
       dispatch: async () => ({ ok: true }),
       eventTypes: ['token:transfer'],
-      headBlockNumber: windowTo + 4,
+      headBlockNumber: windowTo + 3,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`0`)
@@ -1779,6 +2073,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
   const transferSignature =
     'event Transfer(address indexed from, address indexed to, uint256 value)'
   const transferSelector = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+  const windowToken = '0x20c00000000000000000000071de0cd31ab0d105'
   const windowSenderTopic = `0x${'0'.repeat(24)}${windowSender.slice(2)}`
 
   test('log:emitted decodes args from a signature-matched event view', async () => {
@@ -1803,7 +2098,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`2`)
@@ -1823,7 +2117,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
           "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
         },
         "logIndex": 0,
-        "timestamp": "2026-01-14T18:38:03.000Z",
+        "timestamp": "2026-01-14T18:38:03.685Z",
         "topics": [
           "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
           "0x000000000000000000000000e7687128b0a808c2831ff94d4f7b2fb35c65af38",
@@ -1857,7 +2151,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`2`)
@@ -1867,7 +2160,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         "blockNumber": 1000002,
         "data": "0x0000000000000000000000000000000000000000000000000000000000002710",
         "logIndex": 0,
-        "timestamp": "2026-01-14T18:38:03.000Z",
+        "timestamp": "2026-01-14T18:38:03.685Z",
         "topics": [
           "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
           "0x000000000000000000000000e7687128b0a808c2831ff94d4f7b2fb35c65af38",
@@ -1879,6 +2172,87 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     `)
   })
 
+  test('log:emitted scans an address-only filter', async () => {
+    const db = TestApp.database()
+    const subscription = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/address-only' },
+      eventType: 'log:emitted',
+      filters: { address: '0xffffffffffffffffffffffffffffffffffffffff' },
+      owner: { orgId: 'org_address_only', type: 'api_key' },
+    })
+    await Core.setCursor(db, subscription.id, windowCursor)
+
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      eventTypes: ['log:emitted'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.scanned).toBe(0)
+    expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([
+      windowTo,
+      endOfBlockIndex,
+    ])
+  })
+
+  test('log:emitted keeps distinct address and topic pushdowns isolated', async () => {
+    const db = TestApp.database()
+    const address = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/address' },
+      eventType: 'log:emitted',
+      filters: {
+        address: windowToken,
+        args: { from: windowSender },
+        signature: transferSignature,
+      },
+      owner: { orgId: 'org_address', type: 'api_key' },
+    })
+    const topic = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/topic' },
+      eventType: 'log:emitted',
+      filters: { topic0: transferSelector, topic1: windowSenderTopic },
+      owner: { orgId: 'org_topic', type: 'api_key' },
+    })
+    await Promise.all([
+      Core.setCursor(db, address.id, windowCursor),
+      Core.setCursor(db, topic.id, windowCursor),
+    ])
+
+    const dispatched: Webhooks.poll.Dispatchable[] = []
+    const result = await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      dispatch: async (input) => {
+        dispatched.push(input)
+        return { ok: true }
+      },
+      eventTypes: ['log:emitted'],
+      headBlockNumber: windowHead,
+    })
+
+    expect(result.dispatched).toBe(3)
+    expect(
+      Object.fromEntries(
+        [...Map.groupBy(dispatched, ({ subscription }) => subscription.id)].map(([id, items]) => [
+          id,
+          items.length,
+        ]),
+      ),
+    ).toEqual({ [address.id]: 1, [topic.id]: 2 })
+    expect(
+      await Promise.all([Core.getCursor(db, address.id), Core.getCursor(db, topic.id)]),
+    ).toEqual([
+      encodeCursor([windowTo, endOfBlockIndex]),
+      encodeCursor([windowTo, endOfBlockIndex]),
+    ])
+  })
+
   test('log:emitted limits a tick and resumes within the block', async () => {
     const db = TestApp.database()
     const subscription = await Core.createSubscription(db, {
@@ -1903,13 +2277,23 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         },
         eventTypes: ['log:emitted'],
         headBlockNumber: windowHead,
-        tidx: realTidx,
       })
 
-    expect((await tick()).dispatched).toBe(1)
+    const first = await tick()
+    expect(first.dispatched).toBe(1)
+    expect(first.hasMore).toBe(true)
     expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([windowTo, 0])
-    expect((await tick()).dispatched).toBe(1)
+    const second = await tick()
+    expect(second.dispatched).toBe(1)
+    expect(second.hasMore).toBe(true)
     expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([windowTo, 1])
+    const third = await tick()
+    expect(third.dispatched).toBe(0)
+    expect(third.hasMore).toBeUndefined()
+    expect(decodeCursor(await Core.getCursor(db, subscription.id))).toEqual([
+      windowTo,
+      endOfBlockIndex,
+    ])
     expect(
       dispatched.map(({ envelope }) => (envelope.data as { logIndex: number }).logIndex),
     ).toEqual([0, 1])
@@ -1942,7 +2326,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowTo + 3,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`1`)
@@ -1954,7 +2337,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         "miner": "0x0000000000000000000000000000000000000000",
         "number": 1000002,
         "parentHash": "0xa406dff9c51cc2abbef3a811f0499e99a568bf781019f129ab45dca1df0e43e5",
-        "timestamp": "2026-01-14T18:38:03.000Z",
+        "timestamp": "2026-01-14T18:38:03.685Z",
         "transactionCount": 52,
       }
     `)
@@ -1992,7 +2375,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         },
         eventTypes: ['block:created'],
         headBlockNumber: windowHead,
-        tidx: realTidx,
       })
 
     expect((await tick()).dispatched).toBe(1)
@@ -2035,6 +2417,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     await Core.setCursor(db, healthy.id, windowCursor)
 
     const dispatched: Webhooks.poll.Dispatchable[] = []
+    const subscriptions: number[] = []
 
     await expect(
       Webhooks.poll({
@@ -2048,11 +2431,14 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         client,
         db,
         maxBlocks: 3,
-        tidx: realTidx,
+        onSubscriptions(count) {
+          subscriptions.push(count)
+        },
       }),
     ).rejects.toThrow()
 
     expect(await Core.getCursor(db, unavailable.id)).toBe(cursor)
+    expect(subscriptions).toEqual([2])
     expect(decodeCursor(await Core.getCursor(db, healthy.id))).toMatchInlineSnapshot(`
       [
         1000002,
@@ -2090,7 +2476,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowTo + 3,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`1`)
@@ -2112,6 +2497,28 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     ])
   })
 
+  test('disables stored subscriptions with removed receipt filters', async () => {
+    const db = TestApp.database()
+    const subscription = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/legacy' },
+      eventType: 'transaction:included',
+      filters: { includeReceipt: true },
+      owner: { orgId: 'org_legacy', type: 'api_key' },
+    })
+
+    await Webhooks.poll({
+      chainId: 42431,
+      client,
+      db,
+      eventTypes: ['transaction:included'],
+      headBlockNumber: windowHead,
+    })
+
+    const disabled = await Core.getSubscription(db, subscription.owner, subscription.id)
+    expect(disabled?.status).toBe('disabled')
+  })
+
   test('transaction:included limits a tick and resumes within the block', async () => {
     const db = TestApp.database()
     const subscription = await Core.createSubscription(db, {
@@ -2136,7 +2543,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         },
         eventTypes: ['transaction:included'],
         headBlockNumber: windowHead,
-        tidx: realTidx,
       })
 
     expect((await tick()).dispatched).toBe(1)
@@ -2168,7 +2574,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         headBlockNumber: missingBlock + 2,
         client,
         db,
-        tidx: realTidx,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(`
       [Webhooks.BlockUnavailableError: Block 4000000000 is unavailable.]
@@ -2199,7 +2604,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       headBlockNumber: windowHead,
       client,
       db,
-      tidx: realTidx,
     })
 
     expect(result.scanned).toMatchInlineSnapshot(`1`)
@@ -2209,78 +2613,10 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     })
   })
 
-  test('transaction:included routes a status filter through receipts', async () => {
-    const db = TestApp.database()
-    const subscription = await Core.createSubscription(db, {
-      chainId: 42431,
-      eventType: 'transaction:included',
-      filters: { from: windowSender, status: 'success' },
-      owner: { orgId: 'org_test', type: 'api_key' },
-      destination: { type: 'url', url: 'https://hooks.example.com/x' },
-    })
-    await Core.setCursor(db, subscription.id, windowCursor)
-
-    const result = await Webhooks.poll({
-      chainId: 42431,
-      dispatch: async () => ({ ok: true }),
-      eventTypes: ['transaction:included'],
-      headBlockNumber: windowHead,
-      client,
-      db,
-      tidx: realTidx,
-    })
-
-    // The window tx succeeded, so the status=success subquery keeps it.
-    expect(result.scanned).toMatchInlineSnapshot(`1`)
-  })
-
-  test('transaction:included embeds the receipt when includeReceipt is set', async () => {
-    const db = TestApp.database()
-    const subscription = await Core.createSubscription(db, {
-      chainId: 42431,
-      eventType: 'transaction:included',
-      // No receipt-touching filter — `includeReceipt` alone must trigger the
-      // fetch and embed it in the delivered payload.
-      filters: { from: windowSender, input: { selector: '0xa9059cbb' }, includeReceipt: true },
-      owner: { orgId: 'org_test', type: 'api_key' },
-      destination: { type: 'url', url: 'https://hooks.example.com/x' },
-    })
-    await Core.setCursor(db, subscription.id, windowCursor)
-
-    const dispatched: Webhooks.poll.Dispatchable[] = []
-    const result = await Webhooks.poll({
-      chainId: 42431,
-      dispatch: async (input) => {
-        dispatched.push(input)
-        return { ok: true }
-      },
-      eventTypes: ['transaction:included'],
-      headBlockNumber: windowHead,
-      client,
-      db,
-      tidx: realTidx,
-    })
-
-    expect(result.scanned).toMatchInlineSnapshot(`1`)
-    const data = dispatched[0]?.envelope.data as TransactionEvent | undefined
-    // The receipt is embedded under `meta.receipt`, matching the read endpoint's
-    // `include=receipt` shape, and refers to the same transaction.
-    expect(data?.meta?.receipt?.status).toMatchInlineSnapshot(`"success"`)
-    expect(data?.meta?.receipt?.transactionHash).toBe(data?.hash)
-    const receipt = data?.meta.receipt
-    if (receipt?.meta.rpc.feeToken) {
-      expect(receipt.feeToken?.address).toBe(receipt.meta.rpc.feeToken)
-      expect(typeof receipt.feeToken?.currency).toBe('string')
-      expect(typeof receipt.feeToken?.decimals).toBe('number')
-      expect(typeof receipt.feeToken?.name).toBe('string')
-      expect(typeof receipt.feeToken?.symbol).toBe('string')
-    } else expect(receipt?.feeToken).toBeUndefined()
-  })
-
   // End-to-end through the *default* transport: `poll` with no injected
   // `dispatch` falls back to `deliverAndRecord`, which signs and POSTs via
-  // `globalThis.fetch` and records the outcome. These stub the global fetch so a
-  // seeded TIDX row reaches a captured local sink with no network.
+  // `globalThis.fetch` and records the outcome. These intercept the delivery
+  // request while real RPC reads pass through.
   describe('default transport (deliverAndRecord)', () => {
     afterEach(() => {
       vi.restoreAllMocks()
@@ -2291,9 +2627,8 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       const subscription = await createTransferSubscription(db)
       await Core.setCursor(db, subscription.id, windowCursor)
 
-      // Real TIDX queries also go through `globalThis.fetch`, so the mock passes
-      // non-webhook requests through to the real network and only captures the
-      // delivery POST to the subscription URL.
+      // RPC queries also go through `globalThis.fetch`, so the interceptor passes
+      // non-webhook requests through and captures only the delivery POST.
       const realFetch = globalThis.fetch.bind(globalThis)
       const calls: { body: string; headers: Headers; url: string }[] = []
       vi.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
@@ -2317,7 +2652,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         headBlockNumber: windowHead,
         client,
         db,
-        tidx: realTidx,
       })
 
       expect(result.dispatched).toBe(1)
@@ -2369,7 +2703,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
           headBlockNumber: windowHead,
           client,
           db,
-          tidx: realTidx,
         })
 
       const first = await tick()
@@ -2393,7 +2726,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
       const subscription = await createTransferSubscription(db)
       await Core.setCursor(db, subscription.id, windowCursor)
 
-      // Real TIDX queries pass through; only the webhook delivery fails (500).
+      // Real RPC queries pass through; only the webhook delivery fails (500).
       const realFetch = globalThis.fetch.bind(globalThis)
       vi.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
         const url =
@@ -2410,7 +2743,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
           headBlockNumber: windowHead,
           client,
           db,
-          tidx: realTidx,
         })
 
       // Each tick delivers once and fails; after `maxFailures` ticks the
@@ -2428,7 +2760,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
   })
 
   // Full loop through the public HTTP surface: create over the route, let the
-  // poller detect a seeded TIDX row and deliver via the default transport, then
+  // poller detect an RPC transfer log and deliver via the default transport, then
   // read the recorded outcome back through the deliveries route. Unlike the
   // `poll` tests above (which seed subscriptions via the core helper), this
   // proves the route-issued secret and id line up with what is delivered/logged.
@@ -2467,7 +2799,7 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         return new Response(null, { status: 200 })
       }) satisfies typeof globalThis.fetch
 
-      // 3. Poll a real TIDX transfer row; dispatch through the real
+      // 3. Poll a real RPC transfer log; dispatch through the real
       // sign+deliver+record core with the injected transport. `batchSize: 1`
       // delivers exactly one envelope from the window.
       const result = await Webhooks.poll({
@@ -2479,7 +2811,6 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
         headBlockNumber: windowHead,
         client,
         db,
-        tidx: realTidx,
       })
       expect(result.dispatched).toBe(1)