tapimo 0.10.2 → 0.12.0

package/src/Client.test-d.ts

@@ -173,7 +173,7 @@ describe('narrows responses by status', () => {
         'apy.window': '24h',
         capability: 'deposit',
         'engine.type': 'erc4626',
-        include: 'access,apy,capabilities,token.logoUri,tvl,zone',
+        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
       },
     })
 
@@ -205,6 +205,8 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.vaultAddress).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.data[0]!.verified).toEqualTypeOf<boolean>()
       expectTypeOf(json.data[0]!.zone?.chainId).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.deploymentBlock).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.earnRouter).toEqualTypeOf<`0x${string}` | undefined>()
       expectTypeOf(json.meta?.valuation?.basis).toEqualTypeOf<'nominal' | undefined>()
       void json
       return
@@ -226,7 +228,10 @@ describe('narrows responses by status', () => {
   test('GET /v1/earn/vaults/verified', async () => {
     const client = Client.create()
     const res = await client.v1.earn.vaults.verified.$get({
-      query: { 'apy.window': '7d', include: 'access,apy,capabilities,token.logoUri,tvl,zone' },
+      query: {
+        'apy.window': '7d',
+        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
+      },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -243,6 +248,7 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.tvl).toEqualTypeOf<VaultValue | null | undefined>()
       expectTypeOf(json.data[0]!.tvl?.formatted).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.data[0]!.verified).toEqualTypeOf<true>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.chainId).toEqualTypeOf<number | undefined>()
       expectTypeOf(json.meta?.valuation?.source).toEqualTypeOf<string | undefined>()
       void json
       return
@@ -968,6 +974,46 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete({
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
+        void json
+        return
+      }
     }
   })
 
@@ -1035,10 +1081,21 @@ describe('narrows responses by status', () => {
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
 
-    if (res.status === 200) {
-      const json = await res.json()
-      expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
-      void json
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
     }
   })
 
@@ -1053,6 +1110,14 @@ describe('narrows responses by status', () => {
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
       case 404: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<
@@ -1117,6 +1182,12 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
     }
   })
 
@@ -1129,6 +1200,20 @@ describe('narrows responses by status', () => {
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
+        void json
+        return
+      }
       case 409: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
@@ -1138,6 +1223,87 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('DELETE /v1/orgs/:orgId/members/:userId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members[
+      ':userId{usr_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { orgId: 'org_test', userId: 'usr_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.userId).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/orgs/:orgId/invitations', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations.$post({
+      json: { email: 'dev@example.com', role: 'member' },
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.email).toEqualTypeOf<string>()
+        expectTypeOf(json.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/invitations/:invitationId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations[
+      ':invitationId{inv_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { invitationId: 'inv_test', orgId: 'org_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
+
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        'invitation_not_found' | 'organization_not_found'
+      >()
+      void json
+    }
+  })
+
   test('POST /v1/orgs/:orgId/invite-links', async () => {
     const client = Client.create()
     const orgLinks = client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links']
@@ -1157,13 +1323,57 @@ describe('narrows responses by status', () => {
     >()
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
 
-    if (res.status === 200) {
-      const json = await res.json()
-      expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<readonly string[] | null>()
-      expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<
-        z.output<typeof InviteLinks.schema.InviteLink>['allowedEmailDomains']
-      >()
-      void json
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<readonly string[] | null>()
+        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<
+          z.output<typeof InviteLinks.schema.InviteLink>['allowedEmailDomains']
+        >()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('PATCH /v1/orgs/:orgId/invite-links/:inviteLinkId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links'][
+      ':inviteLinkId{iln_[A-Za-z0-9_-]+}'
+    ].$patch({
+      json: { enabled: false },
+      param: { inviteLinkId: 'iln_test', orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'invite_link_not_found' | 'organization_not_found'
+        >()
+        void json
+        return
+      }
     }
   })
 
@@ -1500,14 +1710,18 @@ describe('narrows responses by status', () => {
       param: {
         transactionHash: '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474',
       },
-      query: { include: 'token.logoUri,token.verified' },
+      query: {
+        chainId: '4217',
+        include: 'zones,token.logoUri,token.verified',
+      },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PaidAccessStatus>()
 
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        expectTypeOf(json.chainId).toEqualTypeOf<number>()
         expectTypeOf(json.data[0]!.type).toEqualTypeOf<
           z.output<
             typeof Activities.schema.getTransactionActivities.Response
@@ -1550,6 +1764,13 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'transaction_ambiguous'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
       case 502: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
@@ -2604,6 +2825,30 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('QUERY /v1/exchange/quotes', async () => {
+    const client = Client.create()
+    const res = await client.v1.exchange.quotes.$query({
+      json: {
+        account: '0x1111111111111111111111111111111111111111',
+        amount: '1000000',
+        destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
+        mode: 'exactSource',
+        slippageBps: 50,
+        sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
+      },
+      query: { include: 'token.logoUri,token.verified' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
+      expectTypeOf(json.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
+      expectTypeOf(json.destinationToken.logoUri).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
+    }
+  })
+
   test('POST /v1/exchange/quotes/execute', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.quotes.execute.$post({
@@ -3292,7 +3537,10 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.addresses[':address'].activities.$get({
       param: { address: '0x0000000000000000000000000000000000000000' },
-      query: { include: 'token.logoUri,token.verified' },
+      query: {
+        chainId: '4217',
+        include: 'zones,token.logoUri,token.verified',
+      },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -3300,6 +3548,7 @@ describe('narrows responses by status', () => {
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        expectTypeOf(json.data[0]!.chainId).toEqualTypeOf<number | undefined>()
         expectTypeOf(json.data[0]!.type).toEqualTypeOf<
           z.output<typeof Activities.schema.getAddressActivities.Response>['data'][number]['type']
         >()
@@ -3351,6 +3600,17 @@ describe('narrows responses by status', () => {
 
   test('POST /v1/webhooks', async () => {
     const client = Client.create()
+    void client.v1.webhooks.$post({
+      json: {
+        destination: { type: 'url', url: 'https://example.com/webhook' },
+        eventType: 'funding:deposit.updated',
+        filters: {
+          depositAddressId: 'fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
+          recipient: `0x${'11'.repeat(20)}`,
+          status: 'completed',
+        },
+      },
+    })
     const res = await client.v1.webhooks.$post({
       json: {
         destination: { type: 'url', url: 'https://example.com/webhook' },
@@ -3376,7 +3636,13 @@ describe('narrows responses by status', () => {
     if (res.status === 400) {
       const json = await res.json()
       expectTypeOf(json.error.code).toEqualTypeOf<
-        Access400<'body_invalid' | 'chain_id_unsupported' | 'filters_invalid' | 'url_invalid'>
+        Access400<
+          | 'body_invalid'
+          | 'chain_id_unsupported'
+          | 'event_type_unsupported'
+          | 'filters_invalid'
+          | 'url_invalid'
+        >
       >()
     }
     if (res.status === 403) {
@@ -3632,6 +3898,10 @@ describe('narrows responses by status', () => {
       >()
       if (json.envelope.type === 'block:created')
         expectTypeOf(json.envelope.data.number).toEqualTypeOf<number>()
+      if (json.envelope.type === 'funding:deposit.updated')
+        expectTypeOf(json.envelope.data.status).toEqualTypeOf<
+          z.output<typeof Webhooks.schema.FundingDepositEvent>['status']
+        >()
       expectTypeOf(json.requestUrl).toEqualTypeOf<string>()
       void json
     }

package/src/Webhooks.ts

@@ -1,18 +1,6 @@
-import * as AppWebhooks from './apps/data/routes/webhooks.js'
-import * as Db from './db/Db.js'
-import * as core_Webhooks from './internal/Webhooks.js'
-import * as MetricSink from './internal/MetricSink.js'
-import * as Store from './internal/Store.js'
-import type * as Metrics from './Metrics.js'
-import * as Viem from './internal/Viem.js'
-
-/** How often a poller reclaims expired rows, independent of tick cadence. */
-const pruneIntervalMs = 60_000
-
 // Re-export the runtime-agnostic primitives (subscriptions, signing, delivery,
 // `deliverAndRecord`, cursors, …) so consumers reach everything through one
-// `Webhooks` namespace. The apps-layer poller stays private behind
-// `createPoller` below.
+// `Webhooks` namespace.
 export * from './internal/Webhooks.js'
 
 // Re-export the webhook resource's zod schemas so consumers can validate and
@@ -20,210 +8,3 @@ export * from './internal/Webhooks.js'
 // `type`), plus the per-event `TransferEvent` / `TransactionEvent` / `PingEvent`
 // payloads. Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
 export { enrichEventData, eventTypes, scanBlock, schema } from './apps/data/routes/webhooks.js'
-
-/**
- * Builds a webhook poller bound to a state store and chain config.
- *
- * This is the entry point a host runtime drives from chain-head notifications
- * or a timer. Each {@link Poller.tick} scans active subscriptions from their
- * cursors up to `head - confirmations` and dispatches matching events.
- *
- * Every onchain event type scans a confirmed window directly over JSON-RPC, so
- * the poller builds memoized viem clients via {@link Viem.createGetClient}. The
- * poller keeps `App.create` a pure Hono app: it constructs its own clients
- * instead of reaching into app internals, and owns no request state.
- */
-export function createPoller(options: createPoller.Options): createPoller.Poller {
-  // Persistent memoize cache for token metadata, shared across ticks (the
-  // webhook state store used to double-duty as this cache).
-  const cache = options.cache ?? Store.memory()
-  const getClient = Viem.createGetClient({
-    defaultChainId: options.defaultChainId,
-    rpc: options.rpc,
-  })
-  // Chain-head ticks run about once per block, so the janitor is throttled here
-  // rather than issuing deletes per block. Reads filter expiry at query time, so
-  // reclaiming late only costs space.
-  let prunedAt: number | undefined
-
-  const metrics = options.metrics ? MetricSink.webhooks(options.metrics) : undefined
-
-  return {
-    async tick(input = {}) {
-      const chainId = input.chainId ?? options.defaultChainId ?? Viem.defaultChainId
-
-      // Wrap the transport so each enqueue (or inline delivery) emits a timed
-      // `webhook:enqueue` metric. The wrapper preserves the dispatch contract: it
-      // returns the underlying result unchanged and is a no-op when no metrics
-      // backend is configured.
-      const inner = input.dispatch ?? options.dispatch
-      const innerBatch =
-        input.dispatchBatch ?? (input.dispatch === undefined ? options.dispatchBatch : undefined)
-      const dispatch =
-        metrics && inner
-          ? async (dispatchable: AppWebhooks.poll.Dispatchable) => {
-              const start = Date.now()
-              const result = await inner(dispatchable)
-              metrics.record({
-                chainId: dispatchable.envelope.chainId,
-                durationMs: Date.now() - start,
-                eventType: dispatchable.envelope.type,
-                ok: result.ok,
-                type: 'webhook:enqueue',
-              })
-              return result
-            }
-          : inner
-      const dispatchBatch = innerBatch
-        ? async (
-            dispatchables: readonly AppWebhooks.poll.Dispatchable[],
-            context: AppWebhooks.poll.DispatchContext,
-          ) => {
-            const start = Date.now()
-            const result = await innerBatch(dispatchables, context)
-            const durationMs = Date.now() - start
-            for (const dispatchable of dispatchables)
-              metrics?.record({
-                chainId: dispatchable.envelope.chainId,
-                durationMs,
-                eventType: dispatchable.envelope.type,
-                ok: result.ok,
-                type: 'webhook:enqueue',
-              })
-            return result
-          }
-        : undefined
-
-      // Resolve per tick so Workers factories build a fresh Hyperdrive-pooled
-      // connection each run.
-      const db = Db.get(options.db)
-      const now = input.now ?? options.now
-      if (prunedAt === undefined || Date.now() - prunedAt >= pruneIntervalMs) {
-        prunedAt = Date.now()
-        await core_Webhooks.pruneExpired(db, { now }).catch(() => {})
-      }
-
-      const start = Date.now()
-      let cursorLagBlocks: number | undefined
-      try {
-        const result = await AppWebhooks.poll({
-          batchSize: input.batchSize ?? options.batchSize,
-          cache,
-          chainId,
-          client: getClient(chainId),
-          confirmations: input.confirmations ?? options.confirmations,
-          db,
-          dispatch,
-          dispatchBatch,
-          eventTypes: input.eventTypes ?? options.eventTypes,
-          ...(input.headBlockNumber === undefined
-            ? {}
-            : { headBlockNumber: input.headBlockNumber }),
-          maxBlocks: input.maxBlocks ?? options.maxBlocks,
-          now,
-          signal: input.signal,
-          ...(metrics
-            ? {
-                onCursorLag(blocks: number) {
-                  cursorLagBlocks = blocks
-                },
-                onScanCheckpoint(checkpoint: AppWebhooks.poll.ScanCheckpoint) {
-                  metrics.record({ chainId, type: 'webhook:poll-scan', ...checkpoint })
-                  // Ship the start boundary before the RPC allocation can terminate the isolate.
-                  metrics.flush()
-                },
-                onStage(stage: AppWebhooks.poll.Stage) {
-                  metrics.record({ chainId, type: 'webhook:poll', ...stage })
-                },
-                onSubscriptions(count: number) {
-                  metrics.record({ chainId, count, type: 'webhook:poll-subscriptions' })
-                },
-              }
-            : {}),
-        })
-        metrics?.record({
-          cursorLagBlocks,
-          meta: { durationMs: Date.now() - start, outcome: 'ok' },
-          result,
-          type: 'webhook:tick',
-        })
-        return result
-      } catch (error) {
-        metrics?.record({
-          cursorLagBlocks,
-          meta: { chainId, durationMs: Date.now() - start, outcome: 'error' },
-          result: undefined,
-          type: 'webhook:tick',
-        })
-        throw error
-      } finally {
-        metrics?.flush()
-      }
-    },
-  }
-}
-
-export declare namespace createPoller {
-  /** A row to dispatch, paired with its owning subscription. */
-  type Dispatchable = AppWebhooks.poll.Dispatchable
-
-  /** Delivery transport: hands a matched event to a queue or delivers inline. */
-  type Dispatch = NonNullable<AppWebhooks.poll.Options['dispatch']>
-
-  /** Batch delivery transport: confirms all rows together or leaves their cursor unchanged. */
-  type DispatchBatch = NonNullable<AppWebhooks.poll.Options['dispatchBatch']>
-
-  /** Summary counters returned by {@link Poller.tick}. */
-  type Result = AppWebhooks.poll.Result
-
-  /** Knobs shared by every {@link Poller.tick}; each is overridable per tick. */
-  type Defaults = {
-    /** Max matching rows scanned per subscription per tick (default 200). */
-    batchSize?: number | undefined
-    /** Reorg-safety window: only emit blocks this far behind head (default 1). */
-    confirmations?: number | undefined
-    /**
-     * Delivery transport. Defaults to inline `deliverAndRecord` (self-host); on
-     * Cloudflare pass a Queue producer so retry/backoff/DLQ are native.
-     */
-    dispatch?: Dispatch | undefined
-    /** Batch delivery transport used when the runtime can enqueue multiple rows atomically. */
-    dispatchBatch?: DispatchBatch | undefined
-    /** Event types to poll (default all). */
-    eventTypes?: AppWebhooks.poll.Options['eventTypes']
-    /** Backfill cap: most blocks an RPC scanner inspects per tick (default 1000). */
-    maxBlocks?: number | undefined
-    /** Clock for envelope timestamps; injectable for tests. */
-    now?: (() => Date) | undefined
-  }
-
-  /** Options for {@link createPoller}. */
-  type Options = Defaults & {
-    /** Cache for token metadata shared across ticks. */
-    cache?: Store.Store | undefined
-    /** Database holding subscriptions + cursors, or a factory resolved per tick (Workers/Hyperdrive). */
-    db: Db.Source
-    /** Tempo chain id polled when a tick omits one. */
-    defaultChainId?: Viem.ChainId | undefined
-    /** Metrics backend; emits `webhook:tick` per tick and `webhook:enqueue` per dispatch. */
-    metrics?: Metrics.Metrics | undefined
-    /** RPC options for the viem clients that scan chain events. */
-    rpc?: Viem.getClient.Rpc | undefined
-  }
-
-  /** Per-tick overrides; falls back to the {@link Options} defaults. */
-  type TickOptions = Defaults & {
-    /** Chain to poll this tick (default `options.defaultChainId`). */
-    chainId?: Viem.ChainId | undefined
-    /** Chain head to work back from; resolved from RPC when omitted. */
-    headBlockNumber?: bigint | number | undefined
-    /** Stops scanning and dispatch when the caller loses its execution lease. */
-    signal?: AbortSignal | undefined
-  }
-
-  /** A chain-head-driven webhook poller. */
-  type Poller = {
-    /** Runs one poll tick, resolving the RPC head when not supplied. */
-    tick(options?: TickOptions): Promise<Result>
-  }
-}