tapimo 0.10.1 → 0.11.0

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

@@ -10,7 +10,10 @@ import * as Orgs from './orgs.js'
 import * as Webhooks from './webhooks.js'
 
 const origin = 'http://localhost'
-const webhook = { supportedChainIds: [4217, 42431] } satisfies App.Webhook
+const webhook = {
+  applicationEventTypes: ['funding:deposit.updated'],
+  supportedChainIds: [4217, 42431],
+} satisfies App.Webhook
 
 function json(method: 'PATCH' | 'POST', cookie: string, body: unknown) {
   return {
@@ -47,6 +50,81 @@ async function organization(app: ReturnType<typeof createApp>, cookie: string) {
 }
 
 describe('webhooks', () => {
+  test('creates funding deposit subscriptions without reading the RPC head', async () => {
+    const db = TestApp.database()
+    const app = createApp({ db })
+    const cookie = await session(app)
+    const org = await organization(app, cookie)
+    const response = await app.request(
+      `/v1/orgs/${org.id}/webhooks`,
+      json('POST', cookie, {
+        chainId: 4217,
+        destination: { type: 'url', url: 'https://example.com/funding' },
+        environment: 'production',
+        eventType: 'funding:deposit.updated',
+        filters: { status: 'completed' },
+      }),
+    )
+    const created = await TestApp.json(response, Webhooks.schema.createWebhook.Response)
+    const stored = await core_Webhooks.getSubscription(
+      db,
+      { orgId: org.id, type: 'api_key' },
+      created.id,
+    )
+    const listedResponse = await app.request(`/v1/orgs/${org.id}/webhooks`, {
+      headers: { cookie },
+    })
+    const listed = await TestApp.json(listedResponse, Webhooks.schema.ListResponse)
+
+    expect(response.status).toBe(200)
+    expect(created.environment).toBe('production')
+    expect(listed.data[0]?.environment).toBe('production')
+    expect(stored?.environment).toBe('production')
+    expect(await core_Webhooks.getCursor(db, created.id)).toBeNull()
+  })
+
+  test('preserves a production funding environment on testnet', async () => {
+    const db = TestApp.database()
+    const app = createApp({ db })
+    const cookie = await session(app)
+    const org = await organization(app, cookie)
+    const response = await app.request(
+      `/v1/orgs/${org.id}/webhooks`,
+      json('POST', cookie, {
+        chainId: 42431,
+        destination: { type: 'url', url: 'https://example.com/funding-testnet' },
+        environment: 'production',
+        eventType: 'funding:deposit.updated',
+      }),
+    )
+    const created = await TestApp.json(response, Webhooks.schema.createWebhook.Response)
+    const stored = await core_Webhooks.getSubscription(
+      db,
+      { orgId: org.id, type: 'api_key' },
+      created.id,
+    )
+
+    expect(response.status).toBe(200)
+    expect(created.environment).toBe('production')
+    expect(stored?.environment).toBe('production')
+  })
+
+  test('requires an explicit environment for funding deposit subscriptions', async () => {
+    const app = createApp()
+    const cookie = await session(app)
+    const org = await organization(app, cookie)
+    const response = await app.request(
+      `/v1/orgs/${org.id}/webhooks`,
+      json('POST', cookie, {
+        chainId: 4217,
+        destination: { type: 'url', url: 'https://example.com/funding' },
+        eventType: 'funding:deposit.updated',
+      }),
+    )
+
+    expect(response.status).toBe(400)
+  })
+
   test('creates, lists, pauses, and deletes an organization webhook', async () => {
     const db = TestApp.database()
     const app = createApp({ db })

package/src/apps/management/routes/webhooks.ts

@@ -22,13 +22,29 @@ export namespace schema {
 
   /** Schemas for creating an organization webhook. */
   export namespace createWebhook {
+    const Environment = z
+      .enum(['production', 'sandbox'])
+      .check(
+        z.describe('API-key environment whose private funding deposits are delivered.'),
+        z.meta({ examples: ['production'] }),
+      )
+
     /** Organization webhook creation requires an explicit network. */
     export const Body = z
       .intersection(
         webhookSchema.createWebhook.Body,
-        z.object({ chainId: webhookSchema.Subscription.shape.chainId }),
+        z.object({
+          chainId: webhookSchema.Subscription.shape.chainId,
+          environment: z.optional(Environment),
+        }),
+      )
+      .check(
+        z.refine(
+          (body) => body.eventType !== 'funding:deposit.updated' || body.environment !== undefined,
+          { error: '`environment` is required for funding deposit subscriptions.' },
+        ),
+        z.describe('Details for creating an organization webhook subscription.'),
       )
-      .check(z.describe('Details for creating an organization webhook subscription.'))
 
     const secret = webhookSchema.createWebhook.Response.shape.secret
     const urlDestination = z.object({
@@ -181,6 +197,7 @@ export function webhooks(options: webhooks.Options = {}) {
               codes: [
                 'body_invalid',
                 'chain_id_unsupported',
+                'event_type_unsupported',
                 'filters_invalid',
                 'param_invalid',
                 'url_invalid',
@@ -213,6 +230,15 @@ export function webhooks(options: webhooks.Options = {}) {
         if (!options.webhook) return notEnabled(c)
 
         const body = c.req.valid('json')
+        if (
+          body.eventType === 'funding:deposit.updated' &&
+          !options.webhook.applicationEventTypes?.includes(body.eventType)
+        )
+          return Response.error(c, {
+            code: 'event_type_unsupported',
+            message: 'Webhook event type is not available in this deployment',
+            status: 400,
+          })
         const chainId = body.chainId
         const supportedChainIds = new Set(options.webhook.supportedChainIds)
         if (!supportedChainIds.has(chainId))
@@ -225,20 +251,26 @@ export function webhooks(options: webhooks.Options = {}) {
           const owner_ = owner(Auth.org(c).id)
           if ((await Webhooks.countSubscriptions(db, owner_)) >= maxPerOwner)
             throw new Webhooks.LimitExceededError(maxPerOwner)
-          const startBlockNumber = Number(await c.get('getClient')(chainId).getBlockNumber())
+          const startBlockNumber =
+            body.eventType === 'funding:deposit.updated'
+              ? undefined
+              : Number(await c.get('getClient')(chainId).getBlockNumber())
           const subscription = await Webhooks.createSubscription(
             db,
             {
               chainId,
               ...(body.context === undefined ? {} : { context: body.context }),
               destination: body.destination,
+              ...(body.eventType === 'funding:deposit.updated' && body.environment !== undefined
+                ? { environment: body.environment }
+                : {}),
               eventType: body.eventType,
               filters: body.filters,
               owner: owner_,
             },
             {
               maxPerOwner,
-              startBlockNumber,
+              ...(startBlockNumber === undefined ? {} : { startBlockNumber }),
             },
           )
           return c.json(
@@ -609,6 +641,10 @@ function publicSubscription(subscription: Webhooks.Subscription) {
     ...(subscription.context === undefined ? {} : { context: subscription.context }),
     createdAt: subscription.createdAt,
     destination,
+    ...(subscription.eventType === 'funding:deposit.updated' &&
+    subscription.environment !== undefined
+      ? { environment: subscription.environment }
+      : {}),
     eventType: subscription.eventType,
     ...(subscription.expiresAt === undefined ? {} : { expiresAt: subscription.expiresAt }),
     failureCount: subscription.failureCount,

package/src/db/Db.test.ts

@@ -71,11 +71,7 @@ describe('postgres', () => {
       await Organizations.create(tx, { id: 'org_qualified', name: 'Qualified' })
     })
     expect((await Organizations.get(db, 'org_qualified'))?.name).toBe('Qualified')
-    expect(
-      await WebhookSubscriptions.compareAndSetCursors(db, {
-        cursors: [{ cursor: 'next', expectedCursor: null, subscriptionId: 'wh_missing' }],
-      }),
-    ).toEqual(new Set())
+    expect(await WebhookSubscriptions.getCursor(db, 'wh_missing')).toBeNull()
     await db.close()
   })
 

package/src/db/Db.ts

@@ -1362,6 +1362,65 @@ export const migrations: readonly Migration[] = [
         sql`DELETE FROM webhook_queue_events WHERE status = 'pending' AND attempting_at IS NULL AND expires_at <= to_char(now() AT TIME ZONE 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`,
       ),
   },
+  {
+    name: '0123_funding_deposit_addresses_owner_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposit_addresses_owner_list_idx')
+        .ifNotExists()
+        .on('fundingDepositAddresses')
+        .columns(['orgId', 'environment', 'createdAt', 'id']),
+  },
+  {
+    name: '0124_funding_deposit_addresses_project_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposit_addresses_project_list_idx')
+        .ifNotExists()
+        .on('fundingDepositAddresses')
+        .columns(['orgId', 'environment', 'projectId', 'createdAt', 'id']),
+  },
+  {
+    name: '0125_funding_deposits_owner_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposits_owner_list_idx')
+        .ifNotExists()
+        .on('fundingDeposits')
+        .columns(['orgId', 'environment', 'createdAt', 'id']),
+  },
+  {
+    name: '0126_funding_deposits_project_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposits_project_list_idx')
+        .ifNotExists()
+        .on('fundingDeposits')
+        .columns(['orgId', 'environment', 'projectId', 'createdAt', 'id']),
+  },
+  {
+    name: '0127_webhook_subscriptions_environment',
+    up: (db) => raw(db, sql`ALTER TABLE webhook_subscriptions ADD COLUMN IF NOT EXISTS environment text`), // prettier-ignore
+  },
+  {
+    name: '0128_webhook_subscriptions_project',
+    up: (db) => raw(db, sql`ALTER TABLE webhook_subscriptions ADD COLUMN IF NOT EXISTS project_id text`), // prettier-ignore
+  },
+  {
+    name: '0129_webhook_subscriptions_funding_deposit_index',
+    up: (db) =>
+      db.schema
+        .createIndex('webhook_subscriptions_funding_deposit_idx')
+        .ifNotExists()
+        .on('webhookSubscriptions')
+        .columns(['eventType', 'ownerType', 'ownerId', 'environment', 'projectId', 'chainId'])
+        .where(sql.ref('status'), '=', sql.lit('active')),
+  },
+  {
+    name: '0130_webhook_queue_events_observed_at',
+    up: (db) =>
+      raw(db, sql`ALTER TABLE webhook_queue_events ADD COLUMN IF NOT EXISTS observed_at text`),
+  },
 ]
 
 /**

package/src/db/Schema.ts

@@ -792,6 +792,9 @@ export const WebhookSubscription = z.object({
   destination: z
     .custom<Webhooks.Destination>()
     .check(z.describe('Delivery destination (`jsonb`).')),
+  environment: z
+    .nullable(z.enum(['production', 'sandbox']))
+    .check(z.describe('API-key environment for private resource events, or null.')),
   eventType: z
     .custom<Webhooks.EventType>()
     .check(z.describe('Event type the subscription listens to.')),
@@ -820,6 +823,9 @@ export const WebhookSubscription = z.object({
   pollerCursor: z
     .nullable(z.string())
     .check(z.describe('Poller keyset cursor, or null before the first tick.')),
+  projectId: z
+    .nullable(z.string())
+    .check(z.describe('API-key project attribution for private resource events, or null.')),
   secret: z.string().check(z.describe('HMAC signing secret.')),
   status: z.custom<Webhooks.Status>().check(z.describe('Lifecycle status.')),
   updatedAt: z
@@ -896,6 +902,13 @@ export const WebhookQueueEvent = z.object({
   nextAttemptAt: z
     .nullable(z.string())
     .check(z.describe('ISO retry due time, or null when due immediately.')),
+  observedAt: z
+    .nullable(z.string())
+    .check(
+      z.describe(
+        'ISO timestamp the coordinator observed the head owing this event, or null on replays.',
+      ),
+    ),
   status: z
     .enum(['failed', 'pending', 'skipped', 'succeeded'])
     .check(z.describe('Delivery-obligation lifecycle status.')),

package/src/db/tables/fundingDepositAddresses.test.ts

@@ -578,3 +578,31 @@ describe('renewPoll', () => {
     `)
   })
 })
+
+describe('list', () => {
+  test('pages organization addresses and narrows project-attributed owners', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_address_list' } as const
+    const first = await seed({ orgId: listOwner.orgId })
+    const project = await seed({ orgId: listOwner.orgId, projectId: 'prj_address_list' })
+    const sibling = await seed({ orgId: listOwner.orgId, projectId: 'prj_address_sibling' })
+    await seed({ orgId: 'org_address_list_foreign' })
+    await seed({ environment: 'sandbox', orgId: listOwner.orgId })
+
+    const page = await FundingDepositAddresses.list(db, { limit: 2, owner: listOwner })
+    expect(page.map((record) => record.id)).toEqual([sibling.id, project.id])
+    const rest = await FundingDepositAddresses.list(db, {
+      cursor: { createdAt: project.createdAt, id: project.id },
+      limit: 2,
+      owner: listOwner,
+    })
+    expect(rest.map((record) => record.id)).toEqual([first.id])
+    expect(
+      (
+        await FundingDepositAddresses.list(db, {
+          limit: 10,
+          owner: { ...listOwner, projectId: 'prj_address_list' },
+        })
+      ).map((record) => record.id),
+    ).toEqual([project.id])
+  })
+})

package/src/db/tables/fundingDepositAddresses.ts

@@ -148,6 +148,45 @@ export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record |
   return query.executeTakeFirst()
 }
 
+/** Lists owner-visible funding deposit addresses newest-first. */
+export function list(db: Db.Db, options: list.Options): Promise<Record[]> {
+  const { cursor, limit, owner } = options
+  let query = db.kysely
+    .selectFrom('funding_deposit_addresses')
+    .selectAll()
+    .where('environment', '=', owner.environment)
+    .where('orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  if (cursor)
+    query = query.where((eb) =>
+      eb.or([
+        eb('createdAt', '<', cursor.createdAt),
+        eb.and([eb('createdAt', '=', cursor.createdAt), eb('id', '<', cursor.id)]),
+      ]),
+    )
+  return query.orderBy('createdAt', 'desc').orderBy('id', 'desc').limit(limit).execute()
+}
+
+export declare namespace list {
+  /** Ownership and paging options for funding deposit addresses. */
+  type Options = {
+    /** Exclusive lower bound from the previous page. */
+    cursor?: Cursor | undefined
+    /** Maximum rows to return. */
+    limit: number
+    /** Ownership filter derived from the authenticated API key. */
+    owner: Owner
+  }
+
+  /** Cursor fields for the last address returned by the previous page. */
+  type Cursor = {
+    /** Deposit address creation time. */
+    createdAt: string
+    /** Deposit address id, used as a deterministic tie-breaker. */
+    id: string
+  }
+}
+
 /** Gets the reusable address that matches one owner and route identity. */
 export function getMatching(db: Db.Db, match: Match): Promise<Record | undefined> {
   let query = db.kysely

package/src/db/tables/fundingDeposits.test.ts

@@ -498,3 +498,85 @@ describe('toPublic', () => {
     })
   })
 })
+
+describe('list', () => {
+  test('pages organization deposits and narrows project-attributed owners', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_deposit_list' } as const
+    const firstAddress = await seedAddress({ orgId: listOwner.orgId })
+    const projectAddress = await seedAddress({
+      orgId: listOwner.orgId,
+      projectId: 'prj_deposit_list',
+    })
+    const siblingAddress = await seedAddress({
+      orgId: listOwner.orgId,
+      projectId: 'prj_deposit_sibling',
+    })
+    const first = await seedDeposit(firstAddress)
+    const project = await seedDeposit(projectAddress)
+    const sibling = await seedDeposit(siblingAddress)
+    const foreignAddress = await seedAddress({ orgId: 'org_deposit_list_foreign' })
+    await seedDeposit(foreignAddress)
+    const sandboxAddress = await seedAddress({
+      environment: 'sandbox',
+      orgId: listOwner.orgId,
+    })
+    await seedDeposit(sandboxAddress)
+
+    const page = await FundingDeposits.list(db, { limit: 2, owner: listOwner })
+    expect(page.map((record) => record.id)).toEqual([sibling.id, project.id])
+    const rest = await FundingDeposits.list(db, {
+      cursor: { createdAt: project.createdAt, id: project.id },
+      limit: 2,
+      owner: listOwner,
+    })
+    expect(rest.map((record) => record.id)).toEqual([first.id])
+    expect(
+      (
+        await FundingDeposits.list(db, {
+          limit: 10,
+          owner: { ...listOwner, projectId: 'prj_deposit_list' },
+        })
+      ).map((record) => record.id),
+    ).toEqual([project.id])
+  })
+
+  test('AND-combines filters and counts through the same ownership scope', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_deposit_filters' } as const
+    const recipient = `0x${'ab'.repeat(20)}`
+    const address = await seedAddress({
+      orgId: listOwner.orgId,
+      snapshot: TestFunding.depositAddressSnapshot({
+        provider: { id: 'relay_filters', name: 'Relay' },
+        recipient,
+      }),
+    })
+    const match = await seedDeposit(address)
+    const unrelatedAddress = await seedAddress({ orgId: listOwner.orgId })
+    await seedDeposit(unrelatedAddress)
+    const filters = {
+      depositAddress: address.address,
+      destinationTokenKeys: [address.destinationTokenKey],
+      providerId: address.providerId,
+      recipient: recipient.toLowerCase(),
+      sourceChainIds: [address.sourceChainId],
+      sourceTokenKeys: [address.sourceTokenKey],
+      status: 'detected',
+    } as const
+
+    expect(
+      (await FundingDeposits.list(db, { ...filters, limit: 10, owner: listOwner })).map(
+        (record) => record.id,
+      ),
+    ).toEqual([match.id])
+    expect(await FundingDeposits.count(db, { ...filters, cap: 10, owner: listOwner })).toBe(1)
+    expect(await FundingDeposits.count(db, { ...filters, cap: 0, owner: listOwner })).toBe(1)
+    expect(
+      await FundingDeposits.count(db, {
+        ...filters,
+        destinationTokenKeys: [],
+        cap: 10,
+        owner: listOwner,
+      }),
+    ).toBe(0)
+  })
+})

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/db/tables/organizations.test.ts

@@ -363,8 +363,11 @@ describe('deleteOrganization', () => {
     expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
 
     expect(await Webhooks.listSubscriptions(db, deletedOrg)).toEqual([])
-    const active = await Webhooks.listActive(db, 4217, 'token:transfer')
-    expect(active.map(({ id }) => id).sort()).toEqual(
+    const active = await Webhooks.listActiveForChain(db, {
+      chainId: 4217,
+      eventTypes: ['token:transfer'],
+    })
+    expect(active.map(({ subscription }) => subscription.id).sort()).toEqual(
       [keptApiKey.id, keptMppSubscription.id].sort(),
     )
     await db.close()

package/src/db/tables/webhookQueueEvents.ts

@@ -7,7 +7,7 @@ import type * as db_Schema from '../Schema.js'
 /** Columns of the `webhook_queue_events` table, derived from `Schema.WebhookQueueEvent`. */
 export type Table = Omit<
   db_Schema.WebhookQueueEvent,
-  'attemptCount' | 'attemptingAt' | 'nextAttemptAt' | 'status'
+  'attemptCount' | 'attemptingAt' | 'nextAttemptAt' | 'observedAt' | 'status'
 > & {
   /** Delivery attempts claimed so far; database default 0. */
   attemptCount: Generated<number>
@@ -15,6 +15,8 @@ export type Table = Omit<
   attemptingAt: Generated<string | null>
   /** ISO retry due time; database default null (due immediately). */
   nextAttemptAt: Generated<string | null>
+  /** ISO head-observation stamp; database default null (replays carry none). */
+  observedAt: Generated<string | null>
   /** Delivery-obligation lifecycle status; database default `pending`. */
   status: Generated<db_Schema.WebhookQueueEvent['status']>
 }
@@ -65,6 +67,10 @@ export async function ensure(db: Db.Db, rows: readonly Insertable<Table>[]): Pro
           envelope: eb.ref('excluded.envelope'),
           expiresAt: eb.ref('excluded.expiresAt'),
           nextAttemptAt: eb.ref('excluded.nextAttemptAt'),
+          // Refreshed with the rest: a replacement keeping the replaced row's
+          // stamp would measure observation-to-attempt from an observation
+          // that belongs to a delivery made days earlier.
+          observedAt: eb.ref('excluded.observedAt'),
           status: 'pending',
         }))
         .where((eb) =>