tapimo 0.15.1 → 0.18.0

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

@@ -1,14 +1,14 @@
 import { nanoid } from 'nanoid'
 
+import * as TestApp from '../../../test/App.js'
 import * as Runtime from '../../../test/runtime.js'
 import * as Db from '../Db.js'
+import * as ApiKeyOwnerTombstones from './apiKeyOwnerTombstones.js'
 import * as Organizations from './organizations.js'
 import * as Projects from './projects.js'
 import * as SponsorshipAttributions from './sponsorshipAttributions.js'
 import * as SponsoredTransactions from './sponsoredTransactions.js'
 
-const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
-
 /** Baseline insert input; tests override per case. */
 const input = {
   apiKeyId: 'key_1',
@@ -33,9 +33,22 @@ function redact(record: SponsoredTransactions.Record) {
 }
 
 describe('upsert', () => {
+  test('behavior: a deleted organization cannot reopen a non-billable commitment', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: input.orgId, name: 'One' })
+    const row = await SponsoredTransactions.upsert(db, { ...input, billable: false })
+    await SponsoredTransactions.fail(db, row.id, new Date().toISOString())
+    await db.transaction((tx) => ApiKeyOwnerTombstones.markDeleted(tx, { orgId: input.orgId }))
+
+    await expect(SponsoredTransactions.upsert(db, input)).rejects.toThrow(
+      SponsoredTransactions.OrganizationDeletedError,
+    )
+    expect((await SponsoredTransactions.get(db, row.id))?.status).toMatchInlineSnapshot(`"failed"`)
+    await db.close()
+  })
+
   test('behavior: records a pending sponsorship with a generated id', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, input)
     expect(record.id).toMatch(/^stx_/)
     expect(redact(record)).toMatchInlineSnapshot(`
@@ -52,6 +65,8 @@ describe('upsert', () => {
         "finalizationAttemptedAt": null,
         "finalizedAt": null,
         "id": "stx_<id>",
+        "meterEventFirstAttemptedAt": null,
+        "meterReportAttemptedAt": null,
         "meterReportedAt": null,
         "orgId": "org_1",
         "projectId": "prj_1",
@@ -60,6 +75,7 @@ describe('upsert', () => {
         "status": "pending",
         "transaction": "0x76cccccccccccccccccccccccccccccccc",
         "transactionHash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "transactionHashReconciled": false,
       }
     `)
     expect(await SponsoredTransactions.get(db, record.id)).toStrictEqual(record)
@@ -67,8 +83,7 @@ describe('upsert', () => {
   })
 
   test('behavior: records organization-level sponsorship without a project', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { projectId: _, ...organization } = input
     const record = await SponsoredTransactions.upsert(db, organization)
 
@@ -78,16 +93,14 @@ describe('upsert', () => {
   })
 
   test('behavior: preserves an explicit fee token', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, { ...input, feeToken: `0x${'fe'.repeat(20)}` }) // prettier-ignore
     expect(record.feeToken).toMatchInlineSnapshot(`"0xfefefefefefefefefefefefefefefefefefefefe"`)
     await db.close()
   })
 
   test('behavior: records fill intents without a transaction hash', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const record = await SponsoredTransactions.upsert(db, intent)
     expect(record.transactionHash).toBeNull()
@@ -96,8 +109,7 @@ describe('upsert', () => {
   })
 
   test('behavior: a raw submission upgrades a fill intent in place', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const first = await SponsoredTransactions.upsert(db, intent)
     const second = await SponsoredTransactions.upsert(db, input)
@@ -112,8 +124,7 @@ describe('upsert', () => {
   })
 
   test('behavior: rejects a sign payload already attributed to another org', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const first = await SponsoredTransactions.upsert(db, input)
 
     await expect(
@@ -129,8 +140,7 @@ describe('upsert', () => {
   })
 
   test('behavior: rejects a sign payload already attributed to another project', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const first = await SponsoredTransactions.upsert(db, intent)
 
@@ -143,8 +153,7 @@ describe('upsert', () => {
   })
 
   test('behavior: a raw submission reopens a failed fill intent', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const first = await SponsoredTransactions.upsert(db, intent)
     await SponsoredTransactions.fail(db, first.id, '2026-01-01T00:00:00.000Z')
@@ -162,8 +171,7 @@ describe('upsert', () => {
   })
 
   test('behavior: a duplicate intent never clears a known hash', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const first = await SponsoredTransactions.upsert(db, input)
     const { transactionHash: _, ...intent } = input
     const second = await SponsoredTransactions.upsert(db, intent)
@@ -174,12 +182,50 @@ describe('upsert', () => {
     )
     await db.close()
   })
+
+  test('behavior: a raw retry never replaces a reconciled hash', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    const reconciledHash = `0x${'ab'.repeat(32)}`
+    await SponsoredTransactions.assignTransactionHash(db, record.id, reconciledHash)
+
+    const pending = await SponsoredTransactions.upsert(db, input)
+    expect(pending.transactionHash).toBe(reconciledHash)
+    expect(pending.transactionHashReconciled).toBe(true)
+    await SponsoredTransactions.finalize(db, record.id, {
+      feeAmount: '1',
+      finalizedAt: new Date().toISOString(),
+      transactionHash: reconciledHash,
+    })
+
+    expect((await SponsoredTransactions.upsert(db, input)).transactionHash).toBe(reconciledHash)
+    await db.close()
+  })
+
+  test('behavior: a raw retry never replaces a legacy finalized hash', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    await SponsoredTransactions.finalize(db, record.id, {
+      feeAmount: '1',
+      finalizedAt: new Date().toISOString(),
+    })
+
+    const retried = await SponsoredTransactions.upsert(db, {
+      ...input,
+      transactionHash: `0x${'ab'.repeat(32)}`,
+    })
+    expect(retried).toMatchObject({
+      status: 'finalized',
+      transactionHash: input.transactionHash,
+      transactionHashReconciled: false,
+    })
+    await db.close()
+  })
 })
 
 describe('listPending', () => {
   test('behavior: returns only pending rows, capped by limit', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await SponsoredTransactions.upsert(db, { ...input, signPayload: `0x${'b1'.repeat(32)}`, transactionHash: `0x${'a1'.repeat(32)}` }) // prettier-ignore
     const second = await SponsoredTransactions.upsert(db, { ...input, signPayload: `0x${'b2'.repeat(32)}`, transactionHash: `0x${'a2'.repeat(32)}` }) // prettier-ignore
     await SponsoredTransactions.upsert(db, { ...input, signPayload: `0x${'b3'.repeat(32)}`, transactionHash: `0x${'a3'.repeat(32)}` }) // prettier-ignore
@@ -204,8 +250,7 @@ describe('listPending', () => {
 
 describe('claimPending', () => {
   test('behavior: rotates through a bounded backlog before retrying rows', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     for (let index = 1; index <= 5; index++)
       await SponsoredTransactions.upsert(db, {
         ...input,
@@ -234,10 +279,9 @@ describe('claimPending', () => {
   })
 })
 
-describe('listIntents', () => {
-  test('behavior: returns active hash-less intents without failed rows', async () => {
-    const db = create()
-    await db.migrate()
+describe('listReconciliationCandidates', () => {
+  test('behavior: returns pending sponsorships without failed rows', async () => {
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const failed = await SponsoredTransactions.upsert(db, intent)
     await SponsoredTransactions.fail(db, failed.id, new Date().toISOString())
@@ -245,18 +289,33 @@ describe('listIntents', () => {
       ...intent,
       signPayload: `0x${'bc'.repeat(32)}`,
     })
+    const submitted = await SponsoredTransactions.upsert(db, {
+      ...input,
+      signPayload: `0x${'bd'.repeat(32)}`,
+    })
+    const confirmed = await SponsoredTransactions.upsert(db, {
+      ...input,
+      signPayload: `0x${'be'.repeat(32)}`,
+    })
+    await SponsoredTransactions.assignTransactionHash(db, confirmed.id, input.transactionHash)
 
-    expect((await SponsoredTransactions.listIntents(db)).map((record) => record.id)).toStrictEqual([
-      pending.id,
-    ])
+    expect(
+      (await SponsoredTransactions.listReconciliationCandidates(db))
+        .map((record) => record.id)
+        .sort(),
+    ).toStrictEqual([pending.id, submitted.id].sort())
+    expect(
+      (await SponsoredTransactions.listReconciliationCandidates(db, { limit: 1 })).map(
+        (record) => record.transactionHash === null,
+      ),
+    ).toStrictEqual([true, false])
     await db.close()
   })
 })
 
 describe('listRecoveryWindows', () => {
   test('behavior: returns each chain with its oldest eligible failed intent', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00.000Z') })
     try {
@@ -293,12 +352,24 @@ describe('listRecoveryWindows', () => {
       await db.close()
     }
   })
+
+  test('behavior: includes recently failed sponsorships with recorded hashes', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    await SponsoredTransactions.fail(db, record.id, '2026-01-02T00:00:00.000Z')
+
+    expect(
+      await SponsoredTransactions.listRecoveryWindows(db, {
+        failedSince: '2026-01-01T12:00:00.000Z',
+      }),
+    ).toMatchObject([{ chainId: input.chainId }])
+    await db.close()
+  })
 })
 
 describe('listRecoverableIntents', () => {
   test('behavior: returns pending and eligible failed intents matching candidate payloads', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const pending = await SponsoredTransactions.upsert(db, {
       ...intent,
@@ -324,12 +395,25 @@ describe('listRecoverableIntents', () => {
     ).toStrictEqual([eligible.id, pending.id].sort())
     await db.close()
   })
+
+  test('behavior: returns eligible failed sponsorships with recorded hashes', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    await SponsoredTransactions.fail(db, record.id, '2026-01-02T00:00:00.000Z')
+
+    expect(
+      await SponsoredTransactions.listRecoverableIntents(db, {
+        failedSince: '2026-01-01T12:00:00.000Z',
+        signPayloads: [record.signPayload],
+      }),
+    ).toMatchObject([{ id: record.id, transactionHash: input.transactionHash }])
+    await db.close()
+  })
 })
 
 describe('assignTransactionHash', () => {
   test('behavior: reopens a failed intent when reconciliation finds its hash', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...intent } = input
     const record = await SponsoredTransactions.upsert(db, intent)
@@ -346,9 +430,24 @@ describe('assignTransactionHash', () => {
     await db.close()
   })
 
+  test('behavior: reopens a failed sponsorship under its mined replacement hash', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const record = await SponsoredTransactions.upsert(db, input)
+    await SponsoredTransactions.fail(db, record.id, new Date().toISOString())
+    const replacementHash = `0x${'ab'.repeat(32)}`
+
+    await SponsoredTransactions.assignTransactionHash(db, record.id, replacementHash)
+
+    expect(await SponsoredTransactions.get(db, record.id)).toMatchObject({
+      status: 'pending',
+      transactionHash: replacementHash,
+    })
+    await db.close()
+  })
+
   test('behavior: does not reopen failed intents after the recovery window', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...intent } = input
     const record = await SponsoredTransactions.upsert(db, intent)
@@ -367,8 +466,7 @@ describe('assignTransactionHash', () => {
   })
 
   test('behavior: does not reopen failed intents for deleted orgs', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const { transactionHash: _, ...intent } = input
     const record = await SponsoredTransactions.upsert(db, intent)
     await SponsoredTransactions.fail(db, record.id, new Date().toISOString())
@@ -382,8 +480,7 @@ describe('assignTransactionHash', () => {
   })
 
   test('behavior: keeps an over-limit failed intent retryable across a period rollover', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...intent } = input
     vi.useFakeTimers({ now: new Date('2026-01-31T23:59:00.000Z') })
@@ -427,8 +524,7 @@ describe('assignTransactionHash', () => {
 
 describe('finalize', () => {
   test('behavior: transitions pending → finalized with the actual fee', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, input)
     await SponsoredTransactions.finalize(db, record.id, {
       feeAmount: '21000',
@@ -441,9 +537,58 @@ describe('finalize', () => {
     await db.close()
   })
 
+  test('behavior: stale finalization cannot settle or fail a reconciled hash', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    const reconciledHash = `0x${'ab'.repeat(32)}`
+    await SponsoredTransactions.assignTransactionHash(db, record.id, reconciledHash)
+
+    await SponsoredTransactions.finalize(db, record.id, {
+      feeAmount: '1',
+      finalizedAt: new Date().toISOString(),
+      transactionHash: input.transactionHash,
+    })
+    await SponsoredTransactions.fail(db, record.id, new Date().toISOString(), {
+      transactionHash: input.transactionHash,
+    })
+    expect(await SponsoredTransactions.get(db, record.id)).toMatchObject({
+      status: 'pending',
+      transactionHash: reconciledHash,
+      transactionHashReconciled: true,
+    })
+
+    await SponsoredTransactions.finalize(db, record.id, {
+      feeAmount: '1',
+      finalizedAt: new Date().toISOString(),
+      transactionHash: reconciledHash,
+    })
+    expect((await SponsoredTransactions.get(db, record.id))?.status).toBe('finalized')
+    await db.close()
+  })
+
+  test('behavior: a receipt-fenced finalization preserves its hash against raw retries', async () => {
+    const db = TestApp.database()
+    const record = await SponsoredTransactions.upsert(db, input)
+    await SponsoredTransactions.finalize(db, record.id, {
+      feeAmount: '1',
+      finalizedAt: new Date().toISOString(),
+      transactionHash: input.transactionHash,
+    })
+
+    const retried = await SponsoredTransactions.upsert(db, {
+      ...input,
+      transactionHash: `0x${'ab'.repeat(32)}`,
+    })
+    expect(retried).toMatchObject({
+      status: 'finalized',
+      transactionHash: input.transactionHash,
+      transactionHashReconciled: true,
+    })
+    await db.close()
+  })
+
   test('behavior: no-op on rows that are no longer pending', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, input)
     await SponsoredTransactions.fail(db, record.id, '2026-01-01T00:00:00.000Z')
     await SponsoredTransactions.finalize(db, record.id, {
@@ -459,8 +604,7 @@ describe('finalize', () => {
 
 describe('fail', () => {
   test('behavior: transitions pending → failed without a fee', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, input)
     await SponsoredTransactions.fail(db, record.id, '2026-01-01T00:00:00.000Z')
     const failed = await SponsoredTransactions.get(db, record.id)
@@ -473,7 +617,7 @@ describe('fail', () => {
 
 describe('migration 0032', () => {
   test('behavior: rescales legacy attodollar fee amounts idempotently', async () => {
-    const db = create()
+    const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
     await db.migrate()
     // A pre-scaling row stored raw attodollars: 2.1e18 + 1, non-divisible so
     // the rescale must round up.
@@ -502,8 +646,7 @@ describe('migration 0032', () => {
 
 describe('spend', () => {
   test('behavior: sums finalized fees plus pending caps within scope', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const chainIds = [input.chainId]
     // Finalized in scope: counts its actual fee, never its cap.
     const finalized = await SponsoredTransactions.upsert(db, { ...input, feeMax: '900000', signPayload: `0x${'01'.repeat(32)}` }) // prettier-ignore
@@ -529,8 +672,7 @@ describe('spend', () => {
   })
 
   test('behavior: rows created before the window start are out of scope', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await SponsoredTransactions.upsert(db, { ...input, feeMax: '250000', signPayload: `0x${'08'.repeat(32)}` }) // prettier-ignore
     const future = new Date(Date.now() + 60_000).toISOString()
     expect(await SponsoredTransactions.spend(db, { chainIds: [input.chainId], orgId: 'org_1', since: future })).toBe(0n) // prettier-ignore
@@ -538,8 +680,7 @@ describe('spend', () => {
   })
 
   test('behavior: promotional spend is isolated by project', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await SponsoredTransactions.upsert(db, {
       ...input,
       billable: false,
@@ -570,8 +711,7 @@ describe('spend', () => {
 
 describe('reserve', () => {
   test('behavior: enforces promotional limits independently per project', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const limit = {
       billable: false,
       chainIds: [input.chainId],
@@ -627,8 +767,7 @@ describe('reservePromotion', () => {
   }
 
   test('behavior: atomically records the first sponsorship and immutable window', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, '0.000001')
     const project = await Projects.create(db, { name: 'App', orgId: 'org_1' })
     const attribution = await SponsorshipAttributions.resolveProject(db, {
@@ -668,8 +807,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: records an uncapped promotion', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, null)
     const project = await Projects.create(db, { name: 'App', orgId: 'org_1' })
     const attribution = await SponsorshipAttributions.resolveProject(db, {
@@ -720,8 +858,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: reads the current organization policy when activating', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, '0.000001')
     const project = await Projects.create(db, { name: 'App', orgId: 'org_1' })
     const attribution = await SponsorshipAttributions.resolveProject(db, {
@@ -756,8 +893,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: conflicting envelopes do not activate another project', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, null)
     const first = await Projects.create(db, { name: 'First', orgId: 'org_1' })
     const second = await Projects.create(db, { name: 'Second', orgId: 'org_1' })
@@ -790,8 +926,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: policy changes preserve unattributed retry snapshots', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, null)
     const existing = await SponsoredTransactions.upsert(db, { ...input, billable: true })
     const attribution = await SponsorshipAttributions.resolveExternal(db, {
@@ -826,8 +961,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: later policy changes cannot raise an activated project cap', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, '0.000001')
     const project = await Projects.create(db, { name: 'App', orgId: 'org_1' })
     const attribution = await SponsorshipAttributions.resolveProject(db, {
@@ -873,8 +1007,7 @@ describe('reservePromotion', () => {
   })
 
   test('behavior: preserves activation when the first sponsorship exceeds the cap', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     await configure(db, '0')
     const project = await Projects.create(db, { name: 'App', orgId: 'org_1' })
     const attribution = await SponsorshipAttributions.resolveProject(db, {
@@ -950,8 +1083,7 @@ describe('reservePromotion', () => {
 
 describe('listUnreported', () => {
   test('behavior: lists finalized billable in-scope rows, oldest first', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const chainIds = [input.chainId]
     const first = await SponsoredTransactions.upsert(db, { ...input, signPayload: `0x${'11'.repeat(32)}` }) // prettier-ignore
     await SponsoredTransactions.finalize(db, first.id, { feeAmount: '100', finalizedAt: '2026-01-01T00:00:00.000Z' }) // prettier-ignore
@@ -980,10 +1112,98 @@ describe('listUnreported', () => {
   })
 })
 
+describe('claimUnreported', () => {
+  test('reserves retry capacity while untouched sponsorships keep progressing', async () => {
+    const db = TestApp.database()
+    const rows = []
+    for (const [seed, day] of [
+      ['31', 1],
+      ['32', 2],
+      ['33', 3],
+      ['34', 4],
+    ] as const) {
+      const row = await SponsoredTransactions.upsert(db, {
+        ...input,
+        signPayload: `0x${seed.repeat(32)}`,
+      })
+      await SponsoredTransactions.finalize(db, row.id, {
+        feeAmount: '100',
+        finalizedAt: `2026-01-0${day}T00:00:00.000Z`,
+      })
+      rows.push(row)
+    }
+    await SponsoredTransactions.beginMeterEvent(db, rows[0]!.id, '2026-01-02T00:00:00.000Z')
+
+    const first = await SponsoredTransactions.claimUnreported(db, {
+      attemptedAt: '2026-01-03T00:00:00.000Z',
+      limit: 2,
+    })
+    expect(first.map((row) => row.id)).toStrictEqual([rows[0]!.id, rows[1]!.id])
+    const second = await SponsoredTransactions.claimUnreported(db, {
+      attemptedAt: '2026-01-04T00:00:00.000Z',
+      limit: 2,
+    })
+    expect(second.map((row) => row.id)).toStrictEqual([rows[0]!.id, rows[2]!.id])
+    await db.close()
+  })
+
+  test('rotates failed claims behind untouched rows across historical chains', async () => {
+    const db = TestApp.database()
+    const rows = []
+    for (const [seed, chainId, finalizedAt] of [
+      ['21', input.chainId, '2026-01-01T00:00:00.000Z'],
+      ['22', 421700099, '2026-01-02T00:00:00.000Z'],
+      ['23', input.chainId, '2026-01-03T00:00:00.000Z'],
+    ] as const) {
+      const row = await SponsoredTransactions.upsert(db, {
+        ...input,
+        chainId,
+        signPayload: `0x${seed.repeat(32)}`,
+      })
+      await SponsoredTransactions.finalize(db, row.id, { feeAmount: '100', finalizedAt })
+      rows.push(row)
+    }
+
+    for (const [day, expected] of [
+      [4, rows[0]],
+      [5, rows[1]],
+      [6, rows[2]],
+      [7, rows[0]],
+    ] as const) {
+      const attemptedAt = `2026-01-0${day}T00:00:00.000Z`
+      const claimed = await SponsoredTransactions.claimUnreported(db, { attemptedAt, limit: 1 })
+      expect(claimed.map((row) => row.id)).toStrictEqual([expected!.id])
+      expect(claimed[0]?.meterReportAttemptedAt).toBe(attemptedAt)
+    }
+
+    await SponsoredTransactions.markReported(db, rows[0]!.id, '2026-01-08T00:00:00.000Z')
+    const remaining = await SponsoredTransactions.claimUnreported(db, {
+      attemptedAt: '2026-01-08T00:00:00.000Z',
+      limit: 1,
+    })
+    expect(remaining.map((row) => row.id)).toStrictEqual([rows[1]!.id])
+    await db.close()
+  })
+})
+
 describe('markReported', () => {
+  test.each(['pending', 'failed'] as const)(
+    'behavior: cannot discharge a %s commitment',
+    async (status) => {
+      const db = TestApp.database()
+      const row = await SponsoredTransactions.upsert(db, input)
+      if (status === 'failed')
+        await SponsoredTransactions.fail(db, row.id, new Date().toISOString())
+
+      await SponsoredTransactions.markReported(db, row.id, new Date().toISOString())
+
+      expect((await SponsoredTransactions.get(db, row.id))?.meterReportedAt).toBeNull()
+      await db.close()
+    },
+  )
+
   test('behavior: marks once; re-marking never overwrites the first timestamp', async () => {
-    const db = create()
-    await db.migrate()
+    const db = TestApp.database()
     const record = await SponsoredTransactions.upsert(db, { ...input, signPayload: `0x${'15'.repeat(32)}` }) // prettier-ignore
     await SponsoredTransactions.finalize(db, record.id, { feeAmount: '100', finalizedAt: '2026-01-01T00:00:00.000Z' }) // prettier-ignore
     await SponsoredTransactions.markReported(db, record.id, '2026-01-02T00:00:00.000Z')
@@ -993,3 +1213,58 @@ describe('markReported', () => {
     await db.close()
   })
 })
+
+describe.each(['upsert', 'reserve', 'reservePromotion'] as const)('%s deletion fence', (method) => {
+  test('behavior: waits for deletion to commit and rejects the late commitment', async () => {
+    const schema = `t_${nanoid()}`
+    const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const concurrent = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    await db.migrate()
+    const locked = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const deletion = db.transaction(async (tx) => {
+      await ApiKeyOwnerTombstones.markDeleted(tx, { orgId: input.orgId })
+      locked.resolve()
+      await release.promise
+    })
+    await locked.promise
+    const reservation = (() => {
+      if (method === 'reserve')
+        return SponsoredTransactions.reserve(concurrent, input, {
+          chainIds: [input.chainId],
+          max: 1_000n,
+          since: '2026-01-01T00:00:00.000Z',
+        })
+      if (method === 'reservePromotion')
+        return SponsoredTransactions.reservePromotion(
+          concurrent,
+          {
+            ...input,
+            sponsorshipAttributionId: 'sat_1',
+          },
+          {
+            at: new Date().toISOString(),
+            chainIds: [input.chainId],
+          },
+        )
+      return SponsoredTransactions.upsert(concurrent, input)
+    })()
+    try {
+      expect(
+        await Promise.race([
+          reservation.then(
+            () => 'recorded',
+            () => 'rejected',
+          ),
+          new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+        ]),
+      ).toBe('waiting')
+    } finally {
+      release.resolve()
+    }
+    await deletion
+    await expect(reservation).rejects.toThrow(SponsoredTransactions.OrganizationDeletedError)
+    expect(await SponsoredTransactions.listPending(db)).toEqual([])
+    await Promise.all([db.close(), concurrent.close()])
+  })
+})