tapimo 0.10.1 → 0.11.0

package/src/Webhooks.ts

@@ -1,229 +1,10 @@
-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
 // type delivery bodies: `Webhooks.schema.Envelope` (a discriminated union on
 // `type`), plus the per-event `TransferEvent` / `TransactionEvent` / `PingEvent`
 // payloads. Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
-export { eventTypes, 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>
-  }
-}
+export { enrichEventData, eventTypes, scanBlock, schema } from './apps/data/routes/webhooks.js'

package/src/analytics/Analytics.test.ts

@@ -5,10 +5,12 @@ import * as RequestEvents from './tables/requestEvents.js'
 const context = { enabled: true, environment: 'test', service: 'api' }
 
 const entry = {
+  chainId: 4217,
   duration: 12.3,
   level: 'info',
   method: 'GET',
   path: '/v1/transactions',
+  query: 'include=receipt&limit=10',
   requestId: 'req-1',
   route: '/v1/transactions',
   status: 200,
@@ -25,6 +27,7 @@ const clickHouse = {
 /** Baseline stored row for insert/queue tests. */
 const row = {
   billing_active: null,
+  chain_id: 4217,
   duration_ms: 12.3,
   environment: 'test',
   error_code: null,
@@ -34,6 +37,7 @@ const row = {
   org_id: null,
   project_id: null,
   principal_type: 'unknown',
+  query: 'include=receipt&limit=10',
   rate_limit_scope: null,
   request_id: 'req-1',
   route: '/v1/transactions',
@@ -183,6 +187,7 @@ describe('migrations', () => {
     const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
     for (const column of Object.keys(row)) expect(sql).toContain(column)
     expect(sql).toContain('timings Map(String, Float64)')
+    expect(sql).toContain('query String')
   })
 
   test('the migrations declare query benchmark history', () => {
@@ -192,6 +197,22 @@ describe('migrations', () => {
     expect(sql).toContain('rpc_url String')
     expect(sql).toContain('tidx_url String')
   })
+
+  test('the migrations declare the endpoint latency view', () => {
+    const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
+    const latest = Analytics.migrations[Analytics.migrations.length - 1]!
+    expect(sql).toContain('CREATE OR REPLACE VIEW endpoint_latency_results')
+    expect(sql).toContain("'production' AS source")
+    expect(sql).toContain("'benchmark' AS source")
+    expect(sql).toContain("if(result.metric = 'benchmark', 'request', result.metric) AS metric")
+    expect(sql).toContain("if(status >= 200 AND status < 300, 'success', 'error') AS outcome")
+    expect(sql).toContain("WHERE result.metric != 'request'")
+    expect(sql).toContain('arrayZip(mapKeys(timings), mapValues(timings))')
+    expect(latest.name).toBe('0011_endpoint_latency_query')
+    expect(latest.sql).toContain("environment = 'production' AND service = 'cadent-api'")
+    expect(latest.sql).toContain("coalesce(request_id, '') AS request_id")
+    expect(latest.sql).toContain('query AS variant')
+  })
 })
 
 describe('get', () => {
@@ -213,6 +234,7 @@ describe('createQueueSink', () => {
     const row = send.mock.calls[0]![0]
     expect({
       billing_active: row.billing_active,
+      chain_id: row.chain_id,
       duration_ms: row.duration_ms,
       environment: row.environment,
       error_code: row.error_code,
@@ -222,6 +244,7 @@ describe('createQueueSink', () => {
       org_id: row.org_id,
       principal_type: row.principal_type,
       project_id: row.project_id,
+      query: row.query,
       rate_limit_scope: row.rate_limit_scope,
       request_id: row.request_id,
       route: row.route,
@@ -235,6 +258,7 @@ describe('createQueueSink', () => {
     }).toMatchInlineSnapshot(`
       {
         "billing_active": null,
+        "chain_id": 4217,
         "duration_ms": 12.3,
         "environment": "test",
         "error_code": null,
@@ -244,6 +268,7 @@ describe('createQueueSink', () => {
         "org_id": null,
         "principal_type": "unknown",
         "project_id": null,
+        "query": "include=receipt&limit=10",
         "rate_limit_scope": null,
         "request_id": "req-1",
         "route": "/v1/transactions",
@@ -270,6 +295,15 @@ describe('createQueueSink', () => {
     expect(send.mock.calls[0]![0].timings).toMatchInlineSnapshot(`{}`)
   })
 
+  test('stores an empty query when the request has no query string', async () => {
+    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const sink = Analytics.createQueueSink({ send })(context)
+
+    await sink({ ...entry, query: undefined })
+
+    expect(send.mock.calls[0]![0].query).toMatchInlineSnapshot(`""`)
+  })
+
   test('retries a failed send once with the same row', async () => {
     const send = vi
       .fn<(message: Analytics.Event) => Promise<void>>()

package/src/analytics/Analytics.ts

@@ -120,6 +120,7 @@ export const migrations: readonly Migration[] = [
         timestamp DateTime64(3, 'UTC'),
         service LowCardinality(String),
         environment LowCardinality(String),
+        chain_id Nullable(UInt32),
         method LowCardinality(String),
         route LowCardinality(String),
         status UInt16,
@@ -129,6 +130,7 @@ export const migrations: readonly Migration[] = [
         key_environment Nullable(String),
         org_id Nullable(String),
         project_id Nullable(String),
+        query String,
         rate_limit_scope Nullable(String),
         error_code Nullable(String),
         rpc_error_code Nullable(Int32),
@@ -203,6 +205,8 @@ export const migrations: readonly Migration[] = [
         git_ref LowCardinality(String),
         chain_id UInt32,
         chain LowCardinality(String),
+        method LowCardinality(String),
+        route LowCardinality(String),
         query String,
         metric LowCardinality(String),
         mean_ms Float64,
@@ -218,6 +222,208 @@ export const migrations: readonly Migration[] = [
       ORDER BY (chain_id, query, metric, timestamp, run_id)
     `,
   },
+  {
+    name: '0006_endpoint_latency_dimensions',
+    // Patches production while fresh preview tables skip the unavailable ALTER.
+    guard: `
+      SELECT toUInt8(count() = 1) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'request_events'
+        AND name = 'chain_id'
+    `,
+    sql: `
+      ALTER TABLE request_events
+        ADD COLUMN IF NOT EXISTS chain_id Nullable(UInt32) AFTER environment
+    `,
+  },
+  {
+    name: '0007_query_benchmark_dimensions',
+    // Patches production while fresh preview tables skip the unavailable ALTER.
+    guard: `
+      SELECT toUInt8(count() = 2) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'query_benchmark_results'
+        AND name IN ('method', 'route')
+    `,
+    sql: `
+      ALTER TABLE query_benchmark_results
+        ADD COLUMN IF NOT EXISTS method LowCardinality(String) AFTER chain,
+        ADD COLUMN IF NOT EXISTS route LowCardinality(String) AFTER method
+    `,
+  },
+  {
+    name: '0008_endpoint_latency_results',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        '' AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
+  {
+    name: '0009_endpoint_latency_production_service',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        '' AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'cadent-api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
+  {
+    name: '0010_request_events_query',
+    // Patches tables created before redacted request queries entered the baseline.
+    // Fresh tables skip this ALTER, allowing scoped preview users to migrate.
+    guard: `
+      SELECT toUInt8(count() = 1) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'request_events'
+        AND name = 'query'
+    `,
+    sql: `
+      ALTER TABLE request_events
+        ADD COLUMN IF NOT EXISTS query String AFTER project_id
+    `,
+  },
+  {
+    name: '0011_endpoint_latency_query',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        query AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        coalesce(request_id, '') AS request_id,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'cadent-api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        '' AS request_id,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
 ]
 
 /**

package/src/analytics/tables/requestEvents.ts

@@ -10,6 +10,8 @@ export type Table = {
    * billing gate for sandbox: only `1` rows bill.
    */
   billing_active: number | null
+  /** Tempo chain selected for the request. */
+  chain_id: number | null
   /** Total request duration in milliseconds. */
   duration_ms: number
   /** Deployment environment that served the request. */
@@ -28,6 +30,8 @@ export type Table = {
   project_id: string | null
   /** Caller principal kind. */
   principal_type: 'api_key' | 'public' | 'session' | 'super_admin' | 'unknown'
+  /** Redacted request query string, without a leading `?`. */
+  query: string
   /** Rate-limit bucket scope, when a rate limit was applied. */
   rate_limit_scope: string | null
   /** Numeric JSON-RPC error code when every failed response shares one code. */
@@ -557,6 +561,7 @@ function event(entry: Log.Entry, context: Metrics.cloudflare.Context): Table {
   const principal = entry.principal
   return {
     billing_active: principal?.type === 'api_key' ? Number(principal.billingActive === true) : null,
+    chain_id: entry.chainId ?? null,
     duration_ms: entry.duration,
     environment: context.environment ?? 'unknown',
     error_code: entry.errorCode ?? null,
@@ -566,6 +571,7 @@ function event(entry: Log.Entry, context: Metrics.cloudflare.Context): Table {
     org_id: principal?.type === 'api_key' ? (principal.orgId ?? null) : null,
     project_id: principal?.type === 'api_key' ? (principal.projectId ?? null) : null,
     principal_type: principal?.type ?? 'unknown',
+    query: entry.query ?? '',
     rate_limit_scope: entry.rateLimit?.scope ?? null,
     request_id: entry.requestId ?? null,
     route: entry.route,

package/src/apps/composition.test.ts

@@ -326,6 +326,7 @@ describe('funding()', () => {
         ),
       ),
     ).toEqual([
+      'listFundingDepositAddresses',
       'createFundingDepositAddress',
       'reconcileFundingDepositAddress',
       'getFundingDepositAddress',

package/src/apps/data/App.ts

@@ -224,7 +224,13 @@ export function data(options: data.Options = {}) {
     .route('/', transactionActivities({ fx: options.fx }))
     .route('/', transfers({ fx: options.fx }))
     .route('/', verifiedTokens())
-    .route('/', webhooks({ enabled: options.webhook !== false }))
+    .route(
+      '/',
+      webhooks({
+        applicationEventTypes: webhook?.applicationEventTypes ?? [],
+        enabled: options.webhook !== false,
+      }),
+    )
     .route('/', zones())
     .route('/', rpc())
     .route('/', coingecko())
@@ -237,6 +243,8 @@ export function data(options: data.Options = {}) {
       indexerHandlers: indexerRouteHandlers,
       rpcOnlyHandlers: rpcOnlyRouteHandlers,
     })
+    if (selection.matched && !selection.conflict && !selection.invalid)
+      c.set('chainId', selection.chainId)
     return (
       selection.matched &&
       !selection.conflict &&
@@ -443,7 +451,7 @@ function webhooksBlock() {
             'tempo-event-id',
             'A unique, stable id for this event (`evt_…`). The same event may be delivered more than once, so use this id to skip duplicates.',
           ),
-          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, or `ping`.'), // prettier-ignore
+          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, `funding:deposit.updated`, or `ping`.'), // prettier-ignore
         ],
         requestBody: {
           content: { 'application/json': { schema: envelope } },