tapimo 0.10.0 → 0.10.1

package/src/internal/WebhookTransfer.test.ts

@@ -0,0 +1,89 @@
+import type { Hex } from 'ox'
+
+import * as WebhookTransfer from './WebhookTransfer.js'
+
+const token: Hex.Hex = '0x20c0000000000000000000000000000000000001'
+const sender: Hex.Hex = `0x${'aa'.repeat(20)}`
+const recipient: Hex.Hex = `0x${'bb'.repeat(20)}`
+const other: Hex.Hex = `0x${'cc'.repeat(20)}`
+const transactionHash = `0x${'ef'.repeat(32)}`
+const transferTopic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+const timestamp = '2026-01-01T00:00:00.000Z'
+
+const addressTopic = (address: string) => `0x${'0'.repeat(24)}${address.slice(2)}`
+
+function transferLog(overrides: Record<string, unknown> = {}) {
+  return {
+    address: token,
+    blockNumber: '0x7b',
+    data: `0x${(10n ** 18n).toString(16).padStart(64, '0')}`,
+    logIndex: '0x4',
+    topics: [transferTopic, addressTopic(sender), addressTopic(recipient)],
+    transactionHash,
+    transactionIndex: '0x0',
+    ...overrides,
+  } as never
+}
+
+describe('decode', () => {
+  test('decodes a strict TIP-20 Transfer log', () => {
+    expect(WebhookTransfer.decode(transferLog(), timestamp)).toMatchInlineSnapshot(`
+      {
+        "address": "0x20c0000000000000000000000000000000000001",
+        "amount": "1000000000000000000",
+        "blockNumber": 123,
+        "logIndex": 4,
+        "recipient": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        "sender": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "transactionHash": "0xefefefefefefefefefefefefefefefefefefefefefefefefefefefefefefefef",
+      }
+    `)
+  })
+
+  test('rejects non-TIP-20 addresses and malformed payloads', () => {
+    const cases: readonly Record<string, unknown>[] = [
+      // Outside the deterministic TIP-20 address range.
+      { address: other },
+      // Missing recipient topic.
+      { topics: [transferTopic, addressTopic(sender)] },
+      // Wrong event selector.
+      { topics: [`0x${'12'.repeat(32)}`, addressTopic(sender), addressTopic(recipient)] },
+      // Sender topic without the address left-padding.
+      { topics: [transferTopic, `0x${'ff'.repeat(32)}`, addressTopic(recipient)] },
+      // Amount payload is not one word.
+      { data: '0x01' },
+      // Pending-log positions cannot form a cursor.
+      { blockNumber: null },
+      { logIndex: null },
+    ]
+    for (const overrides of cases)
+      expect(
+        WebhookTransfer.decode(transferLog(overrides), timestamp),
+        JSON.stringify(overrides),
+      ).toBeUndefined()
+  })
+})
+
+describe('matches', () => {
+  const data = WebhookTransfer.decode(transferLog(), timestamp)!
+
+  test('AND-combines side, either-side address, and token filters', () => {
+    const cases: readonly [WebhookTransfer.Filters, boolean][] = [
+      [{}, true],
+      [{ sender }, true],
+      [{ sender: recipient }, false],
+      [{ recipient }, true],
+      [{ recipient: sender }, false],
+      [{ address: sender }, true],
+      [{ address: recipient }, true],
+      [{ address: other }, false],
+      [{ token }, true],
+      [{ token: '0x20c0000000000000000000000000000000000002' }, false],
+      [{ recipient, sender, token }, true],
+      [{ recipient: sender, sender, token }, false],
+    ]
+    for (const [filters, expected] of cases)
+      expect(WebhookTransfer.matches(data, filters), JSON.stringify(filters)).toBe(expected)
+  })
+})

package/src/internal/WebhookTransfer.ts

@@ -18,9 +18,11 @@ const scanChunkBlocks = 8
 const event = parseAbiItem(Transfers.signature)
 const topic = encodeEventTopics({ abi: [event] })[0]
 
-type Filters = z.output<typeof Transfers.schema.Predicates>
+/** Parsed transfer filter predicates. */
+export type Filters = z.output<typeof Transfers.schema.Predicates>
 
-type EventData = {
+/** One decoded TIP-20 Transfer row, as the read endpoint returns it. */
+export type EventData = {
   address: string
   amount: string
   blockNumber: number
@@ -303,7 +305,7 @@ function isTip20Address(address: string): boolean {
 }
 
 /** Decodes one strict TIP-20 Transfer wire payload. */
-function decode(log: RpcLog, timestamp: string): EventData | undefined {
+export function decode(log: RpcLog, timestamp: string): EventData | undefined {
   if (!isTip20Address(log.address)) return undefined
   if (
     log.topics.length !== 3 ||
@@ -343,7 +345,7 @@ function decode(log: RpcLog, timestamp: string): EventData | undefined {
 }
 
 /** Re-checks every transfer filter after RPC topic pushdown. */
-function matches(data: EventData, filters: Filters): boolean {
+export function matches(data: EventData, filters: Filters): boolean {
   if (filters.address && data.sender !== filters.address && data.recipient !== filters.address)
     return false
   if (filters.recipient && data.recipient !== filters.recipient) return false
@@ -389,13 +391,13 @@ async function scanCohort(options: {
     items: [],
     state,
   }))
-  const timestamps = new Map<number, Promise<string>>()
+  const timestamps = new Map<number, Promise<string | undefined>>()
   const timestamp = (blockNumber: number) => {
     const existing = timestamps.get(blockNumber)
     if (existing) return existing
     const pending = client
       .getBlock({ blockNumber: BigInt(blockNumber), includeTransactions: false })
-      .then((block) => new Date(Number(block.timestamp) * 1_000).toISOString())
+      .then((block) => Value.blockToIso(block))
     timestamps.set(blockNumber, pending)
     return pending
   }
@@ -412,7 +414,9 @@ async function scanCohort(options: {
       const blockNumber = Value.hexToNumber(log.blockNumber)
       const logIndex = Value.hexToNumber(log.logIndex)
       if (blockNumber === undefined || logIndex === undefined) continue
-      const data = decode(log, await timestamp(blockNumber))
+      const blockTimestamp = await timestamp(blockNumber)
+      if (blockTimestamp === undefined) continue
+      const data = decode(log, blockTimestamp)
       if (!data) continue
       for (const accumulator of accumulators) {
         if (!canMatch(accumulator, blockNumber, logIndex)) continue

package/src/internal/Webhooks.test.ts

@@ -804,6 +804,25 @@ describe('delivery log', () => {
     `)
   })
 
+  test('deliverAndRecord records envelope serialization failures', async () => {
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    const envelope = {
+      chainId: 4217,
+      createdAt: '2026-01-01T00:00:00.000Z',
+      data: { amount: 1n },
+      id: 'evt_invalid',
+      subscriptionId: created.id,
+      type: 'token:transfer',
+    } satisfies Webhooks.Envelope
+
+    const result = await Webhooks.deliverAndRecord(db, created, envelope, { now: fixedNow })
+
+    expect(result).toEqual({ error: 'delivery failed before request', ok: false })
+    const after = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
+    expect(after?.failureCount).toBe(1)
+  })
+
   test('deliverCurrentAndRecord skips paused and deleted queued subscriptions', async () => {
     const db = TestApp.database()
     const paused = await Webhooks.createSubscription(db, createInput())
@@ -909,6 +928,466 @@ describe('delivery log', () => {
   })
 })
 
+async function stagedObligation(db: ReturnType<typeof TestApp.database>, logIndex = 4) {
+  const subscription = await Webhooks.createSubscription(db, createInput())
+  const envelope = Webhooks.buildEnvelope({
+    blockNumber: 123,
+    createdAt: new Date(),
+    data: { amount: '1' },
+    logIndex,
+    subscription,
+  })
+  const { created, references } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+  return { created, envelope, reference: references[0]!, subscription }
+}
+
+describe('ensureQueueEvents', () => {
+  test('keeps oversized envelopes behind compact idempotent Queue references', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const input = `0x${'ab'.repeat(70_000)}`
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 123,
+      createdAt: fixedNow(),
+      data: { input, meta: { rpc: { input } } },
+      logIndex: 4,
+      subscription,
+    })
+    const dispatchable = { envelope, subscription }
+
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [dispatchable]) // prettier-ignore
+    await Webhooks.ensureQueueEvents(db, [dispatchable])
+
+    expect(
+      new TextEncoder().encode(JSON.stringify({ body: dispatchable })).byteLength,
+    ).toBeGreaterThan(128_000)
+    expect(new TextEncoder().encode(JSON.stringify({ body: reference })).byteLength).toBeLessThan(
+      1_000,
+    )
+    expect((await Webhooks.getQueueEvent(db, reference!))?.envelope).toEqual(envelope)
+  })
+
+  test('delivers a staged oversized envelope from its compact reference', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const input = `0x${'ab'.repeat(70_000)}`
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 123,
+      data: { input, meta: { rpc: { input } } },
+      logIndex: 4,
+      subscription,
+    })
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }]) // prettier-ignore
+    const histograms = new Map<string, number>()
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value) {
+        histograms.set(name, value)
+      },
+    })
+    let deliveredBytes = 0
+    const fetch = (async (_url, init) => {
+      deliveredBytes = new TextEncoder().encode(
+        typeof init?.body === 'string' ? init.body : '',
+      ).byteLength
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await Webhooks.deliverQueueEventAndRecord(db, reference!, {
+      fetch,
+      metrics,
+      queuedAt: Date.now(),
+    })
+
+    expect(result.status).toBe('delivered')
+    expect(deliveredBytes).toBeGreaterThan(128_000)
+    expect(histograms.has('webhook_delivery_processing_ms')).toBe(true)
+    expect(histograms.has('webhook_delivery_queue_wait_ms')).toBe(true)
+    expect(histograms.has('webhook_delivery_subscription_read_ms')).toBe(true)
+  })
+
+  test('skips a staged event after its subscription expires', async () => {
+    vi.useFakeTimers({ now: fixedNow(), toFake: ['Date'] })
+    try {
+      const db = TestApp.database()
+      const subscription = await Webhooks.createSubscription(
+        db,
+        createInput({ eventType: 'transaction:included', owner: mppOwner, ttl: 60_000 }),
+        { now: fixedNow },
+      )
+      const envelope = Webhooks.buildEnvelope({
+        blockNumber: 123,
+        data: {},
+        logIndex: 4,
+        subscription,
+      })
+      const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }]) // prettier-ignore
+
+      vi.setSystemTime(new Date('2026-01-01T00:01:00.000Z'))
+
+      await expect(Webhooks.deliverQueueEventAndRecord(db, reference!)).resolves
+        .toMatchInlineSnapshot(`
+        {
+          "status": "skipped",
+        }
+      `)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('stages once and keeps the first envelope', async () => {
+    const db = TestApp.database()
+    const { created, envelope, reference, subscription } = await stagedObligation(db)
+    const replacement = { ...envelope, data: { amount: '2' } }
+
+    const second = await Webhooks.ensureQueueEvents(db, [{ envelope: replacement, subscription }])
+
+    expect(created).toBe(1)
+    expect(second.created).toBe(0)
+    expect((await Webhooks.getQueueEvent(db, reference))?.envelope).toEqual(envelope)
+  })
+
+  test('never resurrects a terminal obligation', async () => {
+    const db = TestApp.database()
+    const { envelope, reference, subscription } = await stagedObligation(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: claim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    const again = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+    expect(again.created).toBe(0)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      status: 'succeeded',
+      type: 'terminal',
+    })
+    // Terminal rows read as absent, so no consumer path can redeliver them.
+    expect(await Webhooks.getQueueEvent(db, reference)).toBeNull()
+  })
+
+  test('replaces an expired terminal row so replays stay deliverable', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+    try {
+      const db = TestApp.database()
+      const { envelope, reference, subscription } = await stagedObligation(db)
+      const claim = await Webhooks.claimQueueEvent(db, reference)
+      expect(claim.type).toBe('claimed')
+      if (claim.type !== 'claimed') return
+      expect(
+        await Webhooks.completeQueueEvent(db, reference, {
+          claimedAt: claim.record.attemptingAt!,
+          status: 'succeeded',
+        }),
+      ).toBe(true)
+
+      // Past the dedupe window an unpruned terminal row must not suppress a
+      // replay.
+      vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+      const replay = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+      expect(replay.created).toBe(1)
+      await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
+        type: 'claimed',
+      })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('claimQueueEvent', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('claims a due obligation once and reclaims after staleness', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    const first = await Webhooks.claimQueueEvent(db, reference)
+    expect(first.type).toBe('claimed')
+    if (first.type !== 'claimed') return
+    expect(first.record.attemptCount).toBe(1)
+
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      type: 'attempting',
+    })
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 1))
+    const reclaimed = await Webhooks.claimQueueEvent(db, reference)
+    expect(reclaimed.type).toBe('claimed')
+    if (reclaimed.type !== 'claimed') return
+    expect(reclaimed.record.attemptCount).toBe(2)
+  })
+
+  test('classifies missing, scheduled, and terminal obligations', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    await expect(
+      Webhooks.claimQueueEvent(db, { eventId: 'evt_absent', subscriptionId: 'wh_absent' }),
+    ).resolves.toEqual({ type: 'missing' })
+
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, reference, {
+        attemptCount: 1,
+        claimedAt: claim.record.attemptingAt!,
+      }),
+    ).toBe(true)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      nextAttemptAt: new Date(fixedNow().getTime() + Webhooks.retryDelayMs(1)).toISOString(),
+      type: 'scheduled',
+    })
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.retryDelayMs(1) + 1))
+    const retried = await Webhooks.claimQueueEvent(db, reference)
+    expect(retried.type).toBe('claimed')
+    if (retried.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: retried.record.attemptingAt!,
+        status: 'failed',
+      }),
+    ).toBe(true)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      status: 'failed',
+      type: 'terminal',
+    })
+  })
+
+  test('keeps owed work claimable indefinitely', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    // Pending obligations never expire; only terminal transitions stamp a
+    // dedupe deadline.
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs * 3))
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
+      type: 'claimed',
+    })
+  })
+
+  test('never prunes pending work', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+    await Webhooks.pruneExpired(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: claim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+  })
+
+  test('fences a stale claimant after a reclaim', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+    const stale = await Webhooks.claimQueueEvent(db, reference)
+    expect(stale.type).toBe('claimed')
+    if (stale.type !== 'claimed') return
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 1))
+    const current = await Webhooks.claimQueueEvent(db, reference)
+    expect(current.type).toBe('claimed')
+    if (current.type !== 'claimed') return
+
+    const staleClaimedAt = stale.record.attemptingAt!
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: staleClaimedAt,
+        status: 'failed',
+      }),
+    ).toBe(false)
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, reference, {
+        attemptCount: 1,
+        claimedAt: staleClaimedAt,
+      }),
+    ).toBe(false)
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: current.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+  })
+})
+
+describe('retryDelayMs', () => {
+  test('backs off exponentially and caps hourly', () => {
+    expect([1, 2, 3, 4, 5, 6, 10].map(Webhooks.retryDelayMs)).toMatchInlineSnapshot(`
+      [
+        5000,
+        25000,
+        125000,
+        625000,
+        3125000,
+        3600000,
+        3600000,
+      ]
+    `)
+  })
+})
+
+describe('dueQueueEvents', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('lists due pending work and skips in-flight, scheduled, and terminal rows', async () => {
+    const db = TestApp.database()
+    // Distinct staging times so the due order (next_attempt_at) is deterministic.
+    const due = await stagedObligation(db, 1)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 1))
+    const inFlight = await stagedObligation(db, 2)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 2))
+    const scheduled = await stagedObligation(db, 3)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 3))
+    const terminal = await stagedObligation(db, 4)
+
+    expect((await Webhooks.claimQueueEvent(db, inFlight.reference)).type).toBe('claimed')
+    const scheduledClaim = await Webhooks.claimQueueEvent(db, scheduled.reference)
+    expect(scheduledClaim.type).toBe('claimed')
+    if (scheduledClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, scheduled.reference, {
+        attemptCount: 3,
+        claimedAt: scheduledClaim.record.attemptingAt!,
+      }),
+    ).toBe(true)
+    const terminalClaim = await Webhooks.claimQueueEvent(db, terminal.reference)
+    expect(terminalClaim.type).toBe('claimed')
+    if (terminalClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, terminal.reference, {
+        claimedAt: terminalClaim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    await expect(Webhooks.dueQueueEvents(db, 10)).resolves.toEqual([due.reference])
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 10))
+    await expect(Webhooks.dueQueueEvents(db, 10)).resolves.toEqual([
+      due.reference,
+      inFlight.reference,
+    ])
+  })
+})
+
+describe('pendingQueueEvents', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('counts pending obligations and reports the oldest staging time', async () => {
+    const db = TestApp.database()
+    await stagedObligation(db, 1)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 1_000))
+    const done = await stagedObligation(db, 2)
+    const doneClaim = await Webhooks.claimQueueEvent(db, done.reference)
+    expect(doneClaim.type).toBe('claimed')
+    if (doneClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, done.reference, {
+        claimedAt: doneClaim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    await expect(Webhooks.pendingQueueEvents(db)).resolves.toEqual({
+      count: 1,
+      dueCount: 1,
+      oldestAt: fixedNow().toISOString(),
+      oldestDueAt: fixedNow().toISOString(),
+    })
+  })
+
+  test('excludes in-flight claims and scheduled retries from due work', async () => {
+    const db = TestApp.database()
+    const inFlight = await stagedObligation(db, 1)
+    const claim = await Webhooks.claimQueueEvent(db, inFlight.reference)
+    expect(claim.type).toBe('claimed')
+
+    await expect(Webhooks.pendingQueueEvents(db)).resolves.toMatchObject({
+      count: 1,
+      dueCount: 0,
+      oldestDueAt: null,
+    })
+  })
+})
+
+describe('deliverClaimedAndRecord', () => {
+  test('delivers a claimed envelope and skips an inactive subscription', async () => {
+    const db = TestApp.database()
+    const { envelope, reference, subscription } = await stagedObligation(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+
+    let delivered: unknown
+    const fetch = (async (_url, init) => {
+      delivered = JSON.parse(typeof init?.body === 'string' ? init.body : '{}')
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const delivery = await Webhooks.deliverClaimedAndRecord(
+      db,
+      { envelope: claim.record.envelope, subscriptionId: reference.subscriptionId },
+      { fetch },
+    )
+    expect(delivery.status).toBe('delivered')
+    if (delivery.status !== 'delivered') return
+    expect(delivery.result.ok).toBe(true)
+    expect(delivered).toEqual(envelope)
+
+    await Webhooks.deleteSubscription(db, apiKeyOwner, subscription.id)
+    await expect(
+      Webhooks.deliverClaimedAndRecord(db, {
+        envelope: claim.record.envelope,
+        subscriptionId: reference.subscriptionId,
+      }),
+    ).resolves.toEqual({ status: 'skipped' })
+  })
+})
+
 describe('buildPingEnvelope', () => {
   test('builds a synthetic ping envelope with a deterministic id from the nonce', async () => {
     const db = TestApp.database()