tapimo 0.7.2 → 0.9.0

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

@@ -1,2994 +0,0 @@
-import { Hash, Hex, Value } from 'ox'
-import { Schema } from 'tapimo'
-import { decodeFunctionData, erc20Abi, maxUint256 } from 'viem'
-import { base } from 'viem/chains'
-import { tempoMainnet } from 'viem/tempo/chains'
-
-import * as Anvil from '../../../../test/Anvil.js'
-import * as FundingDepositAddresses from '../../../db/tables/fundingDepositAddresses.js'
-import * as FundingIdempotencyTable from '../../../db/tables/fundingIdempotency.js'
-import * as Cache from '../../../internal/Cache.js'
-import * as Cursor from '../../../internal/Cursor.js'
-import * as FundingCatalog from '../../../internal/funding/Catalog.js'
-import * as FundingDeposit from '../../../internal/funding/Deposit.js'
-import * as FundingDepositAddress from '../../../internal/funding/DepositAddress.js'
-import * as FundingProvider from '../../../internal/funding/Provider.js'
-import * as FundingTransfer from '../../../internal/funding/Transfer.js'
-import * as Idempotency from '../../../internal/Idempotency.js'
-import * as Across from '../../../internal/funding/providers/across.js'
-import * as Relay from '../../../internal/funding/providers/relay.js'
-import * as Rhino from '../../../internal/funding/providers/rhino.js'
-import * as Squid from '../../../internal/funding/providers/squid.js'
-import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
-import type * as Log from '../../../internal/Log.js'
-import * as Store from '../../../internal/Store.js'
-import * as TestApp from '../../../../test/App.js'
-import * as TestFunding from '../../../../test/Funding.js'
-import * as Funding from './funding.js'
-
-const db = TestApp.database()
-const relayApiKey = process.env.RELAY_API_KEY
-
-const providers = [
-  Across.across({
-    apiKey: 'across-api-key',
-    integratorId: '0xdead',
-    userAddress: '0x1111111111111111111111111111111111111111',
-  }),
-  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
-  Rhino.rhino(),
-  Squid.squid({
-    integratorId: 'squid-integrator-id',
-    userAddress: '0x1111111111111111111111111111111111111111',
-  }),
-  Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
-] as const
-
-/**
- * Providers with executable coverage on the static Base USDC → pathUSD
- * corridor. Each entry gets a fork execution suite (live quote, calls executed
- * on an anvil Base fork); covering another provider is one entry here.
- */
-const executableProviders = [
-  {
-    create: (sender: string) =>
-      Relay.relay({
-        ...(process.env.RELAY_API_KEY ? { apiKey: process.env.RELAY_API_KEY } : {}),
-        userAddress: sender,
-      }),
-    id: 'relay',
-  },
-] as const
-
-beforeAll(() => TestFunding.publish(db))
-
-function create(options: TestApp.create.Options = {}) {
-  return TestApp.create({ ...options, db })
-}
-
-describe('funding OpenAPI', () => {
-  test('publishes get operation ids for funding inventory', async () => {
-    const app = create({ auth: false })
-    const spec = await (await app.request('/openapi.json')).json()
-
-    expect({
-      chains: spec.paths['/v1/funding/chains'].get.operationId,
-      providers: spec.paths['/v1/funding/providers'].get.operationId,
-    }).toEqual({
-      chains: 'getFundingChains',
-      providers: 'getFundingProviders',
-    })
-  })
-})
-
-describe('GET /funding/quotes', () => {
-  test('publishes alphabetically ordered quote example fields', async () => {
-    const app = create({ auth: false })
-    const spec = await (await app.request('/openapi.json')).json()
-    const operation = spec.paths['/v1/funding/quotes'].get
-    const response = operation.responses['200'].content['application/json']
-    const fields = Object.keys(response.example.data[0])
-
-    expect(fields).toEqual([...fields].sort())
-  })
-
-  test('returns successful live quotes with output amounts', async () => {
-    const app = create({ providers: [relayProvider()] })
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-
-    expect(body.data).toHaveLength(1)
-    expect(body.data[0]).toMatchObject({
-      destinationAmount: {
-        baseUnits: '990000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.99',
-      },
-      destinationAmountMin: {
-        baseUnits: '980000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.98',
-      },
-      id: 'base-usdc-tempo-usdce-relay',
-      provider: { id: 'relay' },
-      quality: { liquiditySource: 'providerQuote', tier: 'liquid' },
-      quote: { sampledAt: '2026-01-01T00:00:00Z' },
-      sourceAmount: { baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' },
-    })
-    expect(body.data[0]?.sourceToken).not.toHaveProperty('amount')
-    expect(body.data[0]?.destinationToken).not.toHaveProperty('amount')
-  })
-
-  test('resolves token identifiers through the composed route', async () => {
-    const app = create({ providers: [relayProvider()] })
-    const identifiers = [
-      { destinationToken: 'usdc.e', name: 'symbol', sourceToken: 'USDC' },
-      { destinationToken: 'usdce', name: 'slug', sourceToken: 'usdc' },
-      {
-        destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
-        name: 'address',
-        sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-      },
-      {
-        destinationToken: 'eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50',
-        name: 'token key',
-        sourceToken: 'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-      },
-    ] as const
-    const results = []
-    for (const identifier of identifiers) {
-      const response = await app.request(
-        quoteUrl({
-          destinationToken: identifier.destinationToken,
-          sourceAmount: '1000000',
-          sourceChain: 'base',
-          sourceToken: identifier.sourceToken,
-        }),
-        { headers: TestApp.auth.headers },
-      )
-      const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-      results.push({
-        destinationToken: body.data[0]?.destinationToken.symbol,
-        name: identifier.name,
-        sourceToken: body.data[0]?.sourceToken.symbol,
-        status: response.status,
-      })
-    }
-
-    expect(results).toMatchInlineSnapshot(`
-      [
-        {
-          "destinationToken": "USDC.e",
-          "name": "symbol",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-        {
-          "destinationToken": "USDC.e",
-          "name": "slug",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-        {
-          "destinationToken": "USDC.e",
-          "name": "address",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-        {
-          "destinationToken": "USDC.e",
-          "name": "token key",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-      ]
-    `)
-  })
-
-  test('queries only the requested provider', async () => {
-    let acrossCalls = 0
-    let relayCalls = 0
-    const app = create({
-      providers: [
-        acrossProvider(() => {
-          acrossCalls += 1
-        }),
-        relayProvider(() => {
-          relayCalls += 1
-        }),
-      ],
-    })
-    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
-      headers: TestApp.auth.headers,
-    })
-
-    expect(response.status).toBe(200)
-    expect(acrossCalls).toBe(1)
-    expect(relayCalls).toBe(0)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-    expect(body.data[0]?.quote.expiresAt).toBe('2026-01-01T00:01:00Z')
-  })
-
-  test('returns non-EVM Rhino quotes with stable chain and token ids', async () => {
-    const app = create({ providers: [rhinoProvider()] })
-    const response = await app.request(
-      quoteUrl({
-        destinationToken: 'USDC.e',
-        provider: 'rhino',
-        sourceAmount: '1000000',
-        sourceChain: 'solana',
-        sourceToken: 'USDC',
-      }),
-      { headers: TestApp.auth.headers },
-    )
-
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-    expect(body.data[0]).toMatchObject({
-      id: 'solana-usdc-tempo-usdce-rhino',
-      provider: { id: 'rhino' },
-      sourceChain: {
-        addressFormat: 'base58',
-        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-        kind: 'solana',
-      },
-      sourceToken: {
-        tokenKey:
-          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-      },
-    })
-  })
-
-  test('returns an empty list when no provider is available', async () => {
-    const response = await create().request(quoteUrl(), {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-    expect(body.data).toEqual([])
-  })
-
-  test('returns an empty list when the provider reports no quote', async () => {
-    const entries: Log.Entry[] = []
-    const app = create({
-      logger: (entry) => {
-        entries.push(entry)
-      },
-      providers: [
-        withGetQuote('relay', async () => ({
-          sampledAt: '2026-01-01T00:00:00Z',
-          status: 'unavailable',
-        })),
-      ],
-    })
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-    expect(body.data).toEqual([])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        id: 'relay',
-        operation: 'getQuote',
-        outcome: 'unavailable',
-      },
-    ])
-  })
-
-  test('returns 502 when every matching provider fails', async () => {
-    const app = create({
-      providers: [
-        withGetQuote('relay', async () => {
-          throw new Error('upstream unavailable')
-        }),
-      ],
-    })
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-    expect(response.status).toBe(502)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('upstream_error')
-  })
-
-  test('logs provider quote deadlines as timeouts', async () => {
-    vi.useFakeTimers()
-    const entries: Log.Entry[] = []
-    const app = create({
-      logger: (entry) => {
-        entries.push(entry)
-      },
-      providers: [
-        withGetQuote('across', () => new Promise<FundingProvider.getQuote.ReturnType>(() => {})),
-      ],
-    })
-
-    try {
-      const response_promise = app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
-        headers: TestApp.auth.headers,
-      })
-      await vi.advanceTimersByTimeAsync(2_000)
-      const response = await response_promise
-
-      expect(response.status).toBe(502)
-      expect(entries[0]?.provider).toEqual({
-        failure: 'timeout',
-        id: 'across',
-        operation: 'getQuote',
-      })
-      expect(entries[0]?.fundingProviderAttempts).toEqual([
-        {
-          durationMs: expect.any(Number),
-          failure: 'timeout',
-          id: 'across',
-          operation: 'getQuote',
-          outcome: 'failed',
-        },
-      ])
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-
-  test('logs every failure when multiple providers fail', async () => {
-    const entries: Log.Entry[] = []
-    const app = create({
-      logger: (entry) => {
-        entries.push(entry)
-      },
-      providers: [
-        withGetQuote('across', async () => {
-          throw new TypeError('Across network failure')
-        }),
-        withGetQuote('relay', async () => {
-          throw new Error('Relay failure')
-        }),
-      ],
-    })
-
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-
-    expect(response.status).toBe(502)
-    expect(entries[0]?.provider).toEqual({
-      failure: 'network',
-      id: 'across',
-      operation: 'getQuote',
-    })
-    expect(entries[0]?.providerFailures).toEqual([
-      { failure: 'network', id: 'across', operation: 'getQuote' },
-      { failure: 'unknown', id: 'relay', operation: 'getQuote' },
-    ])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        failure: 'network',
-        id: 'across',
-        operation: 'getQuote',
-        outcome: 'failed',
-      },
-      {
-        durationMs: expect.any(Number),
-        failure: 'unknown',
-        id: 'relay',
-        operation: 'getQuote',
-        outcome: 'failed',
-      },
-    ])
-  })
-
-  test('logs failed providers when another provider returns a quote', async () => {
-    const entries: Log.Entry[] = []
-    const app = create({
-      logger: (entry) => {
-        entries.push(entry)
-      },
-      providers: [
-        withGetQuote('across', async () => {
-          throw new TypeError(`wallet ${'0xaa'.repeat(20)} could not reach secret-provider`)
-        }),
-        relayProvider(),
-      ],
-    })
-
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-
-    expect(response.status).toBe(200)
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        failure: 'network',
-        id: 'across',
-        operation: 'getQuote',
-        outcome: 'failed',
-      },
-      {
-        durationMs: expect.any(Number),
-        id: 'relay',
-        operation: 'getQuote',
-        outcome: 'available',
-      },
-    ])
-    expect(JSON.stringify(entries[0])).not.toContain('secret-provider')
-    expect(JSON.stringify(entries[0])).not.toContain('0xaa')
-  })
-
-  test('rejects successful provider results without output amounts', async () => {
-    const app = create({
-      providers: [
-        withGetQuote('relay', async () => ({
-          sampledAt: '2026-01-01T00:00:00Z',
-          status: 'available',
-        })),
-      ],
-    })
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-    expect(response.status).toBe(502)
-  })
-
-  test('rejects invalid query parameters', async () => {
-    const response = await create().request(
-      quoteUrl({ sourceAmount: '1000000', sourceChain: 'base' }),
-      { headers: TestApp.auth.headers },
-    )
-    expect(response.status).toBe(400)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('query_invalid')
-  })
-
-  test('rejects unsupported providers', async () => {
-    const response = await create().request(quoteUrl({ ...baseUsdcQuery, provider: 'bridge' }), {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(400)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('query_invalid')
-  })
-
-  test('rejects unsupported source chains', async () => {
-    const response = await create().request(
-      quoteUrl({ ...baseUsdcQuery, sourceChain: 'bitcoin' }),
-      {
-        headers: TestApp.auth.headers,
-      },
-    )
-    expect(response.status).toBe(400)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('query_invalid')
-  })
-
-  test('does not expose the removed routes endpoint', async () => {
-    const response = await create().request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000',
-      { headers: TestApp.auth.headers },
-    )
-    expect(response.status).toBe(404)
-  })
-})
-
-describe('GET /funding/chains', () => {
-  test('lists only inputs supported by quote providers', async () => {
-    const response = await create({ providers }).request('/v1/funding/chains', {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.getFundingChains.Response)
-
-    expect(body.data.map((chain) => chain.id)).toEqual([
-      'eip155:1',
-      'eip155:56',
-      'eip155:8453',
-      'eip155:137',
-      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      'tron:0x2b6653dc',
-    ])
-    expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
-      expect.arrayContaining(['USDC', 'USDT']),
-    )
-    expect(
-      body.data.flatMap((chain) => chain.tokens).every((token) => token.currency === 'USD'),
-    ).toBe(true)
-  })
-})
-
-describe('GET /funding/providers', () => {
-  test('lists supplied quote providers', async () => {
-    const app = create({ providers: [relayProvider()] })
-    const response = await app.request('/v1/funding/providers', {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.getFundingProviders.Response)
-
-    expect(body.data).toEqual([
-      {
-        id: 'relay',
-        name: 'Relay',
-      },
-    ])
-  })
-
-  test('isolates cached inventories between apps', async () => {
-    const store = Store.memory()
-    const relayApp = create({ cache: { store }, providers: [relayProvider()] })
-    const acrossApp = create({ cache: { store }, providers: [acrossProvider()] })
-
-    const relayResponse = await relayApp.request('/v1/funding/providers', {
-      headers: TestApp.auth.headers,
-    })
-    const acrossResponse = await acrossApp.request('/v1/funding/providers', {
-      headers: TestApp.auth.headers,
-    })
-    const relayBody = await TestApp.json(relayResponse, Funding.schema.getFundingProviders.Response)
-    const acrossBody = await TestApp.json(
-      acrossResponse,
-      Funding.schema.getFundingProviders.Response,
-    )
-
-    expect(relayBody.data.map((provider) => provider.id)).toEqual(['relay'])
-    expect(acrossBody.data.map((provider) => provider.id)).toEqual(['across'])
-  })
-
-  test('isolates cached inventories between database sources', async () => {
-    const first = TestApp.database()
-    const second = TestApp.database()
-    const store = Store.memory()
-    await TestFunding.publish(first)
-    await FundingCatalog.publish(second, { ...TestFunding.data, routes: [] })
-    const firstApp = TestApp.create({ cache: { store }, db: first, providers: [relayProvider()] })
-    const secondApp = TestApp.create({ cache: { store }, db: second, providers: [relayProvider()] })
-
-    const firstResponse = await firstApp.request('/v1/funding/providers', {
-      headers: TestApp.auth.headers,
-    })
-    const secondResponse = await secondApp.request('/v1/funding/providers', {
-      headers: TestApp.auth.headers,
-    })
-    const firstBody = await TestApp.json(firstResponse, Funding.schema.getFundingProviders.Response)
-    const secondBody = await TestApp.json(
-      secondResponse,
-      Funding.schema.getFundingProviders.Response,
-    )
-
-    expect(firstBody.data.map((provider) => provider.id)).toEqual(['relay'])
-    expect(secondBody.data).toEqual([])
-  })
-
-  test('does not expose the removed generic provider endpoint', async () => {
-    const response = await create().request('/v1/providers', {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(404)
-  })
-})
-
-describe('POST /funding/deposit-addresses', () => {
-  test('requires funding:write and an idempotency key', async () => {
-    const app = transfersApp({ providers: [depositAddressProvider()] })
-    expect((await postDepositAddress(app, { headers: {} })).status).toBe(401)
-    expect((await postDepositAddress(app, { key: fundingReader })).status).toBe(403)
-    const response = await postDepositAddress(app, {
-      headers: { authorization: `Bearer ${fundingWriter.token}` },
-    })
-    expect(response.status).toBe(400)
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_key_required',
-    )
-  })
-
-  test('requires a source amount', async () => {
-    const { amount: _amount, ...body } = depositAddressBody
-    const response = await postDepositAddress(
-      transfersApp({ providers: [depositAddressProvider()] }),
-      { body },
-    )
-
-    expect({ body: await response.json(), status: response.status }).toMatchInlineSnapshot(
-      {
-        body: { requestId: expect.any(String) },
-      },
-      `
-      {
-        "body": {
-          "error": {
-            "code": "body_invalid",
-            "details": [
-              {
-                "message": "Invalid input: expected string, received undefined",
-                "path": [
-                  "amount",
-                ],
-              },
-            ],
-            "message": "Check the request body and try again.",
-          },
-          "requestId": Any<String>,
-        },
-        "status": 400,
-      }
-    `,
-    )
-  })
-
-  test('creates a reusable address and persists private provider correlation', async () => {
-    let seen: FundingProvider.createDepositAddress.Parameters | undefined
-    const app = transfersApp({
-      providers: [
-        depositAddressProvider('TBXSw8fM4jpQkGc6zZjsVABFpVN7UvXPdV', (input) => {
-          seen = input
-        }),
-      ],
-    })
-    const response = await postDepositAddress(app, {
-      body: { ...depositAddressBody, destinationToken: 'usdt0', sourceToken: 'usdt' },
-    })
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
-    expect(body).toMatchObject({
-      address: 'TBXSw8fM4jpQkGc6zZjsVABFpVN7UvXPdV',
-      destinationToken: { symbol: 'USDT0' },
-      provider: { id: 'relay', name: 'Relay' },
-      recipient: depositAddressBody.recipient,
-      refundAddress: depositAddressBody.refundAddress,
-      sourceChain: { id: 'tron:0x2b6653dc' },
-      sourceToken: { symbol: 'USDT' },
-      status: 'active',
-    })
-    expect(seen).toMatchObject({
-      recipient: depositAddressBody.recipient,
-      refundAddress: depositAddressBody.refundAddress,
-    })
-    const record = await FundingDepositAddresses.get(db, body.id)
-    expect(record).toMatchObject({
-      deliveryStrategy: 'provider',
-      providerOutputToken: body.destinationToken,
-      providerRequestIds: ['relay_request_1'],
-      providerState: { checkEndpoint: '/intents/status/v3?requestId=relay_request_1' },
-    })
-  })
-
-  test('resolves token identifiers through the composed route', async () => {
-    const app = transfersApp({
-      providers: [depositAddressProvider('T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb')],
-    })
-    const identifiers = [
-      { destinationToken: 'usdt0', name: 'alias', sourceToken: 'usdt' },
-      {
-        destinationToken: depositAddressBody.destinationToken,
-        name: 'address',
-        sourceToken: depositAddressBody.sourceToken,
-      },
-      {
-        destinationToken: 'eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73',
-        name: 'token key',
-        sourceToken: 'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-      },
-    ] as const
-    const results = []
-    for (const identifier of identifiers) {
-      const response = await postDepositAddress(app, {
-        body: {
-          ...depositAddressBody,
-          destinationToken: identifier.destinationToken,
-          recipient: `0x${'55'.repeat(20)}`,
-          refundAddress: 'TD5gsCwxykWsLN9aPrq2TAfNjByuZKYp4E',
-          sourceToken: identifier.sourceToken,
-        },
-      })
-      const body = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
-      results.push({
-        destinationToken: body.destinationToken.symbol,
-        name: identifier.name,
-        sourceToken: body.sourceToken.symbol,
-        status: response.status,
-      })
-    }
-
-    expect(results).toMatchInlineSnapshot(`
-      [
-        {
-          "destinationToken": "USDT0",
-          "name": "alias",
-          "sourceToken": "USDT",
-          "status": 200,
-        },
-        {
-          "destinationToken": "USDT0",
-          "name": "address",
-          "sourceToken": "USDT",
-          "status": 200,
-        },
-        {
-          "destinationToken": "USDT0",
-          "name": "token key",
-          "sourceToken": "USDT",
-          "status": 200,
-        },
-      ]
-    `)
-  })
-
-  test('omits newly quoted terms from a matching reusable address', async () => {
-    let calls = 0
-    const body = { ...depositAddressBody, refundAddress: 'TD5gsCwxykWsLN9aPrq2TAfNjByuZKYp4E' }
-    const app = transfersApp({
-      providers: [
-        depositAddressProvider('TEdvoHEatmDKvTh3o9vBRB9Vdtbhn4QFhy', () => {
-          calls += 1
-        }),
-      ],
-    })
-    const first = await TestApp.json(
-      await postDepositAddress(app, { body, idempotencyKey: nextDepositAddressKey() }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-    const second = await TestApp.json(
-      await postDepositAddress(app, {
-        body: { ...body, amount: '200000000' },
-        idempotencyKey: nextDepositAddressKey(),
-      }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-    if (!('sourceAmount' in first)) throw new Error('Expected newly provisioned terms.')
-
-    expect({
-      calls,
-      firstHasQuote: 'quote' in first,
-      firstId: first.id,
-      firstSourceAmount: first.sourceAmount.baseUnits,
-      secondHasQuote: 'quote' in second,
-      secondId: second.id,
-    }).toMatchInlineSnapshot(
-      {
-        firstId: expect.any(String),
-        secondId: expect.any(String),
-      },
-      `
-      {
-        "calls": 2,
-        "firstHasQuote": true,
-        "firstId": Any<String>,
-        "firstSourceAmount": "100000000",
-        "secondHasQuote": false,
-        "secondId": Any<String>,
-      }
-    `,
-    )
-    expect(second.id).toBe(first.id)
-  })
-
-  test('stores subsidized addresses as a separate reusable identity', async () => {
-    const inputs: FundingProvider.createDepositAddress.Parameters[] = []
-    const app = transfersApp({
-      providers: [
-        withCreateDepositAddress('relay', async (input) => {
-          inputs.push(input)
-          return {
-            address: inputs.length === 1 ? `0x${'31'.repeat(20)}` : `0x${'32'.repeat(20)}`,
-            correlation: { requestId: `relay_request_${inputs.length}` },
-            destinationAmount: '1000000',
-            destinationAmountMin: '1000000',
-            fees: [],
-            sampledAt: '2026-08-04T00:00:00.000Z',
-          }
-        }),
-      ],
-    })
-    const body = {
-      ...depositAddressBody,
-      refundAddress: `0x${'33'.repeat(20)}`,
-      sourceChain: 'base',
-      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
-    }
-    const standard = await TestApp.json(
-      await postDepositAddress(app, { body }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-    const subsidized = await TestApp.json(
-      await postDepositAddress(app, { body: { ...body, subsidize: true } }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-
-    expect({
-      distinct: standard.id !== subsidized.id,
-      inputs: inputs.map(({ subsidize }) => subsidize),
-      standard: standard.subsidize,
-      subsidized: subsidized.subsidize,
-    }).toMatchInlineSnapshot(`
-      {
-        "distinct": true,
-        "inputs": [
-          false,
-          true,
-        ],
-        "standard": false,
-        "subsidized": true,
-      }
-    `)
-  })
-
-  test('normalizes EVM accounts before provisioning and matching', async () => {
-    const inputs: FundingProvider.createDepositAddress.Parameters[] = []
-    const recipient = '0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD'
-    const refundAddress = '0x1234567890AbcdEF1234567890aBcdef12345678'
-    const body = {
-      ...depositAddressBody,
-      recipient,
-      refundAddress,
-      sourceChain: 'base',
-      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
-    }
-    const app = transfersApp({
-      providers: [
-        depositAddressProvider(`0x${'99'.repeat(20)}`, (input) => {
-          inputs.push(input)
-        }),
-      ],
-    })
-    const first = await TestApp.json(
-      await postDepositAddress(app, { body, idempotencyKey: nextDepositAddressKey() }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-    const second = await TestApp.json(
-      await postDepositAddress(app, {
-        body: {
-          ...body,
-          recipient: recipient.toLowerCase(),
-          refundAddress: refundAddress.toLowerCase(),
-        },
-        idempotencyKey: nextDepositAddressKey(),
-      }),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-
-    expect({
-      first: { recipient: first.recipient, refundAddress: first.refundAddress },
-      inputs: inputs.map(({ recipient, refundAddress }) => ({ recipient, refundAddress })),
-      reused: first.id === second.id,
-      second: { recipient: second.recipient, refundAddress: second.refundAddress },
-    }).toMatchInlineSnapshot(`
-      {
-        "first": {
-          "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
-          "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
-        },
-        "inputs": [
-          {
-            "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
-            "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
-          },
-          {
-            "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
-            "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
-          },
-        ],
-        "reused": true,
-        "second": {
-          "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
-          "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
-        },
-      }
-    `)
-  })
-
-  test('keeps the stored reusable address when the provider rotates addresses', async () => {
-    const body = { ...depositAddressBody, recipient: `0x${'22'.repeat(20)}` }
-    const first = await TestApp.json(
-      await postDepositAddress(
-        transfersApp({
-          providers: [depositAddressProvider('TGCAjMXComunWZEXCT1LPBdcYbDVuyexBv')],
-        }),
-        { body, idempotencyKey: nextDepositAddressKey() },
-      ),
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-
-    let calls = 0
-    const app = transfersApp({
-      providers: [
-        depositAddressProvider('THkQfRopincF6emzbk6VMC7jTHqJ8MP8g7', () => {
-          calls += 1
-        }),
-      ],
-    })
-    const idempotencyKey = nextDepositAddressKey()
-    const response = await postDepositAddress(app, {
-      body: { ...body, amount: '200000000' },
-      idempotencyKey,
-    })
-    const second = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
-
-    expect({
-      address: second.address,
-      calls,
-      hasQuote: 'quote' in second,
-      reused: second.id === first.id,
-      status: response.status,
-    }).toMatchInlineSnapshot(
-      {
-        address: expect.any(String),
-      },
-      `
-      {
-        "address": Any<String>,
-        "calls": 1,
-        "hasQuote": false,
-        "reused": true,
-        "status": 200,
-      }
-    `,
-    )
-    expect(second.address).toBe(first.address)
-    expect(
-      await TestApp.json(
-        await postDepositAddress(app, {
-          body: { ...body, amount: '200000000' },
-          idempotencyKey,
-        }),
-        Funding.schema.createFundingDepositAddress.Response,
-      ),
-    ).toEqual(second)
-    expect(calls).toBe(1)
-  })
-
-  test('rejects a refund address from another chain', async () => {
-    const response = await postDepositAddress(
-      transfersApp({ providers: [depositAddressProvider()] }),
-      { body: { ...depositAddressBody, refundAddress: `0x${'11'.repeat(20)}` } },
-    )
-
-    expect({ body: await response.json(), status: response.status }).toMatchInlineSnapshot(
-      {
-        body: { requestId: expect.any(String) },
-      },
-      `
-      {
-        "body": {
-          "error": {
-            "code": "body_invalid",
-            "message": "Invalid \`refundAddress\`.",
-          },
-          "requestId": Any<String>,
-        },
-        "status": 400,
-      }
-    `,
-    )
-  })
-
-  test('replays matching idempotent requests and rejects changed input', async () => {
-    const body = { ...depositAddressBody, refundAddress: 'TKJebW6SdoJhgkKU13BeKCbrMzT6HeQhJ6' }
-    const app = transfersApp({
-      providers: [depositAddressProvider('TLrtXaP4Yp1AGqrwQLGoHD5yGh4tTAvPbe')],
-    })
-    const idempotencyKey = nextDepositAddressKey()
-    const first = await postDepositAddress(app, { body, idempotencyKey })
-    const replay = await postDepositAddress(app, { body, idempotencyKey })
-    expect(replay.status).toBe(200)
-    expect(await replay.json()).toEqual(await first.json())
-
-    const conflict = await postDepositAddress(app, {
-      body: { ...depositAddressBody, refundAddress: 'TNR8TefgTphcrwQQodMxFDa6BPggc2CZeE' },
-      idempotencyKey,
-    })
-    expect(conflict.status).toBe(409)
-    expect(((await conflict.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_conflict',
-    )
-  })
-
-  test('defaults subsidize for legacy idempotency replays', async () => {
-    const app = transfersApp({
-      providers: [depositAddressProvider(`0x${'45'.repeat(20)}`)],
-    })
-    const requestBody = {
-      ...depositAddressBody,
-      refundAddress: `0x${'44'.repeat(20)}`,
-      sourceChain: 'base',
-      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
-    }
-    const idempotencyKey = nextDepositAddressKey()
-    const first = await postDepositAddress(app, { body: requestBody, idempotencyKey })
-    const response = await TestApp.json(first, Funding.schema.createFundingDepositAddress.Response)
-    const { subsidize: _, ...legacy } = response
-    await db.kysely
-      .updateTable('funding_idempotency_requests')
-      .set({ response: JSON.stringify(legacy) })
-      .where('apiKeyId', '=', fundingWriter.id)
-      .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
-      .returningAll()
-      .executeTakeFirstOrThrow()
-
-    const replay = await postDepositAddress(app, { body: requestBody, idempotencyKey })
-    const response_replay = await TestApp.json(
-      replay,
-      Funding.schema.createFundingDepositAddress.Response,
-    )
-
-    expect({ status: replay.status, subsidize: response_replay.subsidize }).toMatchInlineSnapshot(`
-      {
-        "status": 200,
-        "subsidize": false,
-      }
-    `)
-  })
-
-  test('preserves the idempotency fingerprint when subsidize is omitted', async () => {
-    const idempotencyKey = nextDepositAddressKey()
-    await FundingIdempotencyTable.claim(db, {
-      apiKeyId: fundingWriter.id,
-      keyHash: Idempotency.inputHash(idempotencyKey),
-      requestHash: Idempotency.inputHash({
-        body: depositAddressBody,
-        endpoint: 'POST /v1/funding/deposit-addresses',
-      }),
-      ttlMs: 60_000,
-    })
-
-    const response = await postDepositAddress(transfersApp(), { idempotencyKey })
-
-    expect({ body: await response.json(), status: response.status }).toMatchInlineSnapshot(
-      {
-        body: { requestId: expect.any(String) },
-      },
-      `
-      {
-        "body": {
-          "error": {
-            "code": "idempotency_in_progress",
-            "message": "An equivalent funding deposit address creation is still running.",
-          },
-          "requestId": Any<String>,
-        },
-        "status": 409,
-      }
-    `,
-    )
-  })
-
-  test('includes the creation endpoint in the idempotency fingerprint', async () => {
-    const idempotencyKey = nextDepositAddressKey()
-    await FundingIdempotencyTable.claim(db, {
-      apiKeyId: fundingWriter.id,
-      keyHash: Idempotency.inputHash(idempotencyKey),
-      requestHash: Idempotency.inputHash(depositAddressBody),
-      ttlMs: 60_000,
-    })
-
-    const response = await postDepositAddress(
-      transfersApp({ providers: [depositAddressProvider()] }),
-      { idempotencyKey },
-    )
-    expect(response.status).toBe(409)
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_conflict',
-    )
-  })
-
-  test('returns not available without a registered provider', async () => {
-    const response = await postDepositAddress(transfersApp({ providers: [] }))
-    expect(response.status).toBe(404)
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'deposit_address_not_available',
-    )
-  })
-
-  test('reports unexpected provider failures', async () => {
-    const entries: Log.Entry[] = []
-    const app = transfersApp({
-      logger: (entry) => {
-        entries.push(entry)
-      },
-      providers: [
-        withCreateDepositAddress('relay', async () => {
-          throw new Error('upstream failed')
-        }),
-      ],
-    })
-    const response = await postDepositAddress(app, {
-      body: { ...depositAddressBody, refundAddress: 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb' },
-    })
-    expect(response.status).toBe(502)
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'upstream_error',
-    )
-    expect(entries.at(-1)).toMatchObject({
-      provider: {
-        failure: 'unknown',
-        id: 'relay',
-        operation: 'createDepositAddress',
-      },
-      status: 502,
-    })
-  })
-})
-
-describe('POST /webhooks/funding/relay', () => {
-  test('authenticates and enqueues a bounded reconciliation hint', async () => {
-    const secret = 'relay-webhook-secret'
-    const address = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
-        provider: { id: 'relay', name: 'Relay' },
-        recipient: `0x${'99'.repeat(20)}`,
-      }),
-    })
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
-    const app = transfersApp({
-      providers: [
-        Relay.relay({
-          apiKey: secret,
-          webhook: {
-            db,
-            dispatch: async (message) => {
-              dispatched.push(message)
-            },
-          },
-        }),
-      ],
-    })
-    const body = JSON.stringify({
-      data: {
-        depositAddress: { address: address.address },
-        requestId: 'relay-child-request',
-      },
-      event: 'request.status.updated',
-    })
-    const timestamp = String(Math.floor(Date.now() / 1_000))
-    const signature = Hash.hmac256(
-      Hex.fromString(secret),
-      Hex.fromString(`${timestamp}.${body}`),
-    ).slice(2)
-    const response = await app.request('/webhooks/funding/relay', {
-      body,
-      headers: {
-        'x-signature-sha256': signature,
-        'x-signature-timestamp': timestamp,
-      },
-      method: 'POST',
-    })
-
-    expect({ dispatched, status: response.status }).toMatchInlineSnapshot(`
-      {
-        "dispatched": [
-          {
-            "addressId": "${address.id}",
-            "requestId": "relay-child-request",
-            "type": "funding:deposit-address:reconcile",
-          },
-        ],
-        "status": 204,
-      }
-    `)
-  })
-
-  test('rejects unauthenticated events', async () => {
-    const app = transfersApp({
-      providers: [
-        Relay.relay({
-          apiKey: 'relay-webhook-secret',
-          webhook: { db, dispatch: async () => {} },
-        }),
-      ],
-    })
-    const response = await app.request('/webhooks/funding/relay', {
-      body: '{}',
-      method: 'POST',
-    })
-
-    expect(response.status).toMatchInlineSnapshot('401')
-  })
-})
-
-describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
-  test('provisions and persists a reusable address through Relay', async () => {
-    const app = transfersApp({
-      providers: [Relay.relay({ apiKey: relayApiKey })],
-    })
-    const response = await postDepositAddress(app, {
-      body: { ...depositAddressBody, recipient: `0x${'77'.repeat(20)}` },
-    })
-
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
-    expect(body).toMatchInlineSnapshot(
-      {
-        address: expect.any(String),
-        createdAt: expect.any(String),
-        destinationAmount: {
-          baseUnits: expect.any(String),
-          formatted: expect.any(String),
-        },
-        destinationAmountMin: {
-          baseUnits: expect.any(String),
-          formatted: expect.any(String),
-        },
-        fees: expect.any(Array),
-        id: expect.any(String),
-        quote: { sampledAt: expect.any(String) },
-        updatedAt: expect.any(String),
-      },
-      `
-      {
-        "address": Any<String>,
-        "createdAt": Any<String>,
-        "destinationAmount": {
-          "baseUnits": Any<String>,
-          "currency": "USD",
-          "decimals": 6,
-          "formatted": Any<String>,
-        },
-        "destinationAmountMin": {
-          "baseUnits": Any<String>,
-          "currency": "USD",
-          "decimals": 6,
-          "formatted": Any<String>,
-        },
-        "destinationChain": {
-          "addressFormat": "hex",
-          "id": "eip155:4217",
-          "kind": "evm",
-          "name": "Tempo",
-        },
-        "destinationToken": {
-          "address": "0x20c00000000000000000000014f22ca97301eb73",
-          "currency": "USD",
-          "decimals": 6,
-          "name": "USDT0",
-          "standard": "TIP-20",
-          "symbol": "USDT0",
-          "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
-          "verified": true,
-        },
-        "fees": Any<Array>,
-        "id": Any<String>,
-        "provider": {
-          "id": "relay",
-          "name": "Relay",
-        },
-        "quote": {
-          "sampledAt": Any<String>,
-        },
-        "recipient": "0x7777777777777777777777777777777777777777",
-        "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
-        "sourceAmount": {
-          "baseUnits": "100000000",
-          "currency": "USD",
-          "decimals": 6,
-          "formatted": "100",
-        },
-        "sourceChain": {
-          "addressFormat": "base58check",
-          "id": "tron:0x2b6653dc",
-          "kind": "tron",
-          "name": "Tron",
-        },
-        "sourceToken": {
-          "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-          "currency": "USD",
-          "decimals": 6,
-          "name": "Tether USD",
-          "standard": "TRC-20",
-          "symbol": "USDT",
-          "tokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-          "verified": true,
-        },
-        "status": "active",
-        "subsidize": false,
-        "updatedAt": Any<String>,
-      }
-    `,
-    )
-    const record = await FundingDepositAddresses.get(db, body.id)
-    expect(record).toMatchInlineSnapshot(
-      {
-        address: expect.any(String),
-        createdAt: expect.any(String),
-        id: expect.any(String),
-        nextPollAt: expect.any(String),
-        providerRequestIds: [expect.any(String)],
-        providerState: expect.any(Object),
-        snapshot: { address: expect.any(String) },
-        updatedAt: expect.any(String),
-      },
-      `
-      {
-        "address": Any<String>,
-        "apiKeyId": "key_funding_writer",
-        "createdAt": Any<String>,
-        "deliveryStrategy": "provider",
-        "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
-        "environment": "production",
-        "id": Any<String>,
-        "lastPolledAt": null,
-        "nextPollAt": Any<String>,
-        "orgId": "org_funding",
-        "pollFailureCount": 0,
-        "pollLeaseUntil": null,
-        "pollLeaseVersion": 0,
-        "projectId": null,
-        "providerId": "relay",
-        "providerOutputToken": {
-          "address": "0x20c00000000000000000000014f22ca97301eb73",
-          "currency": "USD",
-          "decimals": 6,
-          "name": "USDT0",
-          "standard": "TIP-20",
-          "symbol": "USDT0",
-          "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
-          "verified": true,
-        },
-        "providerRequestIds": [
-          Any<String>,
-        ],
-        "providerState": Any<Object>,
-        "recipient": "0x7777777777777777777777777777777777777777",
-        "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
-        "snapshot": {
-          "address": Any<String>,
-          "destinationChain": {
-            "addressFormat": "hex",
-            "id": "eip155:4217",
-            "kind": "evm",
-            "name": "Tempo",
-          },
-          "destinationToken": {
-            "address": "0x20c00000000000000000000014f22ca97301eb73",
-            "currency": "USD",
-            "decimals": 6,
-            "name": "USDT0",
-            "standard": "TIP-20",
-            "symbol": "USDT0",
-            "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
-            "verified": true,
-          },
-          "provider": {
-            "id": "relay",
-            "name": "Relay",
-          },
-          "recipient": "0x7777777777777777777777777777777777777777",
-          "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
-          "sourceChain": {
-            "addressFormat": "base58check",
-            "id": "tron:0x2b6653dc",
-            "kind": "tron",
-            "name": "Tron",
-          },
-          "sourceToken": {
-            "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-            "currency": "USD",
-            "decimals": 6,
-            "name": "Tether USD",
-            "standard": "TRC-20",
-            "symbol": "USDT",
-            "tokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-            "verified": true,
-          },
-          "subsidize": false,
-        },
-        "sourceChainId": "tron:0x2b6653dc",
-        "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-        "status": "active",
-        "subsidize": false,
-        "updatedAt": Any<String>,
-        "version": 1,
-      }
-    `,
-    )
-  })
-})
-
-describe('GET /funding/deposit-addresses/:id', () => {
-  test('requires funding:read and returns the owned address', async () => {
-    const app = transfersApp()
-    const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}`
-    expect((await app.request(path)).status).toBe(401)
-    expect((await app.request(path, as(TestApp.key))).status).toBe(403)
-
-    const response = await app.request(path, as(fundingReader))
-    expect(response.status).toBe(200)
-    expect({
-      cacheControl: response.headers.get('cache-control'),
-      etag: response.headers.get('etag'),
-    }).toMatchInlineSnapshot(`
-      {
-        "cacheControl": "no-store",
-        "etag": null,
-      }
-    `)
-    expect(response.headers.get('vary')).toBe('Accept-Encoding, Authorization, Tempo-API-Key')
-    const body = await TestApp.json(response, Funding.schema.getFundingDepositAddress.Response)
-    expect(body).toEqual(FundingDepositAddress.toPublic(record))
-    expect(body).not.toHaveProperty('providerOutputToken')
-    expect(body).not.toHaveProperty('providerRequestIds')
-  })
-
-  test('hides foreign, project-inaccessible, and absent addresses', async () => {
-    const app = transfersApp()
-    const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}`
-
-    for (const key of [fundingForeign, fundingProjectReader]) {
-      const response = await app.request(path, as(key))
-      expect(response.status).toBe(404)
-      expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-        'funding_deposit_address_not_found',
-      )
-    }
-
-    const absent = await app.request(
-      '/v1/funding/deposit-addresses/fda_000000000000000_000000000000000000000000',
-      as(fundingReader),
-    )
-    expect(absent.status).toBe(404)
-  })
-})
-
-describe('GET /funding/deposit-addresses/:id/deposits', () => {
-  test('pages deposits newest-first under an owned address', async () => {
-    const app = transfersApp()
-    const address = await seedDepositAddress()
-    const first = await seedDeposit(address)
-    const second = await seedDeposit(address)
-    const third = await seedDeposit(address)
-    const fourth = await seedDeposit(address)
-    const fifth = await seedDeposit(address)
-    const sixth = await seedDeposit(address)
-
-    const response = await app.request(
-      `/v1/funding/deposit-addresses/${address.id}/deposits?limit=5`,
-      as(fundingReader),
-    )
-    expect(response.status).toBe(200)
-    expect({
-      cacheControl: response.headers.get('cache-control'),
-      etag: response.headers.get('etag'),
-    }).toMatchInlineSnapshot(`
-      {
-        "cacheControl": "no-store",
-        "etag": null,
-      }
-    `)
-    const body = await TestApp.json(
-      response,
-      Funding.schema.listFundingDepositAddressDeposits.Response,
-    )
-    expect(body.data.map((deposit) => deposit.id)).toEqual([
-      sixth.id,
-      fifth.id,
-      fourth.id,
-      third.id,
-      second.id,
-    ])
-    expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
-
-    const next = await TestApp.json(
-      await app.request(
-        `/v1/funding/deposit-addresses/${address.id}/deposits?limit=5&cursor=${body.nextCursor}`,
-        as(fundingReader),
-      ),
-      Funding.schema.listFundingDepositAddressDeposits.Response,
-    )
-    expect(next.data.map((deposit) => deposit.id)).toEqual([first.id])
-    expect(next.nextCursor).toBeNull()
-  })
-
-  test('returns a provider-observed deposit before source verification', async () => {
-    const app = transfersApp()
-    const address = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
-        provider: { id: 'relay_observed', name: 'Relay' },
-        recipient: `0x${'31'.repeat(20)}`,
-      }),
-    })
-    const sourceTransactionHash = `0x${'ab'.repeat(32)}`
-    await FundingDeposit.create(db, {
-      now: new Date('2026-01-04T00:00:00.000Z'),
-      providerRequestId: 'relay-observed-request',
-      snapshot: {
-        depositAddressId: address.id,
-        destinationChain: address.snapshot.destinationChain,
-        destinationToken: address.snapshot.destinationToken,
-        provider: address.snapshot.provider,
-        recipient: address.recipient,
-        refundAddress: address.refundAddress,
-        sourceChain: address.snapshot.sourceChain,
-        sourceToken: address.snapshot.sourceToken,
-        sourceTransactionHashes: [sourceTransactionHash],
-      },
-      sourceTransactionHash,
-    })
-
-    const response = await app.request(
-      `/v1/funding/deposit-addresses/${address.id}/deposits`,
-      as(fundingReader),
-    )
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(
-      response,
-      Funding.schema.listFundingDepositAddressDeposits.Response,
-    )
-    expect(body).toMatchInlineSnapshot(
-      {
-        data: [
-          {
-            createdAt: expect.any(String),
-            depositAddressId: expect.any(String),
-            id: expect.any(String),
-            updatedAt: expect.any(String),
-          },
-        ],
-      },
-      `
-      {
-        "data": [
-          {
-            "createdAt": Any<String>,
-            "depositAddressId": Any<String>,
-            "destinationChain": {
-              "addressFormat": "hex",
-              "id": "eip155:4217",
-              "kind": "evm",
-              "name": "Tempo",
-            },
-            "destinationToken": {
-              "address": "0x20c00000000000000000000014f22ca97301eb73",
-              "currency": "USD",
-              "decimals": 6,
-              "name": "USDT0",
-              "standard": "TIP-20",
-              "symbol": "USDT0",
-              "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
-              "verified": true,
-            },
-            "id": Any<String>,
-            "provider": {
-              "id": "relay_observed",
-              "name": "Relay",
-            },
-            "recipient": "0x3131313131313131313131313131313131313131",
-            "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
-            "sourceChain": {
-              "addressFormat": "base58check",
-              "id": "tron:0x2b6653dc",
-              "kind": "tron",
-              "name": "Tron",
-            },
-            "sourceToken": {
-              "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-              "currency": "USD",
-              "decimals": 6,
-              "name": "Tether USD",
-              "standard": "TRC-20",
-              "symbol": "USDT",
-              "tokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-              "verified": true,
-            },
-            "sourceTransactionHashes": [
-              "0xabababababababababababababababababababababababababababababababab",
-            ],
-            "status": "detected",
-            "updatedAt": Any<String>,
-          },
-        ],
-        "nextCursor": null,
-      }
-    `,
-    )
-  })
-
-  test('returns the parent not-found error before listing deposits', async () => {
-    const app = transfersApp()
-    const address = await seedDepositAddress({ orgId: fundingForeign.orgId })
-    const response = await app.request(
-      `/v1/funding/deposit-addresses/${address.id}/deposits`,
-      as(fundingReader),
-    )
-    expect(response.status).toBe(404)
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'funding_deposit_address_not_found',
-    )
-  })
-})
-
-describe('GET /funding/deposits/:id', () => {
-  test('returns the owned deposit without private reconciliation state', async () => {
-    const app = transfersApp()
-    const address = await seedDepositAddress()
-    const record = await seedDeposit(address, {
-      providerRequestIds: ['relay-private'],
-      providerState: { request: 'private' },
-    })
-    const response = await app.request(`/v1/funding/deposits/${record.id}`, as(fundingReader))
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe(Cache.policies.state)
-    const body = await TestApp.json(response, Funding.schema.getFundingDeposit.Response)
-    expect(body).toEqual(FundingDeposit.toPublic(record))
-    expect(body).not.toHaveProperty('providerRequestIds')
-    expect(body).not.toHaveProperty('providerState')
-  })
-
-  test('hides foreign and absent deposits', async () => {
-    const app = transfersApp()
-    const address = await seedDepositAddress()
-    const record = await seedDeposit(address)
-    expect(
-      (await app.request(`/v1/funding/deposits/${record.id}`, as(fundingForeign))).status,
-    ).toBe(404)
-    expect(
-      (
-        await app.request(
-          '/v1/funding/deposits/fdp_000000000000000_000000000000000000000000',
-          as(fundingReader),
-        )
-      ).status,
-    ).toBe(404)
-  })
-})
-
-describe('GET /funding/transfers', () => {
-  test('requires the funding:read scope', async () => {
-    const app = transfersApp()
-    expect((await app.request('/v1/funding/transfers')).status).toBe(401)
-    const forbidden = await app.request('/v1/funding/transfers', as(TestApp.key))
-    expect(forbidden.status).toBe(403)
-  })
-
-  test('pages own transfers newest-first', async () => {
-    const app = transfersApp()
-    const first = await seedTransfer()
-    const second = await seedTransfer()
-    const third = await seedTransfer()
-    await seedTransfer({ orgId: fundingForeign.orgId })
-
-    const response = await app.request('/v1/funding/transfers?limit=5', {
-      headers: { 'tempo-api-key': fundingReader.token },
-    })
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe(Cache.policies.feed)
-    const etag = response.headers.get('etag') ?? ''
-    expect(etag).not.toBe('')
-    expect(response.headers.get('vary')).toBe('Accept-Encoding, Authorization, Tempo-API-Key')
-    const body = await TestApp.json(response, Funding.schema.listFundingTransfers.Response)
-    expect(body.data.map((transfer) => transfer.id)).toEqual([third.id, second.id, first.id])
-    expect(body.nextCursor).toBeNull()
-    expect(body.meta).toBeUndefined()
-
-    const unchanged = await app.request('/v1/funding/transfers?limit=5', {
-      headers: { 'if-none-match': etag, 'tempo-api-key': fundingReader.token },
-    })
-    expect(unchanged.status).toBe(304)
-    expect(unchanged.headers.get('cache-control')).toBe(Cache.policies.feed)
-    expect(unchanged.headers.get('vary')).toBe('Accept-Encoding, Authorization, Tempo-API-Key')
-
-    const paged = await TestApp.json(
-      await app.request(`/v1/funding/transfers?limit=5&cursor=${second.id}`, as(fundingReader)),
-      Funding.schema.listFundingTransfers.Response,
-    )
-    expect(paged.data.map((transfer) => transfer.id)).toEqual([first.id])
-  })
-
-  test('filters by status and embeds the capped count on request', async () => {
-    const app = transfersApp()
-    const expired = await seedTransfer()
-    await FundingTransfer.transition(db, {
-      expectedVersion: 1,
-      id: expired.id,
-      status: 'expired',
-    })
-
-    const response = await app.request(
-      '/v1/funding/transfers?status=expired&include=totalCount',
-      as(fundingReader),
-    )
-    const body = await TestApp.json(response, Funding.schema.listFundingTransfers.Response)
-    expect(body.data.map((transfer) => transfer.id)).toEqual([expired.id])
-    expect(body.data[0]?.status).toBe('expired')
-    expect(body.meta).toEqual({ totalCount: 1, totalCountCapped: false })
-  })
-
-  test('narrows project-attributed keys to their project', async () => {
-    const app = transfersApp()
-    const scoped = await seedTransfer({ projectId: fundingProjectReader.projectId })
-
-    const body = await TestApp.json(
-      await app.request('/v1/funding/transfers?limit=200', as(fundingProjectReader)),
-      Funding.schema.listFundingTransfers.Response,
-    )
-    expect(body.data.map((transfer) => transfer.id)).toEqual([scoped.id])
-
-    // The organization-attributed key sees the project row too.
-    const orgBody = await TestApp.json(
-      await app.request('/v1/funding/transfers?limit=200', as(fundingReader)),
-      Funding.schema.listFundingTransfers.Response,
-    )
-    expect(orgBody.data.map((transfer) => transfer.id)).toContain(scoped.id)
-  })
-
-  test('rejects invalid query parameters', async () => {
-    const app = transfersApp()
-    const response = await app.request('/v1/funding/transfers?status=bogus', as(fundingReader))
-    expect(response.status).toBe(400)
-  })
-})
-
-describe('GET /funding/transfers/:id', () => {
-  test('returns the owned transfer directly, without an action', async () => {
-    const app = transfersApp()
-    const record = await seedTransfer()
-    const response = await app.request(`/v1/funding/transfers/${record.id}`, {
-      headers: { 'tempo-api-key': fundingReader.token },
-    })
-    expect(response.status).toBe(200)
-    expect({
-      cacheControl: response.headers.get('cache-control'),
-      etag: response.headers.get('etag'),
-    }).toMatchInlineSnapshot(`
-      {
-        "cacheControl": "no-store",
-        "etag": null,
-      }
-    `)
-    expect(response.headers.get('vary')).toBe('Accept-Encoding, Authorization, Tempo-API-Key')
-    const body = await TestApp.json(response, Funding.schema.getFundingTransfer.Response)
-    expect(body).toEqual(FundingTransfer.toPublic(record))
-    expect('action' in body).toBe(false)
-
-    const repeated = await app.request(`/v1/funding/transfers/${record.id}`, {
-      headers: { 'if-none-match': '"stale"', 'tempo-api-key': fundingReader.token },
-    })
-    expect({
-      cacheControl: repeated.headers.get('cache-control'),
-      etag: repeated.headers.get('etag'),
-      status: repeated.status,
-    }).toMatchInlineSnapshot(`
-      {
-        "cacheControl": "no-store",
-        "etag": null,
-        "status": 200,
-      }
-    `)
-  })
-
-  test('hides foreign and absent transfers behind the same 404', async () => {
-    const app = transfersApp()
-    const record = await seedTransfer()
-
-    const foreign = await app.request(`/v1/funding/transfers/${record.id}`, as(fundingForeign))
-    expect(foreign.status).toBe(404)
-    expect(((await foreign.json()) as { error: { code: string } }).error.code).toBe(
-      'funding_transfer_not_found',
-    )
-
-    const project = await app.request(
-      `/v1/funding/transfers/${record.id}`,
-      as(fundingProjectReader),
-    )
-    expect(project.status).toBe(404)
-
-    const absent = await app.request(
-      '/v1/funding/transfers/ftr_000000000000000_000000000000000000000000',
-      as(fundingReader),
-    )
-    expect(absent.status).toBe(404)
-  })
-})
-
-const createBody = {
-  amount: '1000000',
-  destinationToken: '0x20c0000000000000000000000000000000000000',
-  mode: 'exactSource',
-  recipient: `0x${'11'.repeat(20)}`,
-  sender: `0x${'22'.repeat(20)}`,
-  slippageBps: 300,
-  sourceChain: 'base',
-  sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-}
-
-const vaultTransferBody = {
-  amount: createBody.amount,
-  mode: createBody.mode,
-  recipient: createBody.recipient,
-  sender: createBody.sender,
-  slippageBps: createBody.slippageBps,
-  sourceChain: createBody.sourceChain,
-  sourceToken: createBody.sourceToken,
-  vaultAddress: `0x${'f4'.repeat(20)}`,
-}
-
-const zoneTransferBody = {
-  amount: createBody.amount,
-  destinationChain: 'eip155:421700001',
-  destinationToken: createBody.destinationToken,
-  mode: createBody.mode,
-  recipient: createBody.recipient,
-  recipientFallback: `0x${'33'.repeat(20)}`,
-  sender: createBody.sender,
-  slippageBps: createBody.slippageBps,
-  sourceChain: createBody.sourceChain,
-  sourceToken: createBody.sourceToken,
-}
-
-const depositAddressBody = {
-  amount: '100000000',
-  destinationToken: '0x20c00000000000000000000014f22ca97301eb73',
-  recipient: `0x${'11'.repeat(20)}`,
-  refundAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
-  sourceChain: 'tron',
-  sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-}
-
-let depositAddressIdempotencySequence = 0
-function nextDepositAddressKey() {
-  return `funding_deposit_address_${depositAddressIdempotencySequence++}`
-}
-
-function postDepositAddress(
-  app: ReturnType<typeof create>,
-  options: {
-    body?: unknown
-    headers?: Record<string, string> | undefined
-    idempotencyKey?: string | undefined
-    key?: { token: string } | undefined
-  } = {},
-) {
-  return app.request('/v1/funding/deposit-addresses', {
-    body: JSON.stringify(options.body ?? depositAddressBody),
-    headers: options.headers ?? {
-      authorization: `Bearer ${(options.key ?? fundingWriter).token}`,
-      'content-type': 'application/json',
-      'idempotency-key': options.idempotencyKey ?? nextDepositAddressKey(),
-    },
-    method: 'POST',
-  })
-}
-
-function postTransfer(
-  app: ReturnType<typeof create>,
-  options: { body?: unknown; idempotencyKey?: string | undefined; key?: { token: string } } = {},
-) {
-  return app.request('/v1/funding/transfers', {
-    body: JSON.stringify(options.body ?? createBody),
-    headers: {
-      authorization: `Bearer ${(options.key ?? fundingWriter).token}`,
-      'content-type': 'application/json',
-      ...(options.idempotencyKey === undefined
-        ? {}
-        : { 'idempotency-key': options.idempotencyKey }),
-    },
-    method: 'POST',
-  })
-}
-
-describe('POST /funding/transfers', () => {
-  function providerResponse(): FundingProvider.prepareTransfer.ReturnType {
-    const spender = `0x${'44'.repeat(20)}`
-    return {
-      action: {
-        calls: [
-          {
-            data: `0x095ea7b3${spender.slice(2).padStart(64, '0')}${(1_000_000).toString(16).padStart(64, '0')}`,
-            to: createBody.sourceToken,
-            value: '0x0',
-          },
-          { data: '0xe8017952', to: spender, value: '0x0' },
-        ],
-        type: 'evm:calls',
-      },
-      correlation: { requestId: `0x${'ab'.repeat(32)}` },
-      fees: [{ amount: '21050', side: 'source' }],
-      destinationAmountMin: '980000',
-      destinationAmount: '990000',
-      quality: {
-        estimatedSeconds: 4,
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'relay:quote-v2',
-        tier: 'liquid',
-      },
-      sampledAt: '2099-01-01T00:00:00.000Z',
-    }
-  }
-
-  function provider(
-    prepareTransfer: NonNullable<FundingProvider.Provider['prepareTransfer']> = async () =>
-      providerResponse(),
-  ) {
-    return FundingProvider.from({
-      ...Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
-      prepareTransfer,
-    })
-  }
-
-  let idempotencySequence = 0
-  function nextIdempotencyKey() {
-    return `funding_test_${idempotencySequence++}`
-  }
-
-  test('requires funding:write and an Idempotency-Key', async () => {
-    const app = transfersApp({
-      providers: [provider()],
-    })
-    const forbidden = await postTransfer(app, {
-      idempotencyKey: nextIdempotencyKey(),
-      key: fundingReader,
-    })
-    expect(forbidden.status).toBe(403)
-
-    const missing = await postTransfer(app)
-    expect(missing.status).toBe(400)
-    expect(((await missing.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_key_required',
-    )
-  })
-
-  test('creates a transfer with the selected executable quote', async () => {
-    const inputs: FundingProvider.prepareTransfer.Parameters[] = []
-    const app = transfersApp({
-      providers: [
-        provider(async (input) => {
-          inputs.push(input)
-          return providerResponse()
-        }),
-      ],
-    })
-    const response = await postTransfer(app, {
-      body: { ...createBody, destinationToken: 'pathusd', sourceToken: 'usdc' },
-      idempotencyKey: nextIdempotencyKey(),
-    })
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
-
-    expect(inputs[0]).toMatchObject({
-      method: 'transaction',
-      mode: 'exactSource',
-      recipient: createBody.recipient,
-      sender: createBody.sender,
-      slippageBps: 300,
-    })
-    expect(body).toMatchObject({
-      action: { type: 'evm:calls' },
-      destinationAmountMin: { baseUnits: '980000' },
-      method: 'transaction',
-      mode: 'exactSource',
-      provider: { id: 'relay' },
-      // The provider returned no expiry, so the default validity window applies.
-      quote: { expiresAt: '2099-01-01T00:01:00.000Z', sampledAt: '2099-01-01T00:00:00.000Z' },
-      sourceAmount: { baseUnits: '1000000' },
-      status: 'awaiting-source',
-      version: 1,
-    })
-    expect(body.fees[0]).toMatchObject({ side: 'source', token: { symbol: 'USDC' } })
-
-    // Reads return the same transfer without the action; the private
-    // correlation never leaves the row.
-    const read = await app.request(`/v1/funding/transfers/${body.id}`, as(fundingWriter))
-    const readBody = await TestApp.json(read, Funding.schema.getFundingTransfer.Response)
-    expect('action' in readBody).toBe(false)
-    expect(JSON.stringify(readBody)).not.toContain('ab'.repeat(32))
-    const row = await db.kysely
-      .selectFrom('funding_transfers')
-      .select(['providerState'])
-      .where('id', '=', body.id)
-      .executeTakeFirstOrThrow()
-    expect(row.providerState).toEqual({ requestId: `0x${'ab'.repeat(32)}` })
-  })
-
-  test('resolves token identifiers through the composed route', async () => {
-    const app = transfersApp({ providers: [provider()] })
-    const identifiers = [
-      { destinationToken: 'pathusd', name: 'alias', sourceToken: 'usdc' },
-      {
-        destinationToken: createBody.destinationToken,
-        name: 'address',
-        sourceToken: createBody.sourceToken,
-      },
-      {
-        destinationToken: 'eip155:4217/erc20:0x20c0000000000000000000000000000000000000',
-        name: 'token key',
-        sourceToken: 'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-      },
-    ] as const
-    const results = []
-    for (const identifier of identifiers) {
-      const response = await postTransfer(app, {
-        body: {
-          ...createBody,
-          destinationToken: identifier.destinationToken,
-          sourceToken: identifier.sourceToken,
-        },
-        idempotencyKey: nextIdempotencyKey(),
-      })
-      const body = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
-      results.push({
-        destinationToken: body.destinationToken.symbol,
-        name: identifier.name,
-        sourceToken: body.sourceToken.symbol,
-        status: response.status,
-      })
-    }
-
-    expect(results).toMatchInlineSnapshot(`
-      [
-        {
-          "destinationToken": "pathUSD",
-          "name": "alias",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-        {
-          "destinationToken": "pathUSD",
-          "name": "address",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-        {
-          "destinationToken": "pathUSD",
-          "name": "token key",
-          "sourceToken": "USDC",
-          "status": 200,
-        },
-      ]
-    `)
-  })
-
-  test('replays the exact response for the same key and body', async () => {
-    const app = transfersApp({
-      providers: [provider()],
-    })
-    const idempotencyKey = nextIdempotencyKey()
-    const first = await postTransfer(app, { idempotencyKey })
-    const second = await postTransfer(app, { idempotencyKey })
-    expect(second.status).toBe(200)
-    expect(await second.json()).toEqual(await first.json())
-  })
-
-  test('rejects a reused key with different input', async () => {
-    const app = transfersApp({
-      providers: [provider()],
-    })
-    const idempotencyKey = nextIdempotencyKey()
-    await postTransfer(app, { idempotencyKey })
-    const conflict = await postTransfer(app, {
-      body: { ...createBody, amount: '2000000' },
-      idempotencyKey,
-    })
-    expect(conflict.status).toBe(409)
-    expect(((await conflict.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_conflict',
-    )
-  })
-
-  test('rejects an equivalent request while the first is running', async () => {
-    const app = transfersApp({
-      providers: [provider()],
-    })
-    const idempotencyKey = nextIdempotencyKey()
-    await FundingIdempotencyTable.claim(db, {
-      apiKeyId: fundingWriter.id,
-      keyHash: Idempotency.inputHash(idempotencyKey),
-      requestHash: Idempotency.inputHash(createBody),
-      ttlMs: 60_000,
-    })
-    const pending = await postTransfer(app, { idempotencyKey })
-    expect(pending.status).toBe(409)
-    expect(((await pending.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_in_progress',
-    )
-  })
-
-  test('rolls back creation after losing the idempotency lease', async () => {
-    const idempotencyKey = nextIdempotencyKey()
-    const keyHash = Idempotency.inputHash(idempotencyKey)
-    const before = await db.kysely
-      .selectFrom('funding_transfers')
-      .select(({ fn }) => fn.countAll<number>().as('count'))
-      .executeTakeFirstOrThrow()
-    const app = transfersApp({
-      providers: [
-        provider(async () => {
-          await db.kysely
-            .updateTable('funding_idempotency_requests')
-            .set({ expiresAt: new Date(0).toISOString() })
-            .where('apiKeyId', '=', fundingWriter.id)
-            .where('keyHash', '=', keyHash)
-            .execute()
-          await FundingIdempotencyTable.claim(db, {
-            apiKeyId: fundingWriter.id,
-            keyHash,
-            requestHash: Idempotency.inputHash(createBody),
-            ttlMs: 60_000,
-          })
-          return providerResponse()
-        }),
-      ],
-    })
-
-    const response = await postTransfer(app, { idempotencyKey })
-    expect(response.status).toBe(500)
-    const after = await db.kysely
-      .selectFrom('funding_transfers')
-      .select(({ fn }) => fn.countAll<number>().as('count'))
-      .executeTakeFirstOrThrow()
-    expect(after.count).toBe(before.count)
-  })
-
-  test('rejects non-account fields and gates disabled corridors and methods', async () => {
-    const app = transfersApp({
-      providers: [provider()],
-    })
-
-    const ignoredRefund = await postTransfer(app, {
-      body: { ...createBody, refundAddress: createBody.sender },
-      idempotencyKey: nextIdempotencyKey(),
-    })
-    expect(ignoredRefund.status).toBe(400)
-    expect(((await ignoredRefund.json()) as { error: { code: string } }).error.code).toBe(
-      'body_invalid',
-    )
-
-    const unsupportedDestination = await postTransfer(app, {
-      body: { ...createBody, destinationVault: `0x${'f4'.repeat(20)}`, type: 'vault' },
-      idempotencyKey: nextIdempotencyKey(),
-    })
-    expect(unsupportedDestination.status).toBe(400)
-    expect(((await unsupportedDestination.json()) as { error: { code: string } }).error.code).toBe(
-      'body_invalid',
-    )
-
-    const unknownToken = await postTransfer(app, {
-      body: { ...createBody, destinationToken: `0x${'99'.repeat(20)}` },
-      idempotencyKey: nextIdempotencyKey(),
-    })
-    expect(unknownToken.status).toBe(404)
-  })
-
-  test('releases the claim after a provider failure', async () => {
-    const failing = transfersApp({
-      providers: [
-        provider(async () => {
-          throw new Error('upstream unavailable')
-        }),
-      ],
-    })
-    const idempotencyKey = nextIdempotencyKey()
-    const failed = await postTransfer(failing, { idempotencyKey })
-    expect(failed.status).toBe(502)
-    expect(((await failed.json()) as { error: { code: string } }).error.code).toBe('upstream_error')
-
-    // The key was released, so the same request retries successfully.
-    const working = transfersApp({
-      providers: [provider()],
-    })
-    expect((await postTransfer(working, { idempotencyKey })).status).toBe(200)
-  })
-
-  test('rejects preparations with unbounded approvals', async () => {
-    const app = transfersApp({
-      providers: [
-        provider(async () => {
-          const result = providerResponse()
-          const spender = `0x${'44'.repeat(20)}`
-          return {
-            ...result,
-            action: {
-              calls: [
-                {
-                  data: `0x095ea7b3${spender.slice(2).padStart(64, '0')}${'f'.repeat(64)}`,
-                  to: createBody.sourceToken,
-                  value: '0x0',
-                },
-              ],
-              type: 'evm:calls',
-            },
-          }
-        }),
-      ],
-    })
-    const response = await postTransfer(app, { idempotencyKey: nextIdempotencyKey() })
-    expect(response.status).toBe(502)
-  })
-})
-
-// Quotes come from the live provider API; the returned calls execute on a
-// disposable anvil fork of Base, proving the action without funding a real
-// account. Skips without the `anvil` binary.
-describe.skipIf(!Anvil.available)('POST /funding/transfers (forked localnet)', () => {
-  /**
-   * Storage slot of Circle FiatToken's `balanceAndBlacklistStates` mapping.
-   * `anvil_dealERC20` cannot probe it because balances pack a blacklist bit,
-   * so the fork suite writes the slot directly. Every curated USDC is a
-   * FiatToken.
-   */
-  const fiatTokenBalanceSlot = 9n
-
-  for (const executable of executableProviders) {
-    describe(executable.id, () => {
-      const route = TestFunding.snapshot.routes.find(
-        (entry) =>
-          entry.route.source.chain.id === `eip155:${base.id}` &&
-          entry.route.source.symbol === 'USDC' &&
-          entry.route.destination.slug === 'pathusd',
-      )!
-      const usdc = route.route.source
-      const amount = Value.from('10', usdc.decimals)
-      const sender = Anvil.getAccount(0)
-
-      let anvil: Anvil.start.ReturnType
-
-      beforeAll(async () => {
-        anvil = await Anvil.start({ chain: base, forkUrl: base.rpcUrls.default.http[0]! })
-      })
-
-      afterAll(async () => {
-        await anvil?.stop()
-      })
-
-      function createTransfer(idempotencyKey: string) {
-        const app = transfersApp({ providers: [executable.create(sender.address)] })
-        return postTransfer(app, {
-          body: { ...createBody, amount: amount.toString(), sender: sender.address },
-          idempotencyKey,
-        })
-      }
-
-      test('executes the prepared calls and returns successful receipts', async () => {
-        const { client } = anvil
-        await Anvil.setErc20Balance(client, {
-          address: sender.address,
-          amount,
-          slot: fiatTokenBalanceSlot,
-          token: usdc.address as `0x${string}`,
-        })
-
-        const response = await createTransfer(`bridge_${executable.id}_${sender.address}`)
-        expect(response.status).toBe(200)
-        const transfer = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
-        expect(transfer.action.type).toBe('evm:calls')
-        if (transfer.action.type !== 'evm:calls') return
-        expect(transfer.action.calls.length).toBeGreaterThan(0)
-
-        const receipts = []
-        for (const call of transfer.action.calls) {
-          receipts.push(
-            await client.sendTransactionSync({
-              account: sender,
-              data: call.data as `0x${string}`,
-              to: call.to as `0x${string}`,
-              value: BigInt(call.value),
-            }),
-          )
-        }
-
-        expect(receipts.map((receipt) => receipt.status)).toEqual(
-          transfer.action.calls.map(() => 'success'),
-        )
-        // The deposit is the last call and must emit; an approval alone proves nothing.
-        expect(receipts.at(-1)!.logs.length).toBeGreaterThan(0)
-      })
-
-      test('bounds the approval to the quoted source spend', async () => {
-        const response = await createTransfer(`bridge_bounds_${executable.id}_${sender.address}`)
-        expect(response.status).toBe(200)
-        const transfer = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
-        if (transfer.action.type !== 'evm:calls') return
-
-        const approval = transfer.action.calls.find((call) =>
-          call.data.toLowerCase().startsWith('0x095ea7b3'),
-        )
-        expect(approval).toBeDefined()
-        if (!approval) return
-
-        // Decoded from the live action, so a provider that starts returning
-        // an unlimited allowance fails here.
-        const decoded = decodeFunctionData({ abi: erc20Abi, data: approval.data as `0x${string}` })
-        expect(decoded.functionName).toBe('approve')
-        if (decoded.functionName !== 'approve') return
-        const [, approved] = decoded.args
-        expect(approved).toBeLessThanOrEqual(BigInt(transfer.sourceAmount.baseUnits))
-        expect(approved).toBeLessThan(maxUint256)
-      })
-    })
-  }
-})
-
-describe('POST /funding/transfers/{destination}', () => {
-  test.each([
-    { body: vaultTransferBody, destination: 'vault' },
-    { body: zoneTransferBody, destination: 'zone' },
-  ] as const)('validates and returns 501 for $destination transfers', async (options) => {
-    const app = transfersApp()
-    const before = await db.kysely
-      .selectFrom('funding_transfers')
-      .select(({ fn }) => fn.countAll<number>().as('count'))
-      .executeTakeFirstOrThrow()
-    const response = await app.request(`/v1/funding/transfers/${options.destination}`, {
-      body: JSON.stringify(options.body),
-      headers: {
-        authorization: `Bearer ${fundingWriter.token}`,
-        'content-type': 'application/json',
-        'idempotency-key': `funding_${options.destination}_unimplemented`,
-      },
-      method: 'POST',
-    })
-
-    expect(response.status).toBe(501)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-      'not_implemented',
-    )
-    const after = await db.kysely
-      .selectFrom('funding_transfers')
-      .select(({ fn }) => fn.countAll<number>().as('count'))
-      .executeTakeFirstOrThrow()
-    expect(after.count).toBe(before.count)
-  })
-
-  test('requires the header and validates destination fields', async () => {
-    const app = transfersApp()
-    const missingHeader = await app.request('/v1/funding/transfers/vault', {
-      body: JSON.stringify(vaultTransferBody),
-      headers: {
-        authorization: `Bearer ${fundingWriter.token}`,
-        'content-type': 'application/json',
-      },
-      method: 'POST',
-    })
-    expect(missingHeader.status).toBe(400)
-    expect(((await missingHeader.json()) as { error: { code: string } }).error.code).toBe(
-      'idempotency_key_required',
-    )
-
-    const invalidZone = await app.request('/v1/funding/transfers/zone', {
-      body: JSON.stringify({ ...zoneTransferBody, destinationChain: '421700001' }),
-      headers: {
-        authorization: `Bearer ${fundingWriter.token}`,
-        'content-type': 'application/json',
-        'idempotency-key': 'funding_zone_invalid',
-      },
-      method: 'POST',
-    })
-    expect(invalidZone.status).toBe(400)
-    expect(((await invalidZone.json()) as { error: { code: string } }).error.code).toBe(
-      'body_invalid',
-    )
-  })
-})
-
-describe('funding transfers OpenAPI', () => {
-  test('publishes an executable account transfer example', async () => {
-    const app = create({ auth: false })
-    type TokenSchema = { examples: string[] }
-    type TransferExample = { destinationToken: { address: string } }
-    type Operation = {
-      requestBody: {
-        content: Record<string, { schema: { properties: { destinationToken: TokenSchema } } }>
-      }
-      responses: Record<string, { content: Record<string, { example: TransferExample }> }>
-    }
-    type Spec = { paths: Record<string, { post: Operation }> }
-    const spec = (await (await app.request('/openapi.json')).json()) as Spec
-    const operation = spec.paths['/v1/funding/transfers']!.post
-
-    expect({
-      request:
-        operation.requestBody.content['application/json']!.schema.properties.destinationToken
-          .examples,
-      response:
-        operation.responses['200']!.content['application/json']!.example.destinationToken.address,
-    }).toEqual({
-      request: ['pathusd'],
-      response: '0x20c0000000000000000000000000000000000000',
-    })
-  })
-
-  test('publishes human-readable deposit address route examples', async () => {
-    const app = create({ auth: false })
-    type Property = { examples: string[] }
-    type Operation = {
-      requestBody: {
-        content: Record<
-          string,
-          {
-            schema: {
-              properties: {
-                destinationToken: Property
-                sourceChain: Property
-                sourceToken: Property
-              }
-            }
-          }
-        >
-      }
-    }
-    type Spec = { paths: Record<string, { post: Operation }> }
-    const spec = (await (await app.request('/openapi.json')).json()) as Spec
-    const properties =
-      spec.paths['/v1/funding/deposit-addresses']!.post.requestBody.content['application/json']!
-        .schema.properties
-
-    expect({
-      destinationToken: properties.destinationToken.examples,
-      sourceChain: properties.sourceChain.examples,
-      sourceToken: properties.sourceToken.examples,
-    }).toMatchInlineSnapshot(`
-      {
-        "destinationToken": [
-          "usdt0",
-        ],
-        "sourceChain": [
-          "tron",
-          "tron:0x2b6653dc",
-        ],
-        "sourceToken": [
-          "usdt",
-        ],
-      }
-    `)
-  })
-
-  test('publishes concise operation documentation', async () => {
-    const app = create({ auth: false })
-    type Operation = { description: string; summary: string; tags: string[] }
-    type Spec = {
-      paths: Record<string, { get?: Operation; post?: Operation }>
-      tags: { description?: string; name: string }[]
-    }
-    const spec = (await (await app.request('/openapi.json')).json()) as Spec
-    const detailPath = Object.keys(spec.paths).find((path) =>
-      path.includes('/v1/funding/transfers/{'),
-    )!
-    const depositAddressPath = Object.keys(spec.paths).find(
-      (path) => path.includes('/v1/funding/deposit-addresses/{') && !path.endsWith('/deposits'),
-    )!
-    const depositAddressDepositsPath = Object.keys(spec.paths).find((path) =>
-      path.endsWith('/deposits'),
-    )!
-    const depositPath = Object.keys(spec.paths).find((path) =>
-      path.includes('/v1/funding/deposits/{'),
-    )!
-    const summarize = (operation: Operation) => ({
-      description: operation.description,
-      summary: operation.summary,
-    })
-    const operations = {
-      account: summarize(spec.paths['/v1/funding/transfers']!.post!),
-      chains: summarize(spec.paths['/v1/funding/chains']!.get!),
-      deposit: summarize(spec.paths[depositPath]!.get!),
-      depositAddress: summarize(spec.paths[depositAddressPath]!.get!),
-      depositAddressCreate: summarize(spec.paths['/v1/funding/deposit-addresses']!.post!),
-      depositAddressDeposits: summarize(spec.paths[depositAddressDepositsPath]!.get!),
-      detail: summarize(spec.paths[detailPath]!.get!),
-      list: summarize(spec.paths['/v1/funding/transfers']!.get!),
-      providers: summarize(spec.paths['/v1/funding/providers']!.get!),
-      quotes: summarize(spec.paths['/v1/funding/quotes']!.get!),
-      vault: summarize(spec.paths['/v1/funding/transfers/vault']!.post!),
-      zone: summarize(spec.paths['/v1/funding/transfers/zone']!.post!),
-    }
-    const sidebar = Object.values(spec.paths).flatMap((path) =>
-      [path.get, path.post].flatMap((operation) =>
-        operation?.tags.includes('Funding') ? [operation.summary] : [],
-      ),
-    )
-
-    for (const operation of Object.values(operations))
-      expect(operation.description.split(/\s+/).length).toBeLessThan(15)
-
-    expect({
-      category: spec.tags.find((tag) => tag.name === 'Funding')?.description,
-      operations,
-      sidebar,
-    }).toMatchInlineSnapshot(`
-      {
-        "category": "Quote, transfer, and deposit management for funding Tempo from other chains.",
-        "operations": {
-          "account": {
-            "description": "Creates a transfer to a Tempo account.",
-            "summary": "Create transfer",
-          },
-          "chains": {
-            "description": "Lists supported source chains and tokens.",
-            "summary": "Get chains",
-          },
-          "deposit": {
-            "description": "Returns one detected deposit and its delivery status.",
-            "summary": "Get deposit",
-          },
-          "depositAddress": {
-            "description": "Returns one reusable funding deposit address.",
-            "summary": "Get deposit address",
-          },
-          "depositAddressCreate": {
-            "description": "Creates or returns a reusable deposit address for funding a Tempo account.",
-            "summary": "Create deposit address",
-          },
-          "depositAddressDeposits": {
-            "description": "Lists deposits detected for one funding deposit address, newest first.",
-            "summary": "List deposits",
-          },
-          "detail": {
-            "description": "Returns a transfer by ID.",
-            "summary": "Get transfer",
-          },
-          "list": {
-            "description": "Lists transfers from newest to oldest.",
-            "summary": "List transfers",
-          },
-          "providers": {
-            "description": "Lists available transfer providers.",
-            "summary": "Get providers",
-          },
-          "quotes": {
-            "description": "Returns live quotes for transferring stablecoins to Tempo.",
-            "summary": "Get quotes",
-          },
-          "vault": {
-            "description": "Creates a transfer into a Tempo Earn vault.",
-            "summary": "Create transfer into vault",
-          },
-          "zone": {
-            "description": "Creates a transfer into a Tempo Zone.",
-            "summary": "Create transfer into zone",
-          },
-        },
-        "sidebar": [
-          "Get quotes",
-          "Get chains",
-          "Get providers",
-          "Get deposit address",
-          "Get deposit",
-          "List deposits",
-          "Create deposit address",
-          "List transfers",
-          "Create transfer",
-          "Create transfer into vault",
-          "Create transfer into zone",
-          "Get transfer",
-        ],
-      }
-    `)
-  })
-
-  test('publishes concrete creation schemas', async () => {
-    const app = create({ auth: false })
-    const spec = (await (await app.request('/openapi.json')).json()) as {
-      paths: Record<
-        string,
-        {
-          post?: {
-            requestBody: {
-              content: Record<
-                string,
-                {
-                  schema: {
-                    additionalProperties?: boolean
-                    properties: object
-                    required?: readonly string[] | undefined
-                  }
-                }
-              >
-            }
-            responses: Record<string, unknown>
-          }
-        }
-      >
-    }
-    const creationSchema = (path: string) =>
-      spec.paths[path]!.post!.requestBody.content['application/json']!.schema
-    expect(
-      creationSchema('/v1/funding/deposit-addresses').required?.includes('subsidize') ?? false,
-    ).toMatchInlineSnapshot(`false`)
-    const summarize = (path: string) => {
-      const schema = creationSchema(path)
-      return {
-        additionalProperties: schema.additionalProperties,
-        properties: Object.keys(schema.properties),
-      }
-    }
-
-    expect({
-      account: summarize('/v1/funding/transfers'),
-      depositAddress: summarize('/v1/funding/deposit-addresses'),
-      depositAddressResponses: Object.keys(
-        spec.paths['/v1/funding/deposit-addresses']!.post!.responses,
-      ),
-      vault: summarize('/v1/funding/transfers/vault'),
-      vaultResponses: Object.keys(spec.paths['/v1/funding/transfers/vault']!.post!.responses),
-      zone: summarize('/v1/funding/transfers/zone'),
-      zoneResponses: Object.keys(spec.paths['/v1/funding/transfers/zone']!.post!.responses),
-    }).toMatchInlineSnapshot(`
-      {
-        "account": {
-          "additionalProperties": false,
-          "properties": [
-            "amount",
-            "destinationToken",
-            "mode",
-            "recipient",
-            "sender",
-            "slippageBps",
-            "sourceChain",
-            "sourceToken",
-          ],
-        },
-        "depositAddress": {
-          "additionalProperties": false,
-          "properties": [
-            "amount",
-            "destinationToken",
-            "recipient",
-            "refundAddress",
-            "sourceChain",
-            "sourceToken",
-            "subsidize",
-          ],
-        },
-        "depositAddressResponses": [
-          "200",
-          "400",
-          "401",
-          "404",
-          "409",
-          "429",
-          "500",
-          "502",
-        ],
-        "vault": {
-          "additionalProperties": false,
-          "properties": [
-            "amount",
-            "mode",
-            "recipient",
-            "sender",
-            "slippageBps",
-            "sourceChain",
-            "sourceToken",
-            "vaultAddress",
-          ],
-        },
-        "vaultResponses": [
-          "400",
-          "401",
-          "429",
-          "500",
-          "501",
-        ],
-        "zone": {
-          "additionalProperties": false,
-          "properties": [
-            "amount",
-            "destinationChain",
-            "destinationToken",
-            "mode",
-            "recipient",
-            "recipientFallback",
-            "sender",
-            "slippageBps",
-            "sourceChain",
-            "sourceToken",
-          ],
-        },
-        "zoneResponses": [
-          "400",
-          "401",
-          "429",
-          "500",
-          "501",
-        ],
-      }
-    `)
-  })
-
-  test('publishes alphabetically ordered example fields and parameter examples', async () => {
-    const app = create({ auth: false })
-    const spec = (await (await app.request('/openapi.json')).json()) as {
-      paths: Record<
-        string,
-        {
-          get: {
-            parameters?: { example?: unknown; name: string; schema?: { examples?: unknown } }[]
-            responses: Record<string, { content: Record<string, { example: { data: {}[] } }> }>
-          }
-        }
-      >
-    }
-    const operation = spec.paths['/v1/funding/transfers']!.get
-    const fields = Object.keys(operation.responses['200']!.content['application/json']!.example.data[0]!) // prettier-ignore
-    expect(fields).toEqual([...fields].sort())
-    for (const parameter of operation.parameters ?? [])
-      expect(parameter.example ?? parameter.schema?.examples, parameter.name).toBeDefined()
-  })
-
-  test('publishes operation ids and required scopes', async () => {
-    const app = create({ auth: false })
-    const spec = (await (await app.request('/openapi.json')).json()) as {
-      paths: Record<
-        string,
-        {
-          get: { operationId: string; 'x-required-scopes': string[] }
-          post?: {
-            operationId: string
-            parameters: { in: string; name: string; required: boolean }[]
-            'x-required-scopes': string[]
-          }
-        }
-      >
-    }
-    const detailPath = Object.keys(spec.paths).find((path) =>
-      path.includes('/v1/funding/transfers/{'),
-    )
-    const depositAddressPath = Object.keys(spec.paths).find(
-      (path) => path.includes('/v1/funding/deposit-addresses/{') && !path.endsWith('/deposits'),
-    )
-    const depositAddressDepositsPath = Object.keys(spec.paths).find((path) =>
-      path.endsWith('/deposits'),
-    )
-    const depositPath = Object.keys(spec.paths).find((path) =>
-      path.includes('/v1/funding/deposits/{'),
-    )
-    expect({
-      deposit: depositPath && spec.paths[depositPath]?.get.operationId,
-      depositAddress: depositAddressPath && spec.paths[depositAddressPath]?.get.operationId,
-      depositAddressCreate: spec.paths['/v1/funding/deposit-addresses']?.post?.operationId,
-      depositAddressCreateScopes:
-        spec.paths['/v1/funding/deposit-addresses']?.post?.['x-required-scopes'],
-      depositAddressDeposits:
-        depositAddressDepositsPath && spec.paths[depositAddressDepositsPath]?.get.operationId,
-      depositAddressDepositsScopes:
-        depositAddressDepositsPath &&
-        spec.paths[depositAddressDepositsPath]?.get['x-required-scopes'],
-      depositAddressScopes:
-        depositAddressPath && spec.paths[depositAddressPath]?.get['x-required-scopes'],
-      depositScopes: depositPath && spec.paths[depositPath]?.get['x-required-scopes'],
-      detail: detailPath && spec.paths[detailPath]?.get.operationId,
-      detailScopes: detailPath && spec.paths[detailPath]?.get['x-required-scopes'],
-      list: spec.paths['/v1/funding/transfers']?.get.operationId,
-      listScopes: spec.paths['/v1/funding/transfers']?.get['x-required-scopes'],
-      requiredCreateHeader: spec.paths['/v1/funding/transfers']?.post?.parameters.find(
-        (parameter) => parameter.name === 'idempotency-key',
-      ),
-      vault: spec.paths['/v1/funding/transfers/vault']?.post?.operationId,
-      vaultScopes: spec.paths['/v1/funding/transfers/vault']?.post?.['x-required-scopes'],
-      zone: spec.paths['/v1/funding/transfers/zone']?.post?.operationId,
-      zoneScopes: spec.paths['/v1/funding/transfers/zone']?.post?.['x-required-scopes'],
-    }).toEqual({
-      deposit: 'getFundingDeposit',
-      depositAddress: 'getFundingDepositAddress',
-      depositAddressCreate: 'createFundingDepositAddress',
-      depositAddressCreateScopes: ['funding:write'],
-      depositAddressDeposits: 'listFundingDepositAddressDeposits',
-      depositAddressDepositsScopes: ['funding:read'],
-      depositAddressScopes: ['funding:read'],
-      depositScopes: ['funding:read'],
-      detail: 'getFundingTransfer',
-      detailScopes: ['funding:read'],
-      list: 'listFundingTransfers',
-      listScopes: ['funding:read'],
-      requiredCreateHeader: expect.objectContaining({
-        description: expect.stringContaining('24 hours'),
-        in: 'header',
-        name: 'idempotency-key',
-        required: true,
-        schema: expect.any(Object),
-      }),
-      vault: 'createFundingTransferVault',
-      vaultScopes: ['funding:write'],
-      zone: 'createFundingTransferZone',
-      zoneScopes: ['funding:write'],
-    })
-  })
-})
-
-const baseUsdcQuery = {
-  sourceAmount: '1000000',
-  sourceChain: 'base',
-  sourceToken: 'USDC',
-} as const
-
-type QuoteQuery = Record<string, string>
-
-function quoteUrl(query: QuoteQuery = baseUsdcQuery) {
-  return `/v1/funding/quotes?${new URLSearchParams(
-    Object.entries(query).map(([key, value]) => [key, String(value)]),
-  )}`
-}
-
-function relayProvider(onGetQuote: () => void = () => {}) {
-  return withGetQuote('relay', async (input, signal) => {
-    onGetQuote()
-    expect(signal.aborted).toBe(false)
-    expect(input.candidate.id).toBe('base-usdc-tempo-usdce-relay')
-    return {
-      destinationAmountMin: '980000',
-      destinationAmount: '990000',
-      quality: {
-        estimatedSeconds: 4,
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'relay:quote-v2',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00Z',
-      status: 'available',
-    }
-  })
-}
-
-function acrossProvider(onGetQuote: () => void = () => {}) {
-  return withGetQuote('across', async (input, signal) => {
-    onGetQuote()
-    expect(signal.aborted).toBe(false)
-    expect(input.candidate.id).toBe('base-usdc-tempo-usdce-across')
-    return {
-      expiresAt: '2026-01-01T00:01:00Z',
-      destinationAmountMin: '988000',
-      destinationAmount: '990000',
-      quality: {
-        estimatedSeconds: 2,
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'across:swap-approval',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00Z',
-      status: 'available',
-    }
-  })
-}
-
-function rhinoProvider() {
-  return withGetQuote('rhino', async (input, signal) => {
-    expect(signal.aborted).toBe(false)
-    expect(input.candidate.id).toBe('solana-usdc-tempo-usdce-rhino')
-    return {
-      destinationAmount: '983000',
-      quality: {
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'rhino:bridge-swap-public',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00Z',
-      status: 'available',
-    }
-  })
-}
-
-function withGetQuote(
-  id: FundingProvider.ProviderId,
-  getQuote: FundingProvider.Provider['getQuote'],
-) {
-  const provider = providers.find((entry) => entry.id === id)
-  if (!provider) throw new Error(`Missing ${id} provider`)
-  return FundingProvider.from({ ...provider, getQuote })
-}
-
-function withCreateDepositAddress(
-  id: FundingProvider.ProviderId,
-  createDepositAddress: NonNullable<FundingProvider.Provider['createDepositAddress']>,
-) {
-  const provider = providers.find((entry) => entry.id === id)
-  if (!provider) throw new Error(`Missing ${id} provider`)
-  return FundingProvider.from({ ...provider, createDepositAddress })
-}
-
-function depositAddressProvider(
-  address = 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
-  onCreate: (input: FundingProvider.createDepositAddress.Parameters) => void = () => {},
-) {
-  return withCreateDepositAddress('relay', async (input) => {
-    onCreate(input)
-    return {
-      address,
-      correlation: {
-        checkEndpoint: '/intents/status/v3?requestId=relay_request_1',
-        requestId: 'relay_request_1',
-      },
-      destinationAmount: '1000000',
-      destinationAmountMin: '1000000',
-      fees: [],
-      sampledAt: '2026-08-04T00:00:00.000Z',
-    }
-  })
-}
-
-/** API key with funding read access, owned by `org_funding`. */
-const fundingReader = {
-  id: 'key_funding',
-  orgId: 'org_funding',
-  scopes: ['funding:read'],
-  token: 'secret_funding_reader',
-} satisfies TestApp.kvStore.Key
-
-/** Project-attributed key in the same org, used to prove project narrowing. */
-const fundingProjectReader = {
-  id: 'key_funding_project',
-  orgId: 'org_funding',
-  projectId: 'prj_funding',
-  scopes: ['funding:read'],
-  token: 'secret_funding_project',
-} satisfies TestApp.kvStore.Key
-
-/** Key in a different org, used to prove owner isolation. */
-const fundingForeign = {
-  id: 'key_funding_other',
-  orgId: 'org_funding_other',
-  scopes: ['funding:read'],
-  token: 'secret_funding_other',
-} satisfies TestApp.kvStore.Key
-
-/** Key with funding write access, owned by `org_funding`. */
-const fundingWriter = {
-  id: 'key_funding_writer',
-  orgId: 'org_funding',
-  scopes: ['funding:read', 'funding:write'],
-  token: 'secret_funding_writer',
-} satisfies TestApp.kvStore.Key
-
-function transfersApp(options: TestApp.create.Options = {}) {
-  return create({
-    ...options,
-    auth: {
-      keys: [TestApp.key, fundingReader, fundingProjectReader, fundingForeign, fundingWriter],
-    },
-    defaultChainId: options.defaultChainId ?? tempoMainnet.id,
-  })
-}
-
-/** RequestInit carrying a bearer token for the given key. */
-function as(key: { token: string }) {
-  return { headers: { authorization: `Bearer ${key.token}` } } as const
-}
-
-let seedDepositAddressSecond = 0
-function seedDepositAddress(input: Partial<FundingDepositAddress.create.Input> = {}) {
-  const index = seedDepositAddressSecond++
-  const now = new Date(Date.UTC(2026, 0, 3, 0, 0, index))
-  return FundingDepositAddress.create(db, {
-    apiKeyId: fundingReader.id,
-    deliveryStrategy: 'provider',
-    environment: 'production',
-    id: FundingDepositAddress.generateId(now),
-    now,
-    orgId: fundingReader.orgId,
-    providerOutputToken: TestFunding.providerOutputToken(),
-    snapshot: TestFunding.depositAddressSnapshot({
-      provider: { id: `relay_route_${index}`, name: 'Relay' },
-      recipient: `0x${index.toString(16).padStart(40, '0')}`,
-    }),
-    ...input,
-  })
-}
-
-let seedDepositSecond = 0
-function seedDeposit(
-  address: Awaited<ReturnType<typeof seedDepositAddress>>,
-  input: Partial<FundingDeposit.create.Input> = {},
-) {
-  const index = seedDepositSecond++
-  const now = new Date(Date.UTC(2026, 0, 4, 0, 0, index))
-  const sourceTransactionHash = index.toString(16).padStart(64, '0')
-  return FundingDeposit.create(db, {
-    now,
-    providerRequestId: `relay_request_${index}`,
-    snapshot: TestFunding.depositSnapshot(address.id, {
-      provider: address.snapshot.provider,
-      sourceTransactionHashes: [sourceTransactionHash],
-    }),
-    sourceTransactionHash,
-    sourceTransferIndex: 0,
-    ...input,
-  })
-}
-
-let seedSecond = 0
-function seedTransfer(input: Partial<FundingTransfer.create.Input> = {}) {
-  // Distinct create times keep ids strictly ordered for paging assertions.
-  return FundingTransfer.create(db, {
-    apiKeyId: fundingReader.id,
-    environment: 'production',
-    id: FundingTransfer.generateId(new Date(Date.UTC(2026, 0, 2, 0, 0, seedSecond++))),
-    orgId: fundingReader.orgId,
-    snapshot: TestFunding.transferSnapshot(),
-    ...input,
-  })
-}