tapimo 0.7.0 → 0.7.1

package/src/apps/data/App.test.ts

@@ -372,7 +372,7 @@ describe('zone chain gate', () => {
   test('public chains remain edge-cacheable on a Zone deployment', async () => {
     const store = Store.memory()
     const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })
-    const path = `/v1/tokenlist?chainId=${Viem.chainId.testnet}`
+    const path = '/v1/funding/chains'
 
     const first = await app.request(path)
     const second = await app.request(path)
@@ -380,6 +380,18 @@ describe('zone chain gate', () => {
     expect(second.status).toBe(200)
     expect(second.headers.get('cache-control')).toContain('public')
   })
+
+  test('preserves route-specific edge-cache opt-outs on a Zone deployment', async () => {
+    const store = Store.memory()
+    const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })
+    const path = `/v1/tokenlist?chainId=${Viem.chainId.testnet}`
+
+    const first = await app.request(path)
+    const second = await app.request(path)
+    expect(first.status).toBe(200)
+    expect(second.status).toBe(200)
+    expect(second.headers.get('cache-control')).toContain('private')
+  })
 })
 
 describe('sandbox chain guard', () => {

package/src/apps/data/routes/tokenlist.test.ts

@@ -75,4 +75,19 @@ describe('GET /tokenlist', () => {
     expect(body.tokens).toEqual([])
     expect(body.version.patch).toBe(0)
   })
+
+  test('refreshes cached reads after a snapshot publish', async () => {
+    const db = TestApp.database()
+    await VerifiedTokens.replace(db, chainId, seedList)
+    const client = TestApp.client({ auth: { keys: [reader] }, db })
+
+    await client.v1.tokenlist.$get({ query: {} }, as(reader))
+    await VerifiedTokens.replace(db, chainId, seedList.slice(1))
+
+    const response = await client.v1.tokenlist.$get({ query: {} }, as(reader))
+    const body = await TestApp.json(response, Tokenlist.schema.getTokenList.Response)
+    expect(body.tokens.map((token) => token.address)).toEqual(
+      seedList.slice(1).map((token) => token.address),
+    )
+  })
 })

package/src/apps/data/routes/tokenlist.ts

@@ -4,6 +4,7 @@ import * as z from 'zod/mini'
 import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
+import * as EdgeCache from '../../../internal/EdgeCache.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
@@ -159,11 +160,23 @@ export function tokenlist() {
       summary: 'Get token list',
       tags: ['Verified Tokens'],
     }),
-    Cache.response<App.Environment>({
-      cacheControl: Cache.policies.stable,
-      name: 'tempo-api:tokenlist:v1',
-      key: (c) => Cache.urlKey(c, schema.getTokenList.Query),
-    }),
+    // The shared edge cache is URL-keyed and cannot include the snapshot version.
+    EdgeCache.setEligibility(
+      Cache.response<App.Environment>({
+        cacheControl: Cache.policies.stable,
+        name: 'tempo-api:tokenlist:v1',
+        key: async (c) => {
+          const base = Cache.urlKey(c, schema.getTokenList.Query)
+          const query = schema.getTokenList.Query.parse(
+            Object.fromEntries(new URL(c.req.url).searchParams),
+          )
+          const chainId = query.chainId ?? c.get('chainId')
+          const { version } = await VerifiedTokens.snapshot(c, chainId)
+          return `${base}:v:${version}`
+        },
+      }),
+      () => false,
+    ),
     async (c) => {
       if (Auth.narrowAccess) return Auth.paidAccessError(c)
       if (OpenApi.narrowValidation)

package/src/apps/data/routes/tokens.ts

@@ -1821,6 +1821,8 @@ export async function getTokenCreatedAtByAddress(
   try {
     const result = await tidx.fetch({
       chainId: options.chainId,
+      // TODO: Remove the explicit engine after TIDX 1.0 is released.
+      engine: 'clickhouse',
       query: `
         SELECT token, block_timestamp
         FROM tokencreated
@@ -1916,6 +1918,8 @@ async function getTokenCreatedByAddress(
     // needs no event signature for the `logs` table.
     const result = await tidx.fetch({
       chainId: options.chainId,
+      // TODO: Remove the explicit engine after TIDX 1.0 is released.
+      engine: 'clickhouse',
       query: `
         SELECT topic1, data, block_timestamp
         FROM logs

package/src/apps/data/routes/verified-tokens.test.ts

@@ -87,6 +87,21 @@ describe('GET /verified-tokens', () => {
     )
     expect(second.status).toBe(304)
   })
+
+  test('refreshes cached reads after a snapshot publish', async () => {
+    const db = TestApp.database()
+    await VerifiedTokens.replace(db, chainId, seedList)
+    const client = TestApp.client({ auth: { keys: [reader] }, db })
+
+    await client.v1['verified-tokens'].$get({ query: {} }, as(reader))
+    await VerifiedTokens.replace(db, chainId, seedList.slice(1))
+
+    const response = await client.v1['verified-tokens'].$get({ query: {} }, as(reader))
+    const body = await TestApp.json(response, Verified.schema.listVerifiedTokens.Response)
+    expect(body.data.map((token) => token.address)).toEqual(
+      seedList.slice(1).map((token) => token.address),
+    )
+  })
 })
 
 describe('GET /verified-tokens/currencies', () => {
@@ -97,6 +112,23 @@ describe('GET /verified-tokens/currencies', () => {
     const body = await TestApp.json(response, Verified.schema.getVerifiedTokenCurrencies.Response)
     expect([...body.data]).toEqual(['EUR', 'USD'])
   })
+
+  test('refreshes cached reads after a snapshot publish', async () => {
+    const db = TestApp.database()
+    await VerifiedTokens.replace(db, chainId, seedList)
+    const client = TestApp.client({ auth: { keys: [reader] }, db })
+
+    await client.v1['verified-tokens'].currencies.$get({ query: {} }, as(reader))
+    await VerifiedTokens.replace(
+      db,
+      chainId,
+      seedList.filter((token) => token.currency === 'USD'),
+    )
+
+    const response = await client.v1['verified-tokens'].currencies.$get({ query: {} }, as(reader))
+    const body = await TestApp.json(response, Verified.schema.getVerifiedTokenCurrencies.Response)
+    expect([...body.data]).toEqual(['USD'])
+  })
 })
 
 describe('GET /verified-tokens/:address', () => {
@@ -123,4 +155,23 @@ describe('GET /verified-tokens/:address', () => {
     const body = (await response.json()) as { error?: { code?: string } }
     expect(body.error?.code).toBe('verified_token_not_found')
   })
+
+  test('refreshes cached reads after a snapshot publish', async () => {
+    const db = TestApp.database()
+    await VerifiedTokens.replace(db, chainId, seedList)
+    const client = TestApp.client({ auth: { keys: [reader] }, db })
+    const address = seedList[0].address
+
+    await client.v1['verified-tokens'][':address'].$get(
+      { param: { address }, query: {} },
+      as(reader),
+    )
+    await VerifiedTokens.replace(db, chainId, seedList.slice(1))
+
+    const response = await client.v1['verified-tokens'][':address'].$get(
+      { param: { address }, query: {} },
+      as(reader),
+    )
+    expect(response.status).toBe(404)
+  })
 })

package/src/apps/data/routes/verified-tokens.ts

@@ -4,6 +4,7 @@ import * as z from 'zod/mini'
 import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
+import * as EdgeCache from '../../../internal/EdgeCache.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
@@ -168,11 +169,23 @@ export function verifiedTokens() {
         summary: 'List verified tokens',
         tags: ['Verified Tokens'],
       }),
-      Cache.response<App.Environment>({
-        cacheControl: Cache.policies.stable,
-        name: 'tempo-api:verified-tokens:v1',
-        key: (c) => Cache.urlKey(c, schema.listVerifiedTokens.Query),
-      }),
+      // The shared edge cache is URL-keyed and cannot include the snapshot version.
+      EdgeCache.setEligibility(
+        Cache.response<App.Environment>({
+          cacheControl: Cache.policies.stable,
+          name: 'tempo-api:verified-tokens:v1',
+          key: async (c) => {
+            const base = Cache.urlKey(c, schema.listVerifiedTokens.Query)
+            const query = schema.listVerifiedTokens.Query.parse(
+              Object.fromEntries(new URL(c.req.url).searchParams),
+            )
+            const chainId = query.chainId ?? c.get('chainId')
+            const { version } = await VerifiedTokens.snapshot(c, chainId)
+            return `${base}:v:${version}`
+          },
+        }),
+        () => false,
+      ),
       async (c) => {
         if (Auth.narrowAccess) return Auth.paidAccessError(c)
         if (OpenApi.narrowValidation)
@@ -213,11 +226,23 @@ export function verifiedTokens() {
         summary: 'List verified currencies',
         tags: ['Verified Tokens'],
       }),
-      Cache.response<App.Environment>({
-        cacheControl: Cache.policies.stable,
-        name: 'tempo-api:verified-tokens:v1',
-        key: (c) => Cache.urlKey(c, schema.getVerifiedTokenCurrencies.Query),
-      }),
+      // The shared edge cache is URL-keyed and cannot include the snapshot version.
+      EdgeCache.setEligibility(
+        Cache.response<App.Environment>({
+          cacheControl: Cache.policies.stable,
+          name: 'tempo-api:verified-tokens:v1',
+          key: async (c) => {
+            const base = Cache.urlKey(c, schema.getVerifiedTokenCurrencies.Query)
+            const query = schema.getVerifiedTokenCurrencies.Query.parse(
+              Object.fromEntries(new URL(c.req.url).searchParams),
+            )
+            const chainId = query.chainId ?? c.get('chainId')
+            const { version } = await VerifiedTokens.snapshot(c, chainId)
+            return `${base}:v:${version}`
+          },
+        }),
+        () => false,
+      ),
       async (c) => {
         if (Auth.narrowAccess) return Auth.paidAccessError(c)
         if (OpenApi.narrowValidation)
@@ -265,11 +290,23 @@ export function verifiedTokens() {
         summary: 'Get verified token',
         tags: ['Verified Tokens'],
       }),
-      Cache.response<App.Environment>({
-        cacheControl: Cache.policies.stable,
-        name: 'tempo-api:verified-tokens:v1',
-        key: (c) => Cache.urlKey(c, schema.getVerifiedToken.Query),
-      }),
+      // The shared edge cache is URL-keyed and cannot include the snapshot version.
+      EdgeCache.setEligibility(
+        Cache.response<App.Environment>({
+          cacheControl: Cache.policies.stable,
+          name: 'tempo-api:verified-tokens:v1',
+          key: async (c) => {
+            const base = Cache.urlKey(c, schema.getVerifiedToken.Query)
+            const query = schema.getVerifiedToken.Query.parse(
+              Object.fromEntries(new URL(c.req.url).searchParams),
+            )
+            const chainId = query.chainId ?? c.get('chainId')
+            const { version } = await VerifiedTokens.snapshot(c, chainId)
+            return `${base}:v:${version}`
+          },
+        }),
+        () => false,
+      ),
       async (c) => {
         if (Auth.narrowAccess) return Auth.paidAccessError(c)
         if (OpenApi.narrowValidation)

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

@@ -1736,6 +1736,33 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     `)
   })
 
+  test('block:created preserves the cursor when a block header cannot be read', async () => {
+    const db = TestApp.database()
+    const missingBlock = 4_000_000_000
+    const cursor = encodeCursor([missingBlock - 1, endOfBlockIndex])
+    const subscription = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'block:created',
+      filters: { number: { eq: `0x${missingBlock.toString(16)}` } },
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    await Core.setCursor(db, subscription.id, cursor)
+
+    await expect(
+      Webhooks.poll({
+        chainId: 42431,
+        eventTypes: ['block:created'],
+        headBlockNumber: missingBlock + 2,
+        client,
+        db,
+        tidx: realTidx,
+      }),
+    ).rejects.toThrow()
+
+    expect(await Core.getCursor(db, subscription.id)).toBe(cursor)
+  })
+
   test('transaction:included filters on txs columns and inner calls', async () => {
     const db = TestApp.database()
     const subscription = await Core.createSubscription(db, {
@@ -1778,6 +1805,35 @@ describe.skipIf(Runtime.get().mode === 'localnet')('poll', () => {
     } else expect(tx?.feeToken).toBeUndefined()
   })
 
+  test('transaction:included preserves the cursor when a confirmed block is unavailable', async () => {
+    const db = TestApp.database()
+    const missingBlock = 4_000_000_000
+    const cursor = encodeCursor([missingBlock - 1, endOfBlockIndex])
+    const subscription = await Core.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'transaction:included',
+      filters: { blockNumber: { eq: `0x${missingBlock.toString(16)}` } },
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    await Core.setCursor(db, subscription.id, cursor)
+
+    await expect(
+      Webhooks.poll({
+        chainId: 42431,
+        eventTypes: ['transaction:included'],
+        headBlockNumber: missingBlock + 2,
+        client,
+        db,
+        tidx: realTidx,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      [Webhooks.BlockUnavailableError: Block 4000000000 is unavailable.]
+    `)
+
+    expect(await Core.getCursor(db, subscription.id)).toBe(cursor)
+  })
+
   test('transaction:included matches exact empty calldata through the poller', async () => {
     const db = TestApp.database()
     const subscription = await Core.createSubscription(db, {

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

@@ -2485,7 +2485,7 @@ type RpcBlock = Awaited<ReturnType<Viem.getClient.ReturnType['getBlock']>>
 /** Per-tick lazy cache of fetched block headers, full blocks, and receipts. */
 type ChainCache = {
   /** Full raw block (with transactions) via `eth_getBlockByNumber(n, true)`. */
-  block(n: number): Promise<Record<string, unknown> | undefined>
+  block(n: number): Promise<Record<string, unknown>>
   /** Viem-formatted block header (transaction hashes only) via `getBlock`. */
   header(n: number): Promise<RpcBlock | undefined>
   /** Receipts for a block keyed by lowercased transaction hash. */
@@ -2495,7 +2495,7 @@ type ChainCache = {
 /** Builds a per-tick {@link ChainCache} bound to a viem client. */
 function createChainCache(client: Viem.getClient.ReturnType): ChainCache {
   const headers = new Map<number, Promise<RpcBlock | undefined>>()
-  const blocks = new Map<number, Promise<Record<string, unknown> | undefined>>()
+  const blocks = new Map<number, Promise<Record<string, unknown>>>()
   const receipts = new Map<number, Promise<Map<string, Record<string, unknown>>>>()
   return {
     block(n) {
@@ -2506,7 +2506,10 @@ function createChainCache(client: Viem.getClient.ReturnType): ChainCache {
         p = rpc<Record<string, unknown> | null>(client, 'eth_getBlockByNumber', [
           blockTag(n),
           true,
-        ]).then((b) => b ?? undefined)
+        ]).then((block) => {
+          if (!block) throw new BlockUnavailableError(n)
+          return block
+        })
         blocks.set(n, p)
       }
       return p
@@ -2514,9 +2517,7 @@ function createChainCache(client: Viem.getClient.ReturnType): ChainCache {
     header(n) {
       let p = headers.get(n)
       if (!p) {
-        p = client
-          .getBlock({ blockNumber: BigInt(n), includeTransactions: false })
-          .catch(() => undefined)
+        p = client.getBlock({ blockNumber: BigInt(n), includeTransactions: false })
         headers.set(n, p)
       }
       return p
@@ -2999,10 +3000,10 @@ async function scanTxs(options: {
   const items: ScanItem[] = []
   for (let n = window.from; n <= window.to; n++) {
     const block = await cache.block(n)
-    const txs = Array.isArray(block?.['transactions']) ? (block!['transactions'] as unknown[]) : []
+    const txs = Array.isArray(block['transactions']) ? (block['transactions'] as unknown[]) : []
     if (txs.length === 0) continue
     const receipts = needsReceipt || includeReceipt ? await cache.receipts(n) : undefined
-    const timestamp = asString(block?.['timestamp'])
+    const timestamp = asString(block['timestamp'])
 
     for (let i = 0; i < txs.length; i++) {
       const tx = txs[i] as Record<string, unknown>
@@ -3195,3 +3196,11 @@ function unauthorized(c: Context<App.Environment>) {
     status: 401,
   })
 }
+
+class BlockUnavailableError extends Error {
+  override name = 'Webhooks.BlockUnavailableError'
+
+  constructor(blockNumber: number) {
+    super(`Block ${blockNumber} is unavailable.`)
+  }
+}

package/src/apps/relay/App.test.ts

@@ -450,7 +450,7 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
       `)
   })
 
-  test('behavior: non-mainnet production keys record billable rows', async () => {
+  test('behavior: non-mainnet production keys record non-billable rows', async () => {
     const db = TestApp.database()
     const app = TestApp.create({
       auth: { keys },
@@ -466,7 +466,7 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
     expect(body.error).toBeUndefined()
 
     const [row] = await SponsoredTransactions.listPending(db)
-    expect(row?.billable).toBe(true)
+    expect(row?.billable).toBe(false)
     expect(row?.environment).toMatchInlineSnapshot(`"production"`)
   })
 

package/src/apps/relay/App.ts

@@ -238,7 +238,7 @@ function middleware(options: middleware.Options) {
 
           const input = {
             apiKeyId: attribution.apiKeyId,
-            billable: attribution.environment === 'production',
+            billable: mainnet && attribution.environment === 'production',
             chainId: event.chainId,
             environment: attribution.environment,
             orgId: attribution.orgId,

package/src/apps/relay/Sponsorships.test.ts

@@ -4,6 +4,7 @@ import type { Client } from 'viem'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as Db from '../../db/Db.js'
+import * as Organizations from '../../db/tables/organizations.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
 import * as Sponsorships from './Sponsorships.js'
 
@@ -269,6 +270,7 @@ describe('reconcile', () => {
   test('behavior: recovers recently failed intents by sign payload', async () => {
     const db = create()
     await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...rest } = input
     const intent = await SponsoredTransactions.upsert(db, { ...rest, signPayload })
     await SponsoredTransactions.fail(db, intent.id, '2026-01-01T00:00:00.000Z')

package/src/apps/relay/Sponsorships.ts

@@ -126,7 +126,7 @@ export async function reconcile(db: Db.Db, options: reconcile.Options): Promise<
   const {
     batchSize = 100,
     candidateCap = 500,
-    failedIntentTtlMs = 86_400_000,
+    failedIntentTtlMs = SponsoredTransactions.failedIntentRecoveryTtlMs,
     feePayer,
     getClient,
     getTidx,

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

@@ -2,6 +2,7 @@ import { nanoid } from 'nanoid'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as Webhooks from '../../internal/Webhooks.js'
+import * as Viem from '../../internal/Viem.js'
 import * as Db from '../Db.js'
 import * as EnabledBillingSources from './enabledBillingSources.js'
 import * as Memberships from './memberships.js'
@@ -216,6 +217,7 @@ describe('deleteOrganization', () => {
       transactionHash: `0x${'aa'.repeat(32)}`,
     })
 
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
     await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
       Organizations.UnreportedSponsorshipsError,
     )
@@ -227,6 +229,92 @@ describe('deleteOrganization', () => {
     await db.close()
   })
 
+  test('behavior: deletes an org with only failed or non-mainnet sponsorships', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+      transactionHash: `0x${'aa'.repeat(32)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, '2026-01-01T00:00:00.000Z')
+    const testnet = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.testnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'dd'.repeat(32)}`,
+      transaction: `0x76${'ee'.repeat(16)}`,
+      transactionHash: `0x${'ff'.repeat(32)}`,
+    })
+    await SponsoredTransactions.finalize(db, testnet.id, {
+      feeAmount: '100',
+      finalizedAt: '2026-01-01T00:00:00.000Z',
+    })
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: preserves an org with a recoverable failed fill intent', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, new Date().toISOString())
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedSponsorshipsError,
+    )
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await db.close()
+  })
+
+  test('behavior: deletes an org with only expired failed fill intents', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(
+      db,
+      failed.id,
+      new Date(Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs - 1).toISOString(),
+    )
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
   test('behavior: deletes enabled billing sources', async () => {
     const db = create()
     await db.migrate()

package/src/db/tables/organizations.ts

@@ -1,6 +1,8 @@
-import { sql, type Selectable } from 'kysely'
+import { sql, type ExpressionBuilder, type Selectable } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
+import * as Viem from '../../internal/Viem.js'
+import * as SponsoredTransactions from './sponsoredTransactions.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
 import type * as EnabledBillingSources from './enabledBillingSources.js'
@@ -120,12 +122,17 @@ export declare namespace createOwned {
  */
 export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
   return db.kysely.transaction().execute(async (trx) => {
+    const failedSince = new Date(
+      Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs,
+    ).toISOString()
     const unreported = await trx
       .selectFrom('sponsored_transactions')
       .select('id')
       .where('orgId', '=', id)
       .where('billable', '=', true)
+      .where('chainId', '=', Viem.chainId.mainnet)
       .where('meterReportedAt', 'is', null)
+      .where(unreportedSponsorshipStatus(failedSince))
       .limit(1)
       .executeTakeFirst()
     if (unreported) throw new UnreportedSponsorshipsError()
@@ -152,12 +159,17 @@ export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
 
 /** Whether an organization has billable sponsorships awaiting settlement. */
 export async function hasUnreportedSponsorships(db: Db.Db, id: string): Promise<boolean> {
+  const failedSince = new Date(
+    Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs,
+  ).toISOString()
   const record = await db.kysely
     .selectFrom('sponsored_transactions')
     .select('id')
     .where('orgId', '=', id)
     .where('billable', '=', true)
+    .where('chainId', '=', Viem.chainId.mainnet)
     .where('meterReportedAt', 'is', null)
+    .where(unreportedSponsorshipStatus(failedSince))
     .limit(1)
     .executeTakeFirst()
   return record !== undefined
@@ -429,6 +441,19 @@ export declare namespace upsert {
   }
 }
 
+/** Blocks rows that can still settle or recover into billable mainnet spend. */
+function unreportedSponsorshipStatus(failedSince: string) {
+  return (eb: ExpressionBuilder<Db.Database, 'sponsored_transactions'>) =>
+    eb.or([
+      eb('status', '!=', 'failed'),
+      eb.and([
+        eb('status', '=', 'failed'),
+        eb('transactionHash', 'is', null),
+        eb('finalizedAt', '>=', failedSince),
+      ]),
+    ])
+}
+
 /** Organization deletion is blocked until billable sponsorships settle. */
 export class UnreportedSponsorshipsError extends Error {
   override name = 'Organizations.UnreportedSponsorshipsError'