tapimo 0.10.1 → 0.10.2

package/src/db/tables/fundingDeposits.ts

@@ -27,6 +27,24 @@ export type Owner = {
   projectId?: string | undefined
 }
 
+/** Optional filters shared by funding deposit list and count queries. */
+export type Filters = {
+  /** Reusable source-chain address that received the funds. */
+  depositAddress?: string | undefined
+  /** Canonical destination token keys accepted by the filter. */
+  destinationTokenKeys?: readonly string[] | undefined
+  /** Funding provider id. */
+  providerId?: string | undefined
+  /** Tempo account that receives completed deposits. */
+  recipient?: string | undefined
+  /** Canonical source chain ids accepted by the filter. */
+  sourceChainIds?: readonly string[] | undefined
+  /** Canonical source token keys accepted by the filter. */
+  sourceTokenKeys?: readonly string[] | undefined
+  /** Deposit lifecycle status. */
+  status?: Record['status'] | undefined
+}
+
 /** Inserts one provider-observed source transfer as a funding deposit. */
 export function insert(db: Db.Db, record: Record): Promise<Record> {
   return db.kysely
@@ -234,6 +252,118 @@ export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record |
   return query.executeTakeFirst()
 }
 
+/** Lists owner-visible funding deposits newest-first. */
+export function list(db: Db.Db, options: list.Options): Promise<Record[]> {
+  const { cursor, limit } = options
+  let builder = query(db, options).selectAll('funding_deposits')
+  if (cursor)
+    builder = builder.where((eb) =>
+      eb.or([
+        eb('funding_deposits.createdAt', '<', cursor.createdAt),
+        eb.and([
+          eb('funding_deposits.createdAt', '=', cursor.createdAt),
+          eb('funding_deposits.id', '<', cursor.id),
+        ]),
+      ]),
+    )
+  return builder
+    .orderBy('funding_deposits.createdAt', 'desc')
+    .orderBy('funding_deposits.id', 'desc')
+    .limit(limit)
+    .execute()
+}
+
+export declare namespace list {
+  /** Ownership and paging options for funding deposits. */
+  type Options = Filters & {
+    /** Exclusive lower bound from the previous page. */
+    cursor?: listByAddress.Cursor | undefined
+    /** Maximum rows to return. */
+    limit: number
+    /** Ownership filter derived from the authenticated API key. */
+    owner: Owner
+  }
+}
+
+/** Counts owner-visible funding deposits through the list's shared filters. */
+export async function count(db: Db.Db, options: count.Options): Promise<number> {
+  const rows = query(db, options)
+    .select('funding_deposits.id')
+    .limit(options.cap + 1)
+    .as('rows')
+  const result = await db.kysely
+    .selectFrom(rows)
+    .select(sql<number>`count(*)::int`.as('count'))
+    .executeTakeFirstOrThrow()
+  return result.count
+}
+
+export declare namespace count {
+  /** Ownership, filter, and cap options for counting funding deposits. */
+  type Options = Filters & {
+    /** Maximum exact count before returning the cap plus one. */
+    cap: number
+    /** Ownership filter derived from the authenticated API key. */
+    owner: Owner
+  }
+}
+
+function query(db: Db.Db, options: query.Options) {
+  const owner = options.owner
+  let builder = db.kysely
+    .selectFrom('funding_deposits')
+    .innerJoin(
+      'funding_deposit_addresses',
+      'funding_deposit_addresses.id',
+      'funding_deposits.depositAddressId',
+    )
+    .where('funding_deposit_addresses.environment', '=', owner.environment)
+    .where('funding_deposit_addresses.orgId', '=', owner.orgId)
+    .where('funding_deposits.environment', '=', owner.environment)
+    .where('funding_deposits.orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined)
+    builder = builder
+      .where('funding_deposit_addresses.projectId', '=', owner.projectId)
+      .where('funding_deposits.projectId', '=', owner.projectId)
+  if (options.depositAddress !== undefined) {
+    const address = /^0x[0-9a-fA-F]{40}$/.test(options.depositAddress)
+      ? options.depositAddress.toLowerCase()
+      : options.depositAddress
+    builder = builder.where('funding_deposit_addresses.address', '=', address)
+  }
+  if (options.destinationTokenKeys !== undefined)
+    builder = options.destinationTokenKeys.length
+      ? builder.where(
+          'funding_deposit_addresses.destinationTokenKey',
+          'in',
+          options.destinationTokenKeys,
+        )
+      : builder.where(sql<boolean>`false`)
+  if (options.providerId !== undefined)
+    builder = builder.where('funding_deposit_addresses.providerId', '=', options.providerId)
+  if (options.recipient !== undefined)
+    builder = builder.where(
+      sql<boolean>`lower(funding_deposit_addresses.recipient) = ${options.recipient.toLowerCase()}`,
+    )
+  if (options.sourceChainIds !== undefined)
+    builder = options.sourceChainIds.length
+      ? builder.where('funding_deposit_addresses.sourceChainId', 'in', options.sourceChainIds)
+      : builder.where(sql<boolean>`false`)
+  if (options.sourceTokenKeys !== undefined)
+    builder = options.sourceTokenKeys.length
+      ? builder.where('funding_deposit_addresses.sourceTokenKey', 'in', options.sourceTokenKeys)
+      : builder.where(sql<boolean>`false`)
+  if (options.status !== undefined)
+    builder = builder.where('funding_deposits.status', '=', options.status)
+  return builder
+}
+
+declare namespace query {
+  type Options = Filters & {
+    owner: Owner
+  }
+}
+
 /** Lists one owner-visible address's deposits newest-first. */
 export function listByAddress(
   db: Db.Db,

package/src/internal/Auth.test.ts

@@ -2100,54 +2100,6 @@ describe('ensureProject', () => {
   })
 })
 
-describe('parseCredential', () => {
-  test('parses credentials keyed by chain id', () => {
-    const credential = Auth.parseCredential(
-      JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone:secret' }),
-    )
-
-    expect(credential).toEqual({ 4217: 'mainnet:secret', 421700001: 'zone:secret' })
-  })
-
-  test('supports a shared credential', () => {
-    expect(Auth.parseCredential('shared:secret')).toBe('shared:secret')
-  })
-
-  test('rejects malformed credential maps', () => {
-    expect(() => Auth.parseCredential('{"4217":1}')).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Expected a credential or a chain-id-to-credential JSON object.]`,
-    )
-  })
-})
-
-describe('resolveCredential', () => {
-  test('infers Basic auth from a credential containing a colon', () => {
-    expect(Auth.resolveCredential({ chainId: 4217, value: 'user:password' })).toEqual({
-      basicAuth: 'user:password',
-    })
-  })
-
-  test('infers Bearer auth from a credential without a colon', () => {
-    expect(Auth.resolveCredential({ chainId: 4217, value: 'bearer-token' })).toEqual({
-      basicAuth: undefined,
-      bearerAuth: 'bearer-token',
-    })
-  })
-
-  test('selects a credential by chain id', () => {
-    const value = JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone-token' })
-
-    expect(Auth.resolveCredential({ chainId: 4217, value })).toEqual({
-      basicAuth: 'mainnet:secret',
-    })
-    expect(Auth.resolveCredential({ chainId: 421700001, value })).toEqual({
-      basicAuth: undefined,
-      bearerAuth: 'zone-token',
-    })
-    expect(Auth.resolveCredential({ chainId: 42431, value })).toEqual({ basicAuth: undefined })
-  })
-})
-
 function createScopedApp(options: {
   auth?: Auth.Context | undefined
   routes: readonly { path: string; policy: Auth.require.Policy }[]

package/src/internal/Auth.ts

@@ -1674,65 +1674,6 @@ type RateLimitAccess = PaymentAccess & {
   rateLimit: RateLimit.Result
 }
 
-/** Shared or per-chain credentials. */
-export type ChainCredential = string | Record<number, string>
-
-/** Parses shared or per-chain credentials from an environment value. */
-export function parseCredential(value: ChainCredential | undefined): parseCredential.ReturnType {
-  if (!value) return undefined
-  if (typeof value !== 'string') return value
-  const credentials = (() => {
-    try {
-      return JSON.parse(value) as unknown
-    } catch {
-      return value
-    }
-  })()
-  if (typeof credentials === 'string') return credentials
-  if (
-    !credentials ||
-    typeof credentials !== 'object' ||
-    Array.isArray(credentials) ||
-    Object.values(credentials).some((credential) => typeof credential !== 'string')
-  )
-    throw new Error('Expected a credential or a chain-id-to-credential JSON object.')
-  return credentials as Record<number, string>
-}
-
-export declare namespace parseCredential {
-  /** Parsed shared or per-chain credentials. */
-  type ReturnType = ChainCredential | undefined
-}
-
-/** Resolves a chain credential and infers its HTTP authorization scheme. */
-export function resolveCredential(
-  options: resolveCredential.Options,
-): resolveCredential.ReturnType {
-  const credentials = parseCredential(options.value)
-  const credential = typeof credentials === 'string' ? credentials : credentials?.[options.chainId]
-  if (!credential) return { basicAuth: undefined }
-  if (credential.includes(':')) return { basicAuth: credential }
-  return { basicAuth: undefined, bearerAuth: credential }
-}
-
-export declare namespace resolveCredential {
-  /** Options for resolving a chain credential. */
-  type Options = {
-    /** Chain id selecting a per-chain credential. */
-    chainId: number
-    /** Shared or per-chain credentials. */
-    value?: ChainCredential | undefined
-  }
-
-  /** Resolved HTTP authorization credentials. */
-  type ReturnType = {
-    /** Basic credentials inferred from a value containing a colon. */
-    basicAuth: string | undefined
-    /** Bearer credential inferred from a value without a colon. */
-    bearerAuth?: string | undefined
-  }
-}
-
 /**
  * How long to wait for the rate-limit counter before failing open. A hot
  * counter backend (e.g. a single Durable Object serving one busy quota bucket)

package/src/internal/Credential.test.ts

@@ -0,0 +1,51 @@
+import * as Credential from './Credential.js'
+
+describe('parseCredential', () => {
+  test('parses credentials keyed by chain id', () => {
+    const credential = Credential.parseCredential(
+      JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone:secret' }),
+    )
+
+    expect(credential).toEqual({ 4217: 'mainnet:secret', 421700001: 'zone:secret' })
+  })
+
+  test('supports a shared credential', () => {
+    expect(Credential.parseCredential('shared:secret')).toBe('shared:secret')
+  })
+
+  test('rejects malformed credential maps', () => {
+    expect(() => Credential.parseCredential('{"4217":1}')).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Expected a credential or a chain-id-to-credential JSON object.]`,
+    )
+  })
+})
+
+describe('resolveCredential', () => {
+  test('infers Basic auth from a credential containing a colon', () => {
+    expect(Credential.resolveCredential({ chainId: 4217, value: 'user:password' })).toEqual({
+      basicAuth: 'user:password',
+    })
+  })
+
+  test('infers Bearer auth from a credential without a colon', () => {
+    expect(Credential.resolveCredential({ chainId: 4217, value: 'bearer-token' })).toEqual({
+      basicAuth: undefined,
+      bearerAuth: 'bearer-token',
+    })
+  })
+
+  test('selects a credential by chain id', () => {
+    const value = JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone-token' })
+
+    expect(Credential.resolveCredential({ chainId: 4217, value })).toEqual({
+      basicAuth: 'mainnet:secret',
+    })
+    expect(Credential.resolveCredential({ chainId: 421700001, value })).toEqual({
+      basicAuth: undefined,
+      bearerAuth: 'zone-token',
+    })
+    expect(Credential.resolveCredential({ chainId: 42431, value })).toEqual({
+      basicAuth: undefined,
+    })
+  })
+})

package/src/internal/Credential.ts

@@ -0,0 +1,58 @@
+/** Shared or per-chain credentials. */
+export type ChainCredential = string | Record<number, string>
+
+/** Parses shared or per-chain credentials from an environment value. */
+export function parseCredential(value: ChainCredential | undefined): parseCredential.ReturnType {
+  if (!value) return undefined
+  if (typeof value !== 'string') return value
+  const credentials = (() => {
+    try {
+      return JSON.parse(value) as unknown
+    } catch {
+      return value
+    }
+  })()
+  if (typeof credentials === 'string') return credentials
+  if (
+    !credentials ||
+    typeof credentials !== 'object' ||
+    Array.isArray(credentials) ||
+    Object.values(credentials).some((credential) => typeof credential !== 'string')
+  )
+    throw new Error('Expected a credential or a chain-id-to-credential JSON object.')
+  return credentials as Record<number, string>
+}
+
+export declare namespace parseCredential {
+  /** Parsed shared or per-chain credentials. */
+  type ReturnType = ChainCredential | undefined
+}
+
+/** Resolves a chain credential and infers its HTTP authorization scheme. */
+export function resolveCredential(
+  options: resolveCredential.Options,
+): resolveCredential.ReturnType {
+  const credentials = parseCredential(options.value)
+  const credential = typeof credentials === 'string' ? credentials : credentials?.[options.chainId]
+  if (!credential) return { basicAuth: undefined }
+  if (credential.includes(':')) return { basicAuth: credential }
+  return { basicAuth: undefined, bearerAuth: credential }
+}
+
+export declare namespace resolveCredential {
+  /** Options for resolving a chain credential. */
+  type Options = {
+    /** Chain id selecting a per-chain credential. */
+    chainId: number
+    /** Shared or per-chain credentials. */
+    value?: ChainCredential | undefined
+  }
+
+  /** Resolved HTTP authorization credentials. */
+  type ReturnType = {
+    /** Basic credentials inferred from a value containing a colon. */
+    basicAuth: string | undefined
+    /** Bearer credential inferred from a value without a colon. */
+    bearerAuth?: string | undefined
+  }
+}

package/src/internal/EarnRates.ts

@@ -246,6 +246,12 @@ async function measurePage(options: measurePage.Options): Promise<Measurement |
       () => undefined,
     )
 
+  // The migration scan is independent of historical quotes, so keep its TIDX
+  // round trip off the RPC critical path.
+  const migrations = recentMigrations(options).then(
+    (value) => ({ status: 'fulfilled', value }) as const,
+    (reason: unknown) => ({ reason, status: 'rejected' }) as const,
+  )
   const rates = new Map<string, string>()
   await Promise.all(
     options.vaults.map(async (vault) => {
@@ -263,13 +269,13 @@ async function measurePage(options: measurePage.Options): Promise<Measurement |
     }),
   )
   if (rates.size === 0) return { measuredAt, rates }
+  const migrationResult = await migrations
 
   // A migration inside the window bridges two different yield engines, so the
-  // window resets instead of reporting growth across the swap. Scanned only
-  // once a rate exists for it to invalidate.
-  const migrations = await recentMigrations(options)
-  if (!migrations) return undefined
-  for (const { blockNumber, vault } of migrations)
+  // window resets instead of reporting growth across the swap.
+  if (migrationResult.status === 'rejected') throw migrationResult.reason
+  if (!migrationResult.value) return undefined
+  for (const { blockNumber, vault } of migrationResult.value)
     if (blockNumber > start.number && blockNumber <= end.number) rates.delete(vault)
   return { measuredAt, rates }
 }
@@ -306,9 +312,9 @@ async function boundaryBlocks(options: boundaryBlocks.Options): Promise<Boundari
       const result = await options.getTidx(chainId).fetch({
         chainId,
         query: `
-          (SELECT num, timestamp FROM blocks WHERE timestamp <= '${endInstant}' ORDER BY num DESC LIMIT 1)
+          (SELECT num, timestamp FROM blocks WHERE timestamp <= '${endInstant}' ORDER BY timestamp DESC, num DESC LIMIT 1)
           UNION ALL
-          (SELECT num, timestamp FROM blocks WHERE timestamp <= '${startInstant}' ORDER BY num DESC LIMIT 1)
+          (SELECT num, timestamp FROM blocks WHERE timestamp <= '${startInstant}' ORDER BY timestamp DESC, num DESC LIMIT 1)
         ` as string,
       })
       const rows = result.rows.flatMap((row) => {

package/src/internal/Log.test.ts

@@ -51,10 +51,11 @@ describe('middleware', () => {
     `)
   })
 
-  test('includes a failed optional funding transfer count', async () => {
+  test('includes failed optional funding counts', async () => {
     const entries: Log.Entry[] = []
     const api = app({ emit: (entry) => void entries.push(entry) })
     api.get('/v1/funding/transfers', (c) => {
+      c.set('fundingDepositCountFailed', true)
       c.set('fundingTransferCountFailed', true)
       return c.json({ data: [], nextCursor: null }, 200)
     })
@@ -63,6 +64,7 @@ describe('middleware', () => {
 
     expect(stable(entries[0]!)).toMatchInlineSnapshot(`
       {
+        "fundingDepositCountFailed": true,
         "fundingTransferCountFailed": true,
         "level": "info",
         "method": "GET",

package/src/internal/Log.ts

@@ -10,10 +10,14 @@ import type * as Timing from './Timing.js'
 
 /** Hono variables read by the request logger and written by other layers. */
 export type Variables = {
+  /** Tempo chain selected for the request. */
+  chainId?: number | undefined
   /** Whether the original request exception was already reported. */
   errorCaptured?: boolean | undefined
   /** Stable error code recorded by `Response.error` for the request log entry. */
   errorCode?: string | undefined
+  /** Whether the optional funding deposit count query failed. */
+  fundingDepositCountFailed?: true | undefined
   /** Bounded MPP relay outcome emitted by the credential routes. */
   mpp?: Entry['mpp'] | undefined
   /** Bounded outcomes for funding providers attempted by the request. */
@@ -125,12 +129,16 @@ export type Sponsorship = {
 export type Entry = {
   /** `'hit'` when the edge response cache served the request without reaching the origin handlers. */
   cache?: 'hit' | undefined
+  /** Tempo chain selected for the request. */
+  chainId?: number | undefined
   /** Total request duration in milliseconds. */
   duration: number
   /** Whether the original request exception was already reported. */
   errorCaptured?: boolean | undefined
   /** Stable error code when the response is a JSON error envelope (e.g. `not_found`, `api_key_invalid`). */
   errorCode?: string | undefined
+  /** Whether the optional funding deposit count query failed. */
+  fundingDepositCountFailed?: true | undefined
   /** Bounded funding provider attempts made while serving the request. */
   fundingProviderAttempts?: readonly FundingProviderAttempt[] | undefined
   /** Whether the optional funding transfer count query failed. */
@@ -253,7 +261,11 @@ export function middleware<environment extends Environment = Environment>(
     const error = c.error as ErrorMetadata | undefined
     const principal = c.get('principal' as never) as Auth.Principal | undefined
     const errorCaptured = c.get('errorCaptured' as never) as boolean | undefined
+    const chainId = c.get('chainId' as never) as number | undefined
     const errorCode = c.get('errorCode' as never) as string | undefined
+    const fundingDepositCountFailed = c.get('fundingDepositCountFailed' as never) as
+      | true
+      | undefined
     const fundingProviderAttempts =
       error?.fundingProviderAttempts ??
       (c.get('fundingProviderAttempts' as never) as Entry['fundingProviderAttempts'] | undefined)
@@ -300,9 +312,11 @@ export function middleware<environment extends Environment = Environment>(
 
     const result = fn({
       ...(c.get('edgeCacheStatus' as never) === 'hit' ? { cache: 'hit' as const } : {}),
+      ...(chainId === undefined ? {} : { chainId }),
       duration: round(duration),
       ...(errorCaptured === undefined ? {} : { errorCaptured }),
       ...(errorCode === undefined ? {} : { errorCode }),
+      ...(fundingDepositCountFailed === undefined ? {} : { fundingDepositCountFailed }),
       ...(fundingProviderAttempts === undefined ? {} : { fundingProviderAttempts }),
       ...(fundingTransferCountFailed === undefined ? {} : { fundingTransferCountFailed }),
       level:

package/src/internal/MetricSink.test.ts

@@ -11,7 +11,7 @@ type MetricEvent = {
 }
 
 describe('requests', () => {
-  test('records optional funding transfer count failures on successful pages', () => {
+  test('records optional funding count failures on successful pages', () => {
     const events: MetricEvent[] = []
     const metrics = Metrics.from({
       count(name, value, tags) {
@@ -25,6 +25,7 @@ describe('requests', () => {
 
     record({
       duration: 10,
+      fundingDepositCountFailed: true,
       fundingTransferCountFailed: true,
       level: 'info',
       method: 'GET',
@@ -34,6 +35,22 @@ describe('requests', () => {
       status: 200,
     })
 
+    expect(events.find((event) => event.name === 'funding_deposit_count_failure_count'))
+      .toMatchInlineSnapshot(`
+      {
+        "name": "funding_deposit_count_failure_count",
+        "tags": {
+          "cache": "miss",
+          "method": "GET",
+          "principal_environment": "none",
+          "principal_type": "unknown",
+          "route": "/v1/funding/transfers",
+        },
+        "type": "count",
+        "value": 1,
+      }
+    `)
+
     expect(events.find((event) => event.name === 'funding_transfer_count_failure_count'))
       .toMatchInlineSnapshot(`
       {
@@ -637,6 +654,38 @@ describe('webhooks', () => {
     `)
   })
 
+  test('records scan pipeline blocks, backlog, and finality lag', () => {
+    const events: MetricEvent[] = []
+    const metrics = Metrics.from({
+      count(name, value, tags) {
+        events.push({ name, tags, type: 'count', value })
+      },
+      flush() {},
+      gauge(name, value, tags) {
+        events.push({ name, tags, type: 'gauge', value })
+      },
+      histogram() {},
+    })
+    const sink = MetricSink.webhooks(metrics)
+
+    sink.record({ chainId: 42431, matches: 3, origin: 'socket', outcome: 'dispatched', type: 'webhook:scan-block' }) // prettier-ignore
+    sink.record({ chainId: 42431, matches: 0, origin: 'poll', outcome: 'deferred', type: 'webhook:scan-block' }) // prettier-ignore
+    sink.record({ chainId: 42431, oldestPendingAgeMs: 5_000, pendingCount: 2, type: 'webhook:scan-backlog' }) // prettier-ignore
+    sink.record({ chainId: 42431, lagBlocks: 1, type: 'webhook:scan-finality' })
+
+    expect(events.map(({ name, tags, value }) => `${name}=${value} ${JSON.stringify(tags)}`))
+      .toMatchInlineSnapshot(`
+        [
+          "webhook_scan_block_count=1 {"chain_id":"42431","origin":"socket","outcome":"dispatched"}",
+          "webhook_scan_match_count=3 {"chain_id":"42431","origin":"socket","outcome":"dispatched"}",
+          "webhook_scan_block_count=1 {"chain_id":"42431","origin":"poll","outcome":"deferred"}",
+          "webhook_scan_pending_count=2 {"chain_id":"42431"}",
+          "webhook_scan_oldest_pending_age_ms=5000 {"chain_id":"42431"}",
+          "webhook_scan_finality_lag_blocks=1 {"chain_id":"42431"}",
+        ]
+      `)
+  })
+
   test('records obligation staging and claim outcomes', () => {
     const events: MetricEvent[] = []
     const metrics = Metrics.from({

package/src/internal/MetricSink.ts

@@ -159,6 +159,33 @@ export type WebhookEvent =
       ok: boolean
       type: 'webhook:enqueue'
     }
+  | {
+      chainId: number
+      /** Rows matched when dispatched; zero otherwise. */
+      matches: number
+      /** How the head that enqueued this block was observed. */
+      origin: string
+      /** One scanned block's outcome. */
+      outcome: 'deferred' | 'dispatched' | 'empty'
+      /** Identifies one block-fanout scan. */
+      type: 'webhook:scan-block'
+    }
+  | {
+      chainId: number
+      /** Age of the oldest tracked block, absent when none are pending. */
+      oldestPendingAgeMs?: number | undefined
+      /** Tracked blocks awaiting completion reports. */
+      pendingCount: number
+      /** Identifies the coordinator's tracked-scan backlog. */
+      type: 'webhook:scan-backlog'
+    }
+  | {
+      chainId: number
+      /** Blocks between the observed head and the finalized head. */
+      lagBlocks: number
+      /** Identifies the finality gate's settling distance. */
+      type: 'webhook:scan-finality'
+    }
   | {
       /** Atomic ledger claim outcome. */
       outcome: 'attempting' | 'claimed' | 'missing' | 'scheduled' | 'terminal'
@@ -275,6 +302,9 @@ export function requests(backend: Metrics): RequestSink {
       backend.histogram('funding_quote_provider_duration_ms', attempt.durationMs, tags_attempt)
     }
 
+    if (entry.fundingDepositCountFailed)
+      backend.count('funding_deposit_count_failure_count', 1, tags)
+
     if (entry.fundingTransferCountFailed)
       backend.count('funding_transfer_count_failure_count', 1, tags)
 
@@ -497,6 +527,28 @@ export function webhooks(backend: Metrics): WebhookSink {
           })
           return
         }
+        case 'webhook:scan-block': {
+          const tags = {
+            chain_id: String(event.chainId),
+            origin: event.origin,
+            outcome: event.outcome,
+          }
+          backend.count('webhook_scan_block_count', 1, tags)
+          if (event.matches > 0) backend.count('webhook_scan_match_count', event.matches, tags)
+          return
+        }
+        case 'webhook:scan-backlog': {
+          const tags = { chain_id: String(event.chainId) }
+          backend.gauge('webhook_scan_pending_count', event.pendingCount, tags)
+          backend.gauge('webhook_scan_oldest_pending_age_ms', event.oldestPendingAgeMs ?? 0, tags)
+          return
+        }
+        case 'webhook:scan-finality': {
+          backend.gauge('webhook_scan_finality_lag_blocks', event.lagBlocks, {
+            chain_id: String(event.chainId),
+          })
+          return
+        }
         case 'webhook:delivery-job-claim': {
           backend.count('webhook_delivery_job_claim_count', 1, { outcome: event.outcome })
           return