tapimo 0.14.0 → 0.15.0

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

@@ -1,16 +1,107 @@
 import { nanoid } from 'nanoid'
+import { sql } from 'kysely'
 
+import * as TestRoutes from '../../../test/Routes.js'
 import * as Runtime from '../../../test/runtime.js'
 import * as Webhooks from '../../internal/Webhooks.js'
 import * as Viem from '../../internal/Viem.js'
+import * as Deposit from '../../internal/routes/Deposit.js'
+import * as DepositAddress from '../../internal/routes/DepositAddress.js'
+import * as Transfer from '../../internal/routes/Transfer.js'
 import * as Db from '../Db.js'
 import * as EnabledBillingSources from './enabledBillingSources.js'
 import * as Memberships from './memberships.js'
 import * as Organizations from './organizations.js'
+import * as RoutesDepositAddresses from './routesDepositAddresses.js'
+import * as RoutesDeposits from './routesDeposits.js'
+import * as RoutesIdempotency from './routesIdempotency.js'
 import * as SponsoredTransactions from './sponsoredTransactions.js'
 import * as StripeCustomers from './stripeCustomers.js'
 
-const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
+async function settleRouteRollout(db: Db.Db) {
+  await db.kysely
+    .updateTable('api_key_owner_tombstones')
+    .set({ createdAt: '1970-01-01T00:00:00.000Z' })
+    .where('id', '=', 'routes-legacy-attempt-drain')
+    .execute()
+}
+
+const create = () => {
+  const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
+  return {
+    ...db,
+    async migrate() {
+      await db.migrate()
+      await settleRouteRollout(db)
+    },
+  }
+}
+
+/** Persists one prepared production Routes subsidy liability. */
+async function subsidyLiability(db: Db.Db, orgId: string) {
+  const snapshot = TestRoutes.depositAddressSnapshot({
+    provider: { id: 'stargate', name: 'Stargate' },
+    subsidize: true,
+  })
+  const address = await DepositAddress.create(db, {
+    deliveryStrategy: 'provider',
+    environment: 'production',
+    orgId,
+    providerOutputToken: snapshot.destinationToken,
+    snapshot,
+  })
+  const amount = {
+    baseUnits: '250000',
+    currency: 'USD',
+    decimals: 6,
+    formatted: '0.25',
+  }
+  const record = await Deposit.create(db, {
+    providerRequestId: 'request_routes_subsidy',
+    settlementTransaction: `0x${'bb'.repeat(32)}`,
+    settlementTransactionHash: `0x${'cc'.repeat(32)}`,
+    snapshot: TestRoutes.depositSnapshot(address.id),
+    sourceTransactionHash: `0x${'aa'.repeat(32)}`,
+    subsidyAmount: amount,
+  })
+  const result = await Deposit.transition(db, {
+    expectedVersion: record.version,
+    id: record.id,
+    status: 'settling',
+    subsidyAmount: amount,
+  })
+  if (result.type !== 'applied') throw new Error('Expected prepared Routes subsidy.')
+  return result.record
+}
+
+/** Persists one prepared outbound subsidy liability. */
+async function transferSubsidyLiability(db: Db.Db, orgId: string) {
+  const transfer = await Transfer.create(db, {
+    apiKeyId: 'key_routes_transfer_subsidy',
+    environment: 'production',
+    orgId,
+    snapshot: TestRoutes.transferSnapshot({ subsidize: true }),
+  })
+  const processing = await Transfer.transition(db, {
+    expectedVersion: transfer.version,
+    id: transfer.id,
+    status: 'processing',
+  })
+  if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
+  const prepared = await Transfer.transition(db, {
+    expectedVersion: processing.record.version,
+    id: transfer.id,
+    subsidyAmount: {
+      baseUnits: '3001',
+      currency: 'USD',
+      decimals: 6,
+      formatted: '0.003001',
+    },
+    subsidyTransactionHash: `0x${'dd'.repeat(32)}`,
+  })
+  if (prepared.type !== 'applied') throw new Error('Expected prepared transfer subsidy.')
+  return prepared.record
+}
 
 /** Redacts nondeterministic row fields (generated nanoid ids, timestamps). */
 function redact(record: Organizations.Record) {
@@ -125,6 +216,19 @@ describe('createOwned', () => {
     ).toEqual([])
     await db.close()
   })
+
+  test('behavior: supports concurrent top-level transactions', async () => {
+    const db = create()
+    await db.migrate()
+
+    const records = await Promise.all([
+      Organizations.createOwned(db, { name: 'First', userId: 'usr_first' }),
+      Organizations.createOwned(db, { name: 'Second', userId: 'usr_second' }),
+    ])
+
+    expect(records.map(({ name }) => name).sort()).toEqual(['First', 'Second'])
+    await db.close()
+  })
 })
 
 describe('get', () => {
@@ -181,30 +285,30 @@ describe('setSponsorshipSubsidy', () => {
     await Organizations.create(db, { id: 'org_1', name: 'One' })
 
     const enabled = await Organizations.setSponsorshipSubsidy(db, 'org_1', {
+      attributionSpendLimit: '100.00',
       durationDays: 90,
-      projectSpendLimit: '100.00',
     })
     expect({
+      attributionSpendLimit: enabled?.sponsorshipSubsidyProjectSpendLimit,
       durationDays: enabled?.sponsorshipSubsidyDurationDays,
-      projectSpendLimit: enabled?.sponsorshipSubsidyProjectSpendLimit,
     }).toMatchInlineSnapshot(`
       {
+        "attributionSpendLimit": "100.00",
         "durationDays": 90,
-        "projectSpendLimit": "100.00",
       }
     `)
 
     const disabled = await Organizations.setSponsorshipSubsidy(db, 'org_1', {
+      attributionSpendLimit: null,
       durationDays: null,
-      projectSpendLimit: null,
     })
     expect({
+      attributionSpendLimit: disabled?.sponsorshipSubsidyProjectSpendLimit,
       durationDays: disabled?.sponsorshipSubsidyDurationDays,
-      projectSpendLimit: disabled?.sponsorshipSubsidyProjectSpendLimit,
     }).toMatchInlineSnapshot(`
       {
+        "attributionSpendLimit": null,
         "durationDays": null,
-        "projectSpendLimit": null,
       }
     `)
     await db.close()
@@ -233,6 +337,334 @@ describe('upsert', () => {
 })
 
 describe('deleteOrganization', () => {
+  test('behavior: raw deletion commits before a blocked ownerless legacy claim', async () => {
+    const schema = `t_${nanoid()}`
+    const blocker = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const creator = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const deleter = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    await blocker.migrate()
+    await settleRouteRollout(blocker)
+    await Organizations.create(blocker, { id: 'org_1', name: 'One' })
+    const locked = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const holder = blocker.transaction(async (tx) => {
+      await sql`SELECT pg_advisory_xact_lock(hashtextextended(${'organization:org_1'}, 0))`.execute(
+        tx.kysely,
+      )
+      locked.resolve()
+      await release.promise
+    })
+    await locked.promise
+
+    const deletion = deleter.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute()
+    await expect(
+      Promise.race([
+        deletion.then(() => 'deleted' as const),
+        new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+      ]),
+    ).resolves.toBe('waiting')
+    const creation = creator.kysely
+      .insertInto('routes_idempotency_requests')
+      .values({
+        apiKeyId: 'key_legacy_after_delete',
+        createdAt: '2026-09-04T00:00:00.000Z',
+        expiresAt: '2099-09-04T00:01:00.000Z',
+        irrevocable: false,
+        keyHash: 'key_hash_legacy_after_delete',
+        matchHash: null,
+        operation: null,
+        orgId: null,
+        requestHash: 'request_hash_legacy_after_delete',
+        response: null,
+        status: 'pending',
+        transferId: null,
+      })
+      .execute()
+    await expect(
+      Promise.race([
+        creation.then(() => 'created' as const),
+        new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+      ]),
+    ).resolves.toBe('waiting')
+
+    release.resolve()
+    await holder
+    await expect(deletion).resolves.toHaveLength(1)
+    await expect(creation).rejects.toMatchObject({ code: '23503' })
+    await Promise.all([blocker.close(), creator.close(), deleter.close()])
+  })
+
+  test('behavior: raw deletion observes a committed ownerless legacy claim', async () => {
+    const schema = `t_${nanoid()}`
+    const claimer = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const deleter = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    await claimer.migrate()
+    await settleRouteRollout(claimer)
+    await Organizations.create(claimer, { id: 'org_1', name: 'One' })
+    const inserted = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const claim = claimer.transaction(async (tx) => {
+      await tx.kysely
+        .insertInto('routes_idempotency_requests')
+        .values({
+          apiKeyId: 'key_legacy_before_delete',
+          createdAt: '2026-09-04T00:00:00.000Z',
+          expiresAt: '2099-09-04T00:01:00.000Z',
+          irrevocable: false,
+          keyHash: 'key_hash_legacy_before_delete',
+          matchHash: null,
+          operation: null,
+          orgId: null,
+          requestHash: 'request_hash_legacy_before_delete',
+          response: null,
+          status: 'pending',
+          transferId: null,
+        })
+        .execute()
+      inserted.resolve()
+      await release.promise
+    })
+    await inserted.promise
+
+    const deletion = deleter.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute()
+    await expect(
+      Promise.race([
+        deletion.then(() => 'deleted' as const),
+        new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+      ]),
+    ).resolves.toBe('waiting')
+
+    release.resolve()
+    await claim
+    await expect(deletion).rejects.toMatchObject({ code: '23503' })
+    expect(await Organizations.get(claimer, 'org_1')).toBeDefined()
+    await Promise.all([claimer.close(), deleter.close()])
+  })
+
+  test('behavior: database fence rejects a rolling-worker address after deletion', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    const snapshot = TestRoutes.depositAddressSnapshot()
+
+    await expect(
+      RoutesIdempotency.claim(db, {
+        apiKeyId: 'key_1',
+        irrevocable: false,
+        keyHash: 'key_hash_1',
+        operation: RoutesIdempotency.operations.depositAddress,
+        orgId: 'org_1',
+        requestHash: 'request_hash_1',
+        ttlMs: 60_000,
+      }),
+    ).rejects.toMatchObject({ code: '23503' })
+    await expect(
+      DepositAddress.create(db, {
+        deliveryStrategy: 'provider',
+        environment: 'production',
+        orgId: 'org_1',
+        providerOutputToken: snapshot.destinationToken,
+        snapshot,
+      }),
+    ).rejects.toMatchObject({ code: '23503' })
+    await db.close()
+  })
+
+  test('behavior: deleted organizations reject expired legacy checkpoint updates', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    await db.kysely
+      .insertInto('routes_idempotency_requests')
+      .values({
+        apiKeyId: 'key_expired_legacy',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        expiresAt: '2026-09-02T00:00:00.000Z',
+        irrevocable: false,
+        keyHash: 'key_hash_expired_legacy',
+        matchHash: null,
+        operation: null,
+        orgId: null,
+        requestHash: 'request_hash_expired_legacy',
+        response: null,
+        status: 'pending',
+        transferId: null,
+      })
+      .execute()
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').executeTakeFirst(),
+    ).resolves.toMatchObject({ numDeletedRows: 1n })
+    await expect(
+      db.kysely
+        .updateTable('routes_idempotency_requests')
+        .set({
+          expiresAt: '2099-09-04T00:00:00.000Z',
+          response: '{"requestId":"late"}',
+          status: 'provisioned',
+        })
+        .where('apiKeyId', '=', 'key_expired_legacy')
+        .execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    await db.close()
+  })
+
+  test('behavior: database fence blocks an old worker from deleting an active address', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const snapshot = TestRoutes.depositAddressSnapshot()
+    await DepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: 'org_1',
+      providerOutputToken: snapshot.destinationToken,
+      snapshot,
+    })
+
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: database fence preserves deactivated subsidized Relay addresses', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const snapshot = TestRoutes.depositAddressSnapshot({ subsidize: true })
+    await DepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: 'org_1',
+      providerOutputToken: snapshot.destinationToken,
+      snapshot,
+    })
+    await RoutesDepositAddresses.deactivateByOrganization(db, {
+      now: '2026-09-04T00:00:00.000Z',
+      orgId: 'org_1',
+    })
+
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    await db.close()
+  })
+
+  test('behavior: database fence preserves attributed provider work', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const claim = await RoutesIdempotency.claim(db, {
+      apiKeyId: 'key_1',
+      irrevocable: false,
+      keyHash: 'key_hash_1',
+      operation: RoutesIdempotency.operations.depositAddress,
+      orgId: 'org_1',
+      requestHash: 'request_hash_1',
+      ttlMs: 60_000,
+    })
+    if (claim.type !== 'claimed') throw new Error('Expected a claimed request.')
+
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    await RoutesIdempotency.release(db, {
+      apiKeyId: 'key_1',
+      createdAt: claim.createdAt,
+      keyHash: 'key_hash_1',
+    })
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').executeTakeFirst(),
+    ).resolves.toMatchObject({ numDeletedRows: 1n })
+    await db.close()
+  })
+
+  test('behavior: database fence drains live unattributed provider work', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    await db.kysely
+      .insertInto('routes_idempotency_requests')
+      .values({
+        apiKeyId: 'key_legacy',
+        createdAt: '2026-09-04T00:00:00.000Z',
+        expiresAt: '2099-09-04T00:01:00.000Z',
+        irrevocable: false,
+        keyHash: 'key_hash_legacy',
+        matchHash: null,
+        operation: null,
+        orgId: null,
+        requestHash: 'request_hash_legacy',
+        response: null,
+        status: 'pending',
+        transferId: null,
+      })
+      .execute()
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    await db.kysely
+      .deleteFrom('routes_idempotency_requests')
+      .where('apiKeyId', '=', 'key_legacy')
+      .where('keyHash', '=', 'key_hash_legacy')
+      .execute()
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').executeTakeFirst(),
+    ).resolves.toMatchObject({ numDeletedRows: 1n })
+    await db.close()
+  })
+
+  test('behavior: database fence retains expired unattributed provider checkpoints', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    await db.kysely
+      .insertInto('routes_idempotency_requests')
+      .values({
+        apiKeyId: 'key_legacy_checkpoint',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        expiresAt: '2026-09-02T00:00:00.000Z',
+        irrevocable: false,
+        keyHash: 'key_hash_legacy_checkpoint',
+        matchHash: null,
+        operation: null,
+        orgId: null,
+        requestHash: 'request_hash_legacy_checkpoint',
+        response: '{"requestId":"relay_legacy"}',
+        status: 'provisioned',
+        transferId: null,
+      })
+      .execute()
+    const drain = Db.migrations.find(
+      (migration) => migration.name === '0264_routes_legacy_checkpoint_drain',
+    )
+    if (!drain) throw new Error('Expected the legacy checkpoint drain migration.')
+    await drain.up(db.kysely).execute()
+    const expiry = await db.kysely
+      .selectFrom('routes_idempotency_requests')
+      .select('expiresAt')
+      .where('apiKeyId', '=', 'key_legacy_checkpoint')
+      .executeTakeFirstOrThrow()
+    await drain.up(db.kysely).execute()
+    await expect(
+      db.kysely
+        .selectFrom('routes_idempotency_requests')
+        .select('expiresAt')
+        .where('apiKeyId', '=', 'key_legacy_checkpoint')
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual(expiry)
+
+    await expect(
+      db.kysely.deleteFrom('organizations').where('id', '=', 'org_1').execute(),
+    ).rejects.toMatchObject({ code: '23503' })
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.IrrevocableDepositAddressError,
+    )
+    await db.close()
+  })
+
   test('behavior: preserves an org with unreported billable sponsorships', async () => {
     const db = create()
     await db.migrate()
@@ -258,9 +690,9 @@ describe('deleteOrganization', () => {
       transactionHash: `0x${'aa'.repeat(32)}`,
     })
 
-    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(true)
     await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
-      Organizations.UnreportedSponsorshipsError,
+      Organizations.UnreportedMeteredUsageError,
     )
     expect(await Organizations.get(db, 'org_1')).toBeDefined()
     expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_1', source: 'stripe' })).toBe(
@@ -302,11 +734,256 @@ describe('deleteOrganization', () => {
       finalizedAt: '2026-01-01T00:00:00.000Z',
     })
 
-    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: preserves an org with unsettled Routes subsidy spend', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const subsidy = await subsidyLiability(db, 'org_1')
+
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedMeteredUsageError,
+    )
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+
+    const completed = await Deposit.transition(db, {
+      expectedVersion: subsidy.version,
+      id: subsidy.id,
+      status: 'completed',
+    })
+    if (completed.type !== 'applied') throw new Error('Expected completed Routes subsidy.')
+    await RoutesDeposits.markSubsidyReported(db, completed.record.id, new Date().toISOString())
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: preserves an org with an irrevocable subsidized Relay address', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const snapshot = TestRoutes.depositAddressSnapshot({ subsidize: true })
+    await DepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: 'org_1',
+      providerOutputToken: snapshot.destinationToken,
+      snapshot,
+    })
+
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.IrrevocableDepositAddressError,
+    )
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await db.close()
+  })
+
+  test('behavior: deactivates unsubsidized addresses when deleting an organization', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const snapshot = TestRoutes.depositAddressSnapshot()
+    const address = await DepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: 'org_1',
+      providerOutputToken: snapshot.destinationToken,
+      snapshot,
+    })
+    const claim = await RoutesDepositAddresses.claim(db, {
+      id: address.id,
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      now: '2027-01-01T00:00:00.000Z',
+    })
+    if (!claim) throw new Error('Expected a claimed address.')
+
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    expect(await RoutesDepositAddresses.get(db, address.id)).toMatchObject({
+      pollLeaseVersion: claim.pollLeaseVersion + 1,
+      status: 'deactivated',
+    })
+    expect(
+      await RoutesDepositAddresses.checkpointPoll(db, {
+        id: address.id,
+        pollLeaseVersion: claim.pollLeaseVersion,
+        providerState: { stale: true },
+      }),
+    ).toBeUndefined()
+    expect(
+      await RoutesDepositAddresses.listActiveSources(db, {
+        providerId: address.providerId,
+        sourceChainId: address.sourceChainId,
+        sourceTokenKey: address.sourceTokenKey,
+      }),
+    ).toEqual([])
+    await db.close()
+  })
+
+  test('behavior: preserves unresolved subsidy transactions until a revert is verified', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const subsidy = await subsidyLiability(db, 'org_1')
+    const unavailable = await Deposit.transition(db, {
+      expectedVersion: subsidy.version,
+      id: subsidy.id,
+      status: 'action-required',
+    })
+    if (unavailable.type !== 'applied') throw new Error('Expected unresolved Routes subsidy.')
+
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedMeteredUsageError,
+    )
+
+    const reverted = await Deposit.transition(db, {
+      expectedVersion: unavailable.record.version,
+      id: unavailable.record.id,
+      status: 'action-required',
+      subsidyAmount: { baseUnits: '0', currency: 'USD', decimals: 6, formatted: '0' },
+      tempoGasPaid: '100',
+    })
+    if (reverted.type !== 'applied') throw new Error('Expected reverted Routes subsidy.')
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
     expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
     await db.close()
   })
 
+  test('behavior: preserves an org with an outbound subsidy liability', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const subsidy = await transferSubsidyLiability(db, 'org_1')
+
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedMeteredUsageError,
+    )
+
+    const reverted = await Transfer.transition(db, {
+      expectedVersion: subsidy.version,
+      id: subsidy.id,
+      status: 'action-required',
+      subsidyAmount: { baseUnits: '0', currency: 'USD', decimals: 6, formatted: '0' },
+    })
+    if (reverted.type !== 'applied') throw new Error('Expected reverted transfer subsidy.')
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: serializes deletion with subsidy liability persistence', async () => {
+    const schema = `t_${nanoid()}`
+    const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const concurrent = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    await db.migrate()
+    await settleRouteRollout(db)
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const subsidy = await subsidyLiability(db, 'org_1')
+    await RoutesDeposits.markSubsidyReported(db, subsidy.id, new Date().toISOString())
+    const locked = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const settlement = RoutesDeposits.withSubsidySettlement(db, {
+      fn: async (tx) => {
+        locked.resolve()
+        await release.promise
+        await tx.kysely
+          .updateTable('routes_deposits')
+          .set({ subsidyMeterReportedAt: null })
+          .where('id', '=', subsidy.id)
+          .execute()
+      },
+      orgId: 'org_1',
+    })
+    await locked.promise
+
+    const deletion = Organizations.deleteOrganization(concurrent, 'org_1')
+    expect(
+      await Promise.race([
+        deletion.then(
+          () => 'deleted',
+          () => 'rejected',
+        ),
+        new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+      ]),
+    ).toBe('waiting')
+
+    release.resolve()
+    await settlement
+    await expect(deletion).rejects.toThrow(Organizations.UnreportedMeteredUsageError)
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await concurrent.close()
+    await db.close()
+  })
+
+  test('behavior: serializes deletion with outbound commitment creation', async () => {
+    const schema = `t_${nanoid()}`
+    const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const concurrent = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    await db.migrate()
+    await settleRouteRollout(db)
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const locked = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const commitment = db.transaction((tx) =>
+      Transfer.reserveSubsidyCommitmentIn(
+        tx,
+        {
+          apiKeyId: 'key_routes_transfer_subsidy',
+          environment: 'production',
+          orgId: 'org_1',
+          snapshot: TestRoutes.transferSnapshot({
+            quote: {
+              expiresAt: '2099-01-01T00:01:00.000Z',
+              sampledAt: '2099-01-01T00:00:00.000Z',
+            },
+          }),
+        },
+        {
+          account: `0x${'55'.repeat(20)}`,
+          chainId: 'eip155:8453',
+          async check() {
+            locked.resolve()
+            await release.promise
+            return { nativeAmount: '100' }
+          },
+          subsidyCommitmentAmount: {
+            baseUnits: '3001',
+            currency: 'USD',
+            decimals: 6,
+            formatted: '0.003001',
+          },
+          tokenAddress: `0x${'66'.repeat(20)}`,
+        },
+      ),
+    )
+    await locked.promise
+
+    const deletion = Organizations.deleteOrganization(concurrent, 'org_1')
+    expect(
+      await Promise.race([
+        deletion.then(
+          () => 'deleted',
+          () => 'rejected',
+        ),
+        new Promise((resolve) => setTimeout(() => resolve('waiting'), 100)),
+      ]),
+    ).toBe('waiting')
+
+    release.resolve()
+    await commitment
+    await expect(deletion).rejects.toThrow(Organizations.UnreportedMeteredUsageError)
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await concurrent.close()
+    await db.close()
+  })
+
   test('behavior: preserves an org with a recoverable failed fill intent', async () => {
     const db = create()
     await db.migrate()
@@ -323,9 +1000,9 @@ describe('deleteOrganization', () => {
     })
     await SponsoredTransactions.fail(db, failed.id, new Date().toISOString())
 
-    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(true)
     await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
-      Organizations.UnreportedSponsorshipsError,
+      Organizations.UnreportedMeteredUsageError,
     )
     expect(await Organizations.get(db, 'org_1')).toBeDefined()
     await db.close()
@@ -351,7 +1028,7 @@ describe('deleteOrganization', () => {
       new Date(Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs - 1).toISOString(),
     )
 
-    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.hasUnreportedMeteredUsage(db, 'org_1')).toBe(false)
     expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
     await db.close()
   })