tapimo 0.10.1 → 0.11.0

package/src/db/tables/webhookSubscriptions.ts

@@ -1,6 +1,7 @@
 import type { ExpressionBuilder, Selectable } from 'kysely'
 import { sql } from 'kysely'
 
+import * as Scope from '../../Scope.js'
 import type * as Webhooks from '../../internal/Webhooks.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
@@ -40,6 +41,7 @@ export function toSubscription(row: Record): Webhooks.Subscription {
     ...(row.context === null ? {} : { context: row.context }),
     createdAt: row.createdAt,
     destination: row.destination,
+    ...(row.environment === null ? {} : { environment: row.environment }),
     eventType: row.eventType,
     ...(row.expiresAt === null ? {} : { expiresAt: row.expiresAt }),
     failureCount: row.failureCount,
@@ -50,6 +52,7 @@ export function toSubscription(row: Record): Webhooks.Subscription {
       row.ownerType === 'api_key'
         ? { orgId: row.ownerId, type: 'api_key' }
         : { payer: row.ownerId, type: 'mpp' },
+    ...(row.projectId === null ? {} : { projectId: row.projectId }),
     secret: row.secret,
     status: row.status,
     updatedAt: row.updatedAt,
@@ -75,6 +78,7 @@ export async function insert(
       context: subscription.context ?? null,
       createdAt: subscription.createdAt,
       destination: subscription.destination,
+      environment: subscription.environment ?? null,
       eventType: subscription.eventType,
       expiresAt: subscription.expiresAt ?? null,
       failureCount: subscription.failureCount,
@@ -84,6 +88,7 @@ export async function insert(
       ownerId: ownerId(subscription.owner),
       ownerType: subscription.owner.type,
       pollerCursor: options.pollerCursor ?? null,
+      projectId: subscription.projectId ?? null,
       secret: subscription.secret,
       status: subscription.status,
       updatedAt: subscription.updatedAt,
@@ -94,7 +99,7 @@ export async function insert(
 export declare namespace insert {
   /** Options for {@link insert}. */
   type Options = {
-    /** Initial poller cursor committed with the subscription. */
+    /** Initial cursor committed with the subscription. */
     pollerCursor?: string | undefined
   }
 }
@@ -129,7 +134,7 @@ export declare namespace insertWithinLimit {
     maxPerOwner: number
     /** ISO timestamp used to exclude expired rows from the count. */
     now: string
-    /** Initial poller cursor committed with the subscription. */
+    /** Initial cursor committed with the subscription. */
     pollerCursor?: string | undefined
   }
 }
@@ -149,15 +154,17 @@ export async function get(
   owner: Webhooks.Owner,
   id: string,
   now: string,
+  access?: Webhooks.Access,
 ): Promise<Webhooks.Subscription | null> {
-  const row = await db.kysely
+  let query = db.kysely
     .selectFrom('webhook_subscriptions')
     .selectAll()
     .where('id', '=', id)
     .where('ownerType', '=', owner.type)
     .where('ownerId', '=', ownerId(owner))
     .where(live(now))
-    .executeTakeFirst()
+  if (access) query = query.where(privateResourceAccess(access))
+  const row = await query.executeTakeFirst()
   return row ? toSubscription(row) : null
 }
 
@@ -183,6 +190,7 @@ export async function list(
     .where('ownerId', '=', ownerId(owner))
     .where(live(options.now))
     .orderBy('id', 'desc')
+  if (options.access) query = query.where(privateResourceAccess(options.access))
   if (options.cursor) query = query.where('id', '<', options.cursor)
   if (options.offset) query = query.offset(options.offset)
   if (options.limit !== undefined) query = query.limit(options.limit)
@@ -192,6 +200,8 @@ export async function list(
 export declare namespace list {
   /** Options for {@link list}. */
   type Options = {
+    /** Private-resource visibility scope. */
+    access?: Webhooks.Access | undefined
     /** Return subscriptions older than this id (keyset paging, newest first). */
     cursor?: string | undefined
     /** Maximum subscriptions to return. */
@@ -211,14 +221,20 @@ export declare namespace list {
  * @param now - ISO timestamp expiry is evaluated against.
  * @returns The count.
  */
-export async function count(db: Db.Db, owner: Webhooks.Owner, now: string): Promise<number> {
-  const row = await db.kysely
+export async function count(
+  db: Db.Db,
+  owner: Webhooks.Owner,
+  now: string,
+  access?: Webhooks.Access,
+): Promise<number> {
+  let query = db.kysely
     .selectFrom('webhook_subscriptions')
     .select((eb) => eb.fn.countAll().as('count'))
     .where('ownerType', '=', owner.type)
     .where('ownerId', '=', ownerId(owner))
     .where(live(now))
-    .executeTakeFirstOrThrow()
+  if (access) query = query.where(privateResourceAccess(access))
+  const row = await query.executeTakeFirstOrThrow()
   return Number(row.count)
 }
 
@@ -275,21 +291,42 @@ export async function remove(
   owner: Webhooks.Owner,
   id: string,
   now: string,
+  access?: Webhooks.Access,
 ): Promise<boolean> {
-  const result = await db.kysely
+  let query = db.kysely
     .deleteFrom('webhook_subscriptions')
     .where('id', '=', id)
     .where('ownerType', '=', owner.type)
     .where('ownerId', '=', ownerId(owner))
     .where(live(now))
-    .executeTakeFirst()
+  if (access) query = query.where(privateResourceAccess(access))
+  const result = await query.executeTakeFirst()
   return result.numDeletedRows > 0n
 }
 
+function privateResourceAccess(access: Webhooks.Access) {
+  const fundingRead = access.scopes.some(
+    (scope) => scope === Scope.wildcard || scope === 'funding:read',
+  )
+  return (eb: ExpressionBuilder<Db.Database, 'webhook_subscriptions'>) =>
+    eb.or([
+      eb('eventType', '!=', 'funding:deposit.updated'),
+      ...(fundingRead
+        ? [
+            eb.and([
+              eb('eventType', '=', 'funding:deposit.updated'),
+              eb('environment', '=', access.environment),
+              ...(access.projectId === undefined ? [] : [eb('projectId', '=', access.projectId)]),
+            ]),
+          ]
+        : []),
+    ])
+}
+
 /**
- * Lists live `active` subscriptions for a `(chainId, eventType)` stream — the
- * poller's per-stream lookup, served by the partial status index. Each row
- * carries its poller cursor so the poller avoids a per-subscription read.
+ * Lists live `active` subscriptions for a `(chainId, eventType)` stream,
+ * served by the partial status index. Each row carries its cursor so callers
+ * avoid a per-subscription read.
  *
  * @param db - The database.
  * @param chainId - Chain the stream belongs to.
@@ -316,8 +353,8 @@ export async function listActive(
 }
 
 /**
- * Lists every live `active` subscription on a chain in one read. The poller
- * groups the rows by event type so empty streams cost no extra database reads.
+ * Lists every live `active` subscription on a chain in one read. Callers
+ * group the rows by event type so empty streams cost no extra database reads.
  *
  * @param db - The database.
  * @param options - Chain, configured event types, and expiry time.
@@ -342,43 +379,58 @@ export async function listActiveForChain(
 }
 
 export declare namespace listActiveForChain {
-  /** Filters for the poller's chain-level subscription read. */
+  /** Filters for the chain-level subscription read. */
   type Options = {
     /** Chain whose subscriptions to read. */
     chainId: number
-    /** Event types configured for this poller tick. */
+    /** Event types eligible for the read. */
     eventTypes: readonly Webhooks.EventType[]
     /** ISO timestamp expiry is evaluated against. */
     now: string
   }
 }
 
-/**
- * Reads the poller cursors of every live `active` subscription on a chain,
- * across event types. Feeds the cron's cursor-freshness fallback gate.
- *
- * @param db - The database.
- * @param chainId - Chain whose cursors to read.
- * @param now - ISO timestamp expiry is evaluated against.
- * @returns The non-null cursors, unordered.
- */
-export async function listActiveCursors(
+/** Lists live funding deposit subscriptions visible to one deposit owner. */
+export async function listActiveForFundingDeposit(
   db: Db.Db,
-  chainId: number,
-  now: string,
-): Promise<string[]> {
-  const rows = await db.kysely
+  options: listActiveForFundingDeposit.Options,
+): Promise<Webhooks.Subscription[]> {
+  let query = db.kysely
     .selectFrom('webhook_subscriptions')
-    .select('pollerCursor')
-    .where('chainId', '=', chainId)
+    .selectAll()
+    .where('chainId', '=', options.chainId)
+    .where('environment', '=', options.environment)
+    .where('eventType', '=', 'funding:deposit.updated')
+    .where('ownerId', '=', options.orgId)
+    .where('ownerType', '=', 'api_key')
     .where('status', '=', 'active')
-    .where(live(now))
-    .execute()
-  return rows.flatMap((row) => (row.pollerCursor === null ? [] : [row.pollerCursor]))
+    .where(live(options.now))
+  const projectId = options.projectId
+  query =
+    projectId === undefined
+      ? query.where('projectId', 'is', null)
+      : query.where((eb) => eb.or([eb('projectId', 'is', null), eb('projectId', '=', projectId)]))
+  return (await query.orderBy('id').execute()).map(toSubscription)
+}
+
+export declare namespace listActiveForFundingDeposit {
+  /** Ownership scope and chain for a funding deposit event. */
+  type Options = {
+    /** Destination Tempo chain id. */
+    chainId: number
+    /** Deposit API-key environment. */
+    environment: 'production' | 'sandbox'
+    /** ISO timestamp used to exclude expired subscriptions. */
+    now: string
+    /** Owning organization id. */
+    orgId: string
+    /** Attributed deposit project, when present. */
+    projectId?: string | undefined
+  }
 }
 
 /**
- * Reads a subscription's poller cursor.
+ * Reads a subscription's keyset cursor.
  *
  * @param db - The database.
  * @param id - The subscription id (`wh_…`).
@@ -393,107 +445,6 @@ export async function getCursor(db: Db.Db, id: string): Promise<string | null> {
   return row?.pollerCursor ?? null
 }
 
-/**
- * Writes a subscription's poller cursor. Deliberately does not touch
- * `updatedAt` — the cursor advances every tick and is not a user mutation.
- *
- * @param db - The database.
- * @param id - The subscription id (`wh_…`).
- * @param cursor - The keyset cursor to store.
- */
-export async function setCursor(db: Db.Db, id: string, cursor: string): Promise<void> {
-  await db.kysely
-    .updateTable('webhook_subscriptions')
-    .set({ pollerCursor: cursor })
-    .where('id', '=', id)
-    .execute()
-}
-
-/**
- * Writes a poller cursor only when the stored cursor still matches the caller's
- * observed value.
- *
- * @param db - The database.
- * @param options - Subscription, expected cursor, and next cursor.
- * @returns Whether the cursor was updated.
- */
-export async function compareAndSetCursor(
-  db: Db.Db,
-  options: compareAndSetCursor.Options,
-): Promise<boolean> {
-  let query = db.kysely
-    .updateTable('webhook_subscriptions')
-    .set({ pollerCursor: options.cursor })
-    .where('id', '=', options.subscriptionId)
-  query =
-    options.expectedCursor === null
-      ? query.where('pollerCursor', 'is', null)
-      : query.where('pollerCursor', '=', options.expectedCursor)
-  const result = await query.executeTakeFirst()
-  return result.numUpdatedRows > 0n
-}
-
-export declare namespace compareAndSetCursor {
-  /** Options for {@link compareAndSetCursor}. */
-  type Options = {
-    /** Next keyset cursor. */
-    cursor: string
-    /** Cursor observed before scanning, or null for an uninitialized subscription. */
-    expectedCursor: string | null
-    /** Subscription whose cursor advances. */
-    subscriptionId: string
-  }
-}
-
-/**
- * Writes multiple poller cursors when each stored value still matches the
- * caller's observed value.
- *
- * @param db - The database.
- * @param options - Candidate cursor writes.
- * @returns Subscription ids whose cursors were updated.
- */
-export async function compareAndSetCursors(
-  db: Db.Db,
-  options: compareAndSetCursors.Options,
-): Promise<Set<string>> {
-  if (options.cursors.length === 0) return new Set()
-  const values = JSON.stringify(options.cursors)
-  type Candidate = {
-    cursor: string
-    expectedCursor: string | null
-    subscriptionId: string
-  }
-  const result = await db.kysely
-    .with(
-      'candidates',
-      () => sql<Candidate>`(
-      SELECT
-        candidate."subscriptionId" AS subscription_id,
-        candidate."expectedCursor" AS expected_cursor,
-        candidate.cursor
-      FROM jsonb_to_recordset(${values}::jsonb)
-        AS candidate("subscriptionId" text, "expectedCursor" text, cursor text)
-    )`,
-    )
-    .updateTable('webhook_subscriptions as subscription')
-    .from('candidates as candidate')
-    .set((eb) => ({ pollerCursor: eb.ref('candidate.cursor') }))
-    .whereRef('subscription.id', '=', 'candidate.subscriptionId')
-    .whereRef('subscription.pollerCursor', 'is not distinct from', 'candidate.expectedCursor')
-    .returning('subscription.id as subscriptionId')
-    .execute()
-  return new Set(result.map((row) => row.subscriptionId))
-}
-
-export declare namespace compareAndSetCursors {
-  /** Options for {@link compareAndSetCursors}. */
-  type Options = {
-    /** Candidate cursor writes. */
-    cursors: readonly compareAndSetCursor.Options[]
-  }
-}
-
 /**
  * Records a successful delivery: resets the consecutive-failure counter and
  * stamps `lastDeliveryAt`.
@@ -549,7 +500,7 @@ export async function recordFailure(
 
 /**
  * Deletes expired subscriptions (their delivery rows cascade). Called
- * best-effort from the poller tick.
+ * best-effort on a schedule.
  *
  * @param db - The database.
  * @param now - ISO timestamp expiry is evaluated against.

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",