tapimo 0.7.0 → 0.7.2

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

@@ -1,3 +1,5 @@
+/** @module-tag localnet */
+
 import { nanoid } from 'nanoid'
 import { Hash, Hex, Secp256k1 } from 'ox'
 import { ZoneRpcAuthentication } from 'ox/tempo'
@@ -14,6 +16,7 @@ import * as TestStripe from '../../../test/Stripe.js'
 import * as BillingSettings from '../../db/tables/billingSettings.js'
 import type * as Db from '../../db/Db.js'
 import * as Fees from '../../internal/Fees.js'
+import type * as Log from '../../internal/Log.js'
 import * as Organizations from '../../db/tables/organizations.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
 import * as StripeCustomers from '../../db/tables/stripeCustomers.js'
@@ -28,10 +31,10 @@ const feePayerAccount = Tempo.accounts[10]!
 const senderAccount = Tempo.accounts[9]!
 const zone = runtime.zone.chainId
 const zoneScope = `zone:${zone}:read` as const
-const zoneOptions = {
+const zoneOptions = TestApp.zone({
   chainId: zone,
-  forwardRpcUrl: runtime.zone.forwardRpcUrl,
-}
+  rpcUrl: runtime.zone.publicZoneUrl,
+})
 
 /** Super admin secret configured on the end-to-end billing app. */
 const superAdminSecret = 'tempo:sk:a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1'
@@ -255,8 +258,7 @@ describe('behavior: Zone chain routing', () => {
     try {
       const api = TestApp.create({
         auth: { keys },
-        rpc: ({ chainId }) =>
-          chainId === zone ? { basicAuth: 'rpc-secret', url: server.url } : {},
+        rpc: ({ chainId }) => (chainId === zone ? { auth: 'rpc:secret', url: server.url } : {}),
         zones: [zoneOptions],
       })
       const body = await request(api, {
@@ -266,7 +268,7 @@ describe('behavior: Zone chain routing', () => {
       })
 
       expect(body).toMatchObject({ result: Hex.fromNumber(zone) })
-      expect(authorization).toEqual(['Basic cnBjLXNlY3JldA=='])
+      expect(authorization).toEqual(['Basic cnBjOnNlY3JldA=='])
     } finally {
       await server.closeAsync()
     }
@@ -368,8 +370,10 @@ describe('behavior: Zone chain routing', () => {
   })
 
   test('requires Zone authorization for an embedded signed transaction', async () => {
+    const entries: Log.Entry[] = []
     const api = TestApp.create({
       auth: { keys },
+      logger: (entry) => void entries.push(entry),
       relay: { feePayer: { account: feePayerAccount } },
       zones: [zoneOptions],
     })
@@ -396,6 +400,7 @@ describe('behavior: Zone chain routing', () => {
     const authorized = await request(api, { ...rpc, zoneToken: token() })
 
     expect(refused).toMatchObject({ error: { data: { code: 'api_key_forbidden' } } })
+    expectSponsorshipCode({ code: 'api_key_forbidden', entry: entries[0] })
     expect(authorized).toMatchObject({ result: expect.stringMatching(/^0x/) })
   })
 })
@@ -450,7 +455,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 +471,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"`)
   })
 
@@ -509,7 +514,7 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 
-  test('behavior: keys without project attribution are refused', async () => {
+  test('behavior: organization-attributed keys sponsor without a project', async () => {
     const db = TestApp.database()
     const app = TestApp.create({
       auth: { keys },
@@ -522,26 +527,273 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
       params: [await signSponsorable()],
       token: 'secret_unattributed',
     })
-    expect(body.result).toBeUndefined()
-    expect(body.error?.code).toBe(-32602)
+    expect(body.error).toBeUndefined()
+    expect(Transaction.deserialize(body.result as `0x76${string}`).feePayerSignature).toBeDefined()
+
+    const [row] = await SponsoredTransactions.listPending(db)
+    expect(row?.orgId).toMatchInlineSnapshot(`"org_1"`)
+    expect(row?.projectId).toBeNull()
+  })
+
+  test('behavior: batches aggregate sponsorship rejections without retaining payloads', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: { keys },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+    })
+    const transactions = await Promise.all([
+      signSponsorable({ chainId: 999_999, nonce: 0 }),
+      signSponsorable({ chainId: 999_999, nonce: 1 }),
+    ])
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/sponsor', {
+        body: JSON.stringify(
+          transactions.map((transaction, index) => ({
+            id: index + 1,
+            jsonrpc: '2.0',
+            method: 'eth_signRawTransaction',
+            params: [transaction],
+          })),
+        ),
+        headers: {
+          'content-type': 'application/json',
+          'tempo-api-key': 'secret_sponsor',
+        },
+        method: 'POST',
+      }),
+    )
+    const body = await response.json()
+
+    expect(body).toMatchObject([
+      { error: { data: { code: 'chain_id_unsupported' } } },
+      { error: { data: { code: 'chain_id_unsupported' } } },
+    ])
+    expect(entries).toHaveLength(1)
+    expect(entries[0]?.rpc).toStrictEqual({
+      code: -32602,
+      dataCode: 'chain_id_unsupported',
+      errors: 2,
+    })
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: 999_999,
+      method: 'eth_signRawTransaction',
+      outcome: 'rejected',
+      reason: 'chain_id_unsupported',
+      rejections: 2,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(transactions[0])
+    expect(JSON.stringify(entries[0])).not.toContain(transactions[1])
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
+  })
+
+  test('behavior: invalid batch items never enable payload hashes', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: { keys },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+    })
+    const serialized = await signSponsorable({ chainId: 999_999 })
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/sponsor', {
+        body: JSON.stringify([
+          null,
+          {
+            id: 2,
+            jsonrpc: '2.0',
+            method: 'eth_signRawTransaction',
+            params: [serialized],
+          },
+        ]),
+        headers: {
+          'content-type': 'application/json',
+          'tempo-api-key': 'secret_sponsor',
+        },
+        method: 'POST',
+      }),
+    )
+    const body = await response.json()
+
+    expect(body).toMatchObject([
+      { error: { code: -32600 } },
+      { error: { data: { code: 'chain_id_unsupported' } } },
+    ])
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: 999_999,
+      method: 'eth_signRawTransaction',
+      outcome: 'rejected',
+      reason: 'chain_id_unsupported',
+      rejections: 1,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
+  })
+
+  test('behavior: batch diagnostics use only rejected request methods', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: { keys },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+    })
+    const serialized = await signSponsorable({ chainId: 999_999 })
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/sponsor', {
+        body: JSON.stringify([
+          {
+            id: 1,
+            jsonrpc: '2.0',
+            method: 'eth_fillTransaction',
+            params: [],
+          },
+          {
+            id: 2,
+            jsonrpc: '2.0',
+            method: 'eth_signRawTransaction',
+            params: [serialized],
+          },
+        ]),
+        headers: {
+          'content-type': 'application/json',
+          'tempo-api-key': 'secret_sponsor',
+        },
+        method: 'POST',
+      }),
+    )
+    const body = await response.json()
+
+    expect(body).toMatchObject([
+      { error: { data: { code: 'internal_error' } } },
+      { error: { data: { code: 'chain_id_unsupported' } } },
+    ])
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: 999_999,
+      method: 'eth_signRawTransaction',
+      outcome: 'rejected',
+      reason: 'chain_id_unsupported',
+      rejections: 1,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
+  })
+
+  test('behavior: duplicate batch ids suppress request attribution', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: { keys },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+    })
+    const serialized = await signSponsorable({ chainId: 999_999 })
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/sponsor/999999', {
+        body: JSON.stringify([
+          {
+            id: 1,
+            jsonrpc: '2.0',
+            method: 'eth_chainId',
+          },
+          {
+            id: 1,
+            jsonrpc: '2.0',
+            method: 'eth_signRawTransaction',
+            params: [serialized],
+          },
+        ]),
+        headers: {
+          'content-type': 'application/json',
+          'tempo-api-key': 'secret_sponsor',
+        },
+        method: 'POST',
+      }),
+    )
+    const body = await response.json()
+
+    expect(body).toMatchObject([
+      { error: { data: { code: 'chain_id_unsupported' } } },
+      { error: { data: { code: 'chain_id_unsupported' } } },
+    ])
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: 999_999,
+      outcome: 'rejected',
+      reason: 'chain_id_unsupported',
+      rejections: 2,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 
   test('behavior: super admin principals are refused', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     const app = TestApp.create({
       auth: { keys, superAdmin: { secret: 'super-admin-secret' } },
       db,
+      logger: (entry) => void entries.push(entry),
       relay: { feePayer: { account: feePayerAccount } },
     })
+    const serialized = await signSponsorable()
 
     const body = await relayRequest(app, {
       method: 'eth_signRawTransaction',
-      params: [await signSponsorable()],
+      params: [serialized],
       token: 'super-admin-secret',
     })
     expect(body.result).toBeUndefined()
-    expect(body.error?.code).toBe(-32602)
+    expect(body.error).toStrictEqual({
+      code: -32602,
+      data: { code: 'api_key_required' },
+      message: 'Sponsorship rejected.',
+    })
+    expectSponsorshipCode({ code: 'api_key_required', entry: entries[0] })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
+  })
+
+  test('behavior: sponsorship policy invariants return internal errors', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: {
+        keys,
+        overrides: {
+          'ALL /rpc/sponsor': { apiKey: { scopes: [] } },
+        },
+      },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+    })
+    const serialized = await signSponsorable()
+
+    const body = await relayRequest(app, {
+      method: 'eth_signRawTransaction',
+      params: [serialized],
+      token: 'secret_unscoped',
+    })
+
+    expect(body.error).toStrictEqual({
+      code: -32603,
+      data: { code: 'internal_error' },
+      message: 'Internal error',
+    })
+    expect(entries[0]?.level).toBe('error')
+    expectSponsorshipCode({ code: 'internal_error', entry: entries[0] })
+    expect(entries[0]?.sponsorship?.internalErrors).toBe(1)
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 
@@ -625,30 +877,49 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
 
   test('behavior: sponsorship is refused for chains this deployment does not serve', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     const app = TestApp.create({
       auth: { keys },
       db,
+      logger: (entry) => void entries.push(entry),
       relay: { feePayer: { account: feePayerAccount } },
     })
+    const serialized = await senderAccount.signTransaction({
+      chainId: 999_999,
+      feePayer: true,
+      gas: 100_000n,
+      maxFeePerGas: 1_000_000n,
+      maxPriorityFeePerGas: 0n,
+      nonce: 0,
+      to: Tempo.accounts[8]!.address,
+      value: 0n,
+    })
 
     const body = await relayRequest(app, {
       method: 'eth_signRawTransaction',
-      params: [
-        await senderAccount.signTransaction({
-          chainId: 999_999,
-          feePayer: true,
-          gas: 100_000n,
-          maxFeePerGas: 1_000_000n,
-          maxPriorityFeePerGas: 0n,
-          nonce: 0,
-          to: Tempo.accounts[8]!.address,
-          value: 0n,
-        }),
-      ],
+      params: [serialized],
       token: 'secret_sponsor',
     })
     expect(body.result).toBeUndefined()
-    expect(body.error?.code).toBe(-32602)
+    expect(body.error).toStrictEqual({
+      code: -32602,
+      data: { code: 'chain_id_unsupported' },
+      message: 'Unsupported chain id.',
+    })
+    expect(entries[0]?.rpc).toStrictEqual({
+      code: -32602,
+      dataCode: 'chain_id_unsupported',
+      errors: 1,
+    })
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: 999_999,
+      method: 'eth_signRawTransaction',
+      outcome: 'rejected',
+      payloadHash: Hash.keccak256(serialized),
+      reason: 'chain_id_unsupported',
+      rejections: 1,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 })
@@ -669,15 +940,6 @@ describe('behavior: mainnet billing gate', () => {
     nonce: '0x0',
   } as const
 
-  function createApp(db: Db.Source = TestApp.database()) {
-    return TestApp.create({
-      auth: { keys },
-      db,
-      relay: { feePayer: { account: feePayerAccount } },
-      supportedChainIds: [Viem.chainId.mainnet],
-    })
-  }
-
   /** Activates billing for the org so the gate reaches the limit checks. */
   async function activate(db: ReturnType<typeof TestApp.database>, orgId = 'org_1') {
     await StripeCustomers.create(db, { orgId, stripeCustomerId: `cus_gate_${orgId}` })
@@ -695,18 +957,23 @@ describe('behavior: mainnet billing gate', () => {
   const overCapFees = { gas: 1_000_000n, maxFeePerGas: 2_000_000_000_000n } as const
 
   test('behavior: refuses mainnet sponsorship without a billing source', async () => {
-    const body = await relayRequest(createApp(), {
-      method: 'eth_signRawTransaction',
-      params: [await signSponsorable({ chainId: Viem.chainId.mainnet })],
-      token: 'secret_sponsor_prod',
-    })
+    const entries: Log.Entry[] = []
+    const body = await relayRequest(
+      createMainnetApp({ logger: (entry) => void entries.push(entry) }),
+      {
+        method: 'eth_signRawTransaction',
+        params: [await signSponsorable({ chainId: Viem.chainId.mainnet })],
+        token: 'secret_sponsor_prod',
+      },
+    )
     expect(body.error?.code).toBe(-32602)
     expect(body.error?.message).toBe('Billing required.')
     expect(body.error?.data).toStrictEqual({ code: 'billing_required' })
+    expectSponsorshipCode({ code: 'billing_required', entry: entries[0] })
   })
 
   test('behavior: returns the billing reason for sponsor fills', async () => {
-    const body = await relayRequest(createApp(), {
+    const body = await relayRequest(createMainnetApp(), {
       method: 'eth_fillTransaction',
       params: [fill],
       token: 'secret_sponsor_prod',
@@ -718,6 +985,91 @@ describe('behavior: mainnet billing gate', () => {
     })
   })
 
+  test('behavior: error capabilities retain sponsor fill attribution', async () => {
+    const entries: Log.Entry[] = []
+    const body = await relayRequest(
+      createMainnetApp({ logger: (entry) => void entries.push(entry) }),
+      {
+        method: 'eth_fillTransaction',
+        params: [
+          {
+            ...fill,
+            capabilities: { balanceDiffs: false, errors: true },
+          },
+        ],
+        token: 'secret_sponsor_prod',
+      },
+    )
+    type Result = {
+      capabilities?: {
+        error?: { errorName?: string | undefined; message?: string | undefined } | undefined
+        sponsored?: boolean | undefined
+      }
+    }
+    const result = body.result as unknown as Result | undefined
+
+    expect(body.error).toBeUndefined()
+    expect(result?.capabilities).toMatchObject({
+      error: { errorName: 'unknown', message: 'Billing required.' },
+      sponsored: false,
+    })
+    expect(entries[0]?.level).toBe('warn')
+    expect(entries[0]?.rpc).toBeUndefined()
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: Viem.chainId.mainnet,
+      method: 'eth_fillTransaction',
+      outcome: 'rejected',
+      reason: 'billing_required',
+      rejections: 1,
+    })
+  })
+
+  test('behavior: error capabilities hide sponsorship policy invariants', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      auth: {
+        keys,
+        overrides: {
+          'ALL /rpc/sponsor': { apiKey: { scopes: [] } },
+        },
+      },
+      db: TestApp.database(),
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+      supportedChainIds: [Viem.chainId.mainnet],
+    })
+
+    const body = await relayRequest(app, {
+      method: 'eth_fillTransaction',
+      params: [
+        {
+          ...fill,
+          capabilities: { balanceDiffs: false, errors: true },
+        },
+      ],
+      token: 'secret_unscoped',
+    })
+
+    expect(body.error).toBeUndefined()
+    expect(body.result).toMatchObject({
+      capabilities: {
+        error: { errorName: 'unknown', message: 'Internal error' },
+        sponsored: false,
+      },
+    })
+    expect(JSON.stringify(body)).not.toContain('ineligible API key')
+    expect(entries[0]?.level).toBe('error')
+    expect(entries[0]?.rpc).toBeUndefined()
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: Viem.chainId.mainnet,
+      internalErrors: 1,
+      method: 'eth_fillTransaction',
+      outcome: 'rejected',
+      reason: 'internal_error',
+      rejections: 1,
+    })
+  })
+
   test('behavior: relay fills still fall back to self-payment', async () => {
     const server = await Relay.createServer(
       RequestListener.fromFetchHandler(async (request) => {
@@ -766,7 +1118,7 @@ describe('behavior: mainnet billing gate', () => {
   test('behavior: refuses mainnet sponsorship while billing is inactive', async () => {
     const db = TestApp.database()
     await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_gate' })
-    const body = await relayRequest(createApp(db), {
+    const body = await relayRequest(createMainnetApp({ db }), {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet })],
       token: 'secret_sponsor_prod',
@@ -777,24 +1129,29 @@ describe('behavior: mainnet billing gate', () => {
 
   test('behavior: past-due billing refuses with its own reason', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     await activate(db)
     // An unpaid invoice parked the org; the caller must settle it, not attach a card.
     await StripeCustomers.setStatus(db, 'org_1', 'past_due')
-    const body = await relayRequest(createApp(db), {
-      method: 'eth_signRawTransaction',
-      params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
-      token: 'secret_sponsor_prod',
-    })
+    const body = await relayRequest(
+      createMainnetApp({ db, logger: (entry) => void entries.push(entry) }),
+      {
+        method: 'eth_signRawTransaction',
+        params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
+        token: 'secret_sponsor_prod',
+      },
+    )
     expect(body.error?.code).toBe(-32602)
     expect(body.error?.message).toBe('Billing past due.')
     expect(body.error?.data).toStrictEqual({ code: 'billing_past_due' })
+    expectSponsorshipCode({ code: 'billing_past_due', entry: entries[0] })
   })
 
   test('behavior: active billing opens mainnet sponsorship and records it', async () => {
     const db = TestApp.database()
     await activate(db)
 
-    const body = await relayRequest(createApp(db), {
+    const body = await relayRequest(createMainnetApp({ db }), {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
       token: 'secret_sponsor_prod',
@@ -813,15 +1170,44 @@ describe('behavior: mainnet billing gate', () => {
 
   test('behavior: a sandbox key never sponsors mainnet, even with active billing', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     await activate(db) // org_1 is active…
-    const body = await relayRequest(createApp(db), {
+    const app = TestApp.create({
+      auth: { keys },
+      db,
+      logger: (entry) => void entries.push(entry),
+      relay: { feePayer: { account: feePayerAccount } },
+      supportedChainIds: [Viem.chainId.mainnet],
+    })
+    const serialized = await signSponsorable({
+      chainId: Viem.chainId.mainnet,
+      ...halfDollarFees,
+    })
+    const body = await relayRequest(app, {
       method: 'eth_signRawTransaction',
-      params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
+      params: [serialized],
       token: 'secret_sponsor', // …but this key is sandbox.
     })
     // Refused for the environment, before the billing check reveals a reason.
-    expect(body.error?.code).toBe(-32602)
-    expect(body.error?.message).toBe('Sponsorship rejected.')
+    expect(body.error).toStrictEqual({
+      code: -32602,
+      data: { code: 'production_api_key_required' },
+      message: 'Sponsorship rejected.',
+    })
+    expect(entries[0]?.rpc).toStrictEqual({
+      code: -32602,
+      dataCode: 'production_api_key_required',
+      errors: 1,
+    })
+    expect(entries[0]?.sponsorship).toStrictEqual({
+      chainId: Viem.chainId.mainnet,
+      method: 'eth_signRawTransaction',
+      outcome: 'rejected',
+      payloadHash: Hash.keccak256(serialized),
+      reason: 'production_api_key_required',
+      rejections: 1,
+    })
+    expect(JSON.stringify(entries[0])).not.toContain(serialized)
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 
@@ -829,7 +1215,7 @@ describe('behavior: mainnet billing gate', () => {
     const db = TestApp.database()
     // org_1 is active; the production wildcard key belongs to org_2, which has nothing.
     await activate(db)
-    const body = await relayRequest(createApp(db), {
+    const body = await relayRequest(createMainnetApp({ db }), {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
       token: 'secret_wildcard_prod',
@@ -840,15 +1226,20 @@ describe('behavior: mainnet billing gate', () => {
 
   test('behavior: refuses a transaction over the platform fee cap', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     await activate(db)
-    const body = await relayRequest(createApp(db), {
-      method: 'eth_signRawTransaction',
-      params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...overCapFees })],
-      token: 'secret_sponsor_prod',
-    })
+    const body = await relayRequest(
+      createMainnetApp({ db, logger: (entry) => void entries.push(entry) }),
+      {
+        method: 'eth_signRawTransaction',
+        params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...overCapFees })],
+        token: 'secret_sponsor_prod',
+      },
+    )
     expect(body.error?.code).toBe(-32602)
     expect(body.error?.message).toBe('Transaction fee limit exceeded.')
     expect(body.error?.data).toStrictEqual({ code: 'tx_fee_limit_exceeded' })
+    expectSponsorshipCode({ code: 'tx_fee_limit_exceeded', entry: entries[0] })
   })
 
   test('behavior: the org fee limit tightens the platform cap but never loosens it', async () => {
@@ -856,7 +1247,7 @@ describe('behavior: mainnet billing gate', () => {
     await activate(db)
     // Tighter than the platform default: $0.50 envelopes now refuse.
     await BillingSettings.upsert(db, { orgId: 'org_1', txFeeLimit: '0.10' })
-    const app = createApp(db)
+    const app = createMainnetApp({ db })
     const tightened = await relayRequest(app, {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
@@ -876,6 +1267,7 @@ describe('behavior: mainnet billing gate', () => {
 
   test('behavior: refuses fee tokens the verified list does not resolve to USD', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     await activate(db)
     // EURC is verified yet non-USD; fee math reads micro-USD, so it refuses.
     const eurc = `0x${'e0'.repeat(20)}` as const
@@ -883,7 +1275,7 @@ describe('behavior: mainnet billing gate', () => {
       tokens: [{ address: eurc, currency: 'EUR', decimals: 6, name: 'Euro Coin', symbol: 'EURC' }],
     })
 
-    const app = createApp(db)
+    const app = createMainnetApp({ db, logger: (entry) => void entries.push(entry) })
     const request = async (feeToken: `0x${string}`) =>
       await relayRequest(app, {
         method: 'eth_signRawTransaction',
@@ -893,9 +1285,11 @@ describe('behavior: mainnet billing gate', () => {
     const nonUsd = await request(eurc)
     expect(nonUsd.error?.message).toBe('Fee token unsupported.')
     expect(nonUsd.error?.data).toStrictEqual({ code: 'fee_token_unsupported' })
+    expectSponsorshipCode({ code: 'fee_token_unsupported', entry: entries[0] })
     // Tokens absent from the verified list refuse the same way.
     const unverified = await request(`0x${'ab'.repeat(20)}`)
     expect(unverified.error?.data).toStrictEqual({ code: 'fee_token_unsupported' })
+    expectSponsorshipCode({ code: 'fee_token_unsupported', entry: entries[1] })
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(0)
   })
 
@@ -903,7 +1297,7 @@ describe('behavior: mainnet billing gate', () => {
     const db = TestApp.database()
     await activate(db)
 
-    const body = await relayRequest(createApp(db), {
+    const body = await relayRequest(createMainnetApp({ db }), {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
       token: 'secret_sponsor_prod',
@@ -915,6 +1309,7 @@ describe('behavior: mainnet billing gate', () => {
 
   test('behavior: refuses sponsorship over the period spend limit; raising restores', async () => {
     const db = TestApp.database()
+    const entries: Log.Entry[] = []
     await activate(db)
     await BillingSettings.upsert(db, { orgId: 'org_1', spendLimit: '1' })
     // $0.90 already finalized this window; a $0.50 cap would overshoot $1.
@@ -934,7 +1329,7 @@ describe('behavior: mainnet billing gate', () => {
       finalizedAt: new Date().toISOString(),
     })
 
-    const app = createApp(db)
+    const app = createMainnetApp({ db, logger: (entry) => void entries.push(entry) })
     const request = async () =>
       await relayRequest(app, {
         method: 'eth_signRawTransaction',
@@ -944,6 +1339,7 @@ describe('behavior: mainnet billing gate', () => {
     const refused = await request()
     expect(refused.error?.message).toBe('Spend limit exceeded.')
     expect(refused.error?.data).toStrictEqual({ code: 'spend_limit_exceeded' })
+    expectSponsorshipCode({ code: 'spend_limit_exceeded', entry: entries[0] })
 
     await BillingSettings.upsert(db, { orgId: 'org_1', spendLimit: '10' })
     const restored = await request()
@@ -968,7 +1364,7 @@ describe('behavior: mainnet billing gate', () => {
       transactionHash: `0x${'34'.repeat(32)}`,
     })
 
-    const body = await relayRequest(createApp(db), {
+    const body = await relayRequest(createMainnetApp({ db }), {
       method: 'eth_signRawTransaction',
       params: [await signSponsorable({ chainId: Viem.chainId.mainnet, ...halfDollarFees })],
       token: 'secret_sponsor_prod',
@@ -985,7 +1381,7 @@ describe('behavior: mainnet billing gate', () => {
     await activate(seed)
     // Limit fits exactly two $0.50 sponsorships.
     await BillingSettings.upsert(seed, { orgId: 'org_1', spendLimit: '1' })
-    const app = createApp(db)
+    const app = createMainnetApp({ db })
     // Distinct nonces → distinct envelopes → distinct rows, fired together.
     const results = await Promise.all(
       Array.from({ length: 6 }, async (_, nonce) =>
@@ -1339,3 +1735,38 @@ describe.runIf(TestStripe.secretKey)(
     )
   },
 )
+
+function createMainnetApp(options: createMainnetApp.Options = {}) {
+  return TestApp.create({
+    auth: { keys },
+    db: options.db ?? TestApp.database(),
+    ...(options.logger ? { logger: options.logger } : {}),
+    relay: { feePayer: { account: feePayerAccount } },
+    supportedChainIds: [Viem.chainId.mainnet],
+  })
+}
+
+declare namespace createMainnetApp {
+  /** Mainnet sponsorship test app options. */
+  type Options = {
+    /** Database source. */
+    db?: Db.Source | undefined
+    /** Structured request log sink. */
+    logger?: Log.Emit | undefined
+  }
+}
+
+function expectSponsorshipCode(options: expectSponsorshipCode.Options) {
+  expect(options.entry?.rpc?.dataCode).toBe(options.code)
+  expect(options.entry?.sponsorship?.reason).toBe(options.code)
+}
+
+declare namespace expectSponsorshipCode {
+  /** Expected canonical sponsorship code. */
+  type Options = {
+    /** Expected client and internal code. */
+    code: Log.SponsorshipReason
+    /** Structured request log entry. */
+    entry: Log.Entry | undefined
+  }
+}