tapimo 0.7.0 → 0.7.2

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

@@ -1,13 +1,89 @@
+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 type * as FundingQuotes from '../../../internal/FundingQuotes.js'
+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 = TestApp.create({ auth: false })
+    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']
@@ -17,7 +93,7 @@ describe('GET /funding/quotes', () => {
   })
 
   test('returns successful live quotes with output amounts', async () => {
-    const app = TestApp.create({ funding: { adapters: { relay: relayAdapter() } } })
+    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')
@@ -47,20 +123,84 @@ describe('GET /funding/quotes', () => {
     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 = TestApp.create({
-      funding: {
-        adapters: {
-          across: acrossAdapter(() => {
-            acrossCalls += 1
-          }),
-          relay: relayAdapter(() => {
-            relayCalls += 1
-          }),
-        },
-      },
+    const app = create({
+      providers: [
+        acrossProvider(() => {
+          acrossCalls += 1
+        }),
+        relayProvider(() => {
+          relayCalls += 1
+        }),
+      ],
     })
     const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
       headers: TestApp.auth.headers,
@@ -74,7 +214,7 @@ describe('GET /funding/quotes', () => {
   })
 
   test('returns non-EVM Rhino quotes with stable chain and token ids', async () => {
-    const app = TestApp.create({ funding: { adapters: { rhino: rhinoAdapter() } } })
+    const app = create({ providers: [rhinoProvider()] })
     const response = await app.request(
       quoteUrl({
         destinationToken: 'USDC.e',
@@ -103,8 +243,8 @@ describe('GET /funding/quotes', () => {
     })
   })
 
-  test('returns an empty list when no provider is configured', async () => {
-    const response = await TestApp.create().request(quoteUrl(), {
+  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)
@@ -114,19 +254,16 @@ describe('GET /funding/quotes', () => {
 
   test('returns an empty list when the provider reports no quote', async () => {
     const entries: Log.Entry[] = []
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          relay: {
-            async probeQuote() {
-              return { sampledAt: '2026-01-01T00:00:00Z', status: 'unavailable' }
-            },
-          },
-        },
-      },
+    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)
@@ -136,23 +273,19 @@ describe('GET /funding/quotes', () => {
       {
         durationMs: expect.any(Number),
         id: 'relay',
-        operation: 'quote/v2',
+        operation: 'getQuote',
         outcome: 'unavailable',
       },
     ])
   })
 
   test('returns 502 when every matching provider fails', async () => {
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          relay: {
-            async probeQuote() {
-              throw new Error('upstream unavailable')
-            },
-          },
-        },
-      },
+    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)
@@ -161,64 +294,58 @@ describe('GET /funding/quotes', () => {
   })
 
   test('logs provider quote deadlines as timeouts', async () => {
+    vi.useFakeTimers()
     const entries: Log.Entry[] = []
-    const app = TestApp.create({
-      funding: {
-        adapterTimeoutMs: 1,
-        adapters: {
-          across: {
-            probeQuote() {
-              return new Promise<FundingQuotes.QuoteProbeResult>(() => {})
-            },
-          },
-        },
-      },
+    const app = create({
       logger: (entry) => {
         entries.push(entry)
       },
+      providers: [
+        withGetQuote('across', () => new Promise<FundingProvider.getQuote.ReturnType>(() => {})),
+      ],
     })
 
-    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
-      headers: TestApp.auth.headers,
-    })
+    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: 'swap/approval',
-    })
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
+      expect(response.status).toBe(502)
+      expect(entries[0]?.provider).toEqual({
         failure: 'timeout',
         id: 'across',
-        operation: 'swap/approval',
-        outcome: 'failed',
-      },
-    ])
+        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 = TestApp.create({
-      funding: {
-        adapters: {
-          across: {
-            async probeQuote() {
-              throw new TypeError('Across network failure')
-            },
-          },
-          relay: {
-            async probeQuote() {
-              throw new Error('Relay failure')
-            },
-          },
-        },
-      },
+    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 })
@@ -227,25 +354,25 @@ describe('GET /funding/quotes', () => {
     expect(entries[0]?.provider).toEqual({
       failure: 'network',
       id: 'across',
-      operation: 'swap/approval',
+      operation: 'getQuote',
     })
     expect(entries[0]?.providerFailures).toEqual([
-      { failure: 'network', id: 'across', operation: 'swap/approval' },
-      { failure: 'unknown', id: 'relay', operation: 'quote/v2' },
+      { 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: 'swap/approval',
+        operation: 'getQuote',
         outcome: 'failed',
       },
       {
         durationMs: expect.any(Number),
         failure: 'unknown',
         id: 'relay',
-        operation: 'quote/v2',
+        operation: 'getQuote',
         outcome: 'failed',
       },
     ])
@@ -253,20 +380,16 @@ describe('GET /funding/quotes', () => {
 
   test('logs failed providers when another provider returns a quote', async () => {
     const entries: Log.Entry[] = []
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          across: {
-            async probeQuote() {
-              throw new TypeError(`wallet ${'0xaa'.repeat(20)} could not reach secret-provider`)
-            },
-          },
-          relay: relayAdapter(),
-        },
-      },
+    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 })
@@ -277,13 +400,13 @@ describe('GET /funding/quotes', () => {
         durationMs: expect.any(Number),
         failure: 'network',
         id: 'across',
-        operation: 'swap/approval',
+        operation: 'getQuote',
         outcome: 'failed',
       },
       {
         durationMs: expect.any(Number),
         id: 'relay',
-        operation: 'quote/v2',
+        operation: 'getQuote',
         outcome: 'available',
       },
     ])
@@ -292,23 +415,20 @@ describe('GET /funding/quotes', () => {
   })
 
   test('rejects successful provider results without output amounts', async () => {
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          relay: {
-            async probeQuote() {
-              return { sampledAt: '2026-01-01T00:00:00Z', status: 'available' }
-            },
-          },
-        },
-      },
+    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 TestApp.create().request(
+    const response = await create().request(
       quoteUrl({ sourceAmount: '1000000', sourceChain: 'base' }),
       { headers: TestApp.auth.headers },
     )
@@ -318,19 +438,20 @@ describe('GET /funding/quotes', () => {
   })
 
   test('rejects unsupported providers', async () => {
-    const response = await TestApp.create().request(
-      quoteUrl({ ...baseUsdcQuery, provider: 'bridge' }),
-      { headers: TestApp.auth.headers },
-    )
+    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 TestApp.create().request(
+    const response = await create().request(
       quoteUrl({ ...baseUsdcQuery, sourceChain: 'bitcoin' }),
-      { headers: TestApp.auth.headers },
+      {
+        headers: TestApp.auth.headers,
+      },
     )
     expect(response.status).toBe(400)
     const body = await TestApp.json(response, Schema.ErrorResponse)
@@ -338,7 +459,7 @@ describe('GET /funding/quotes', () => {
   })
 
   test('does not expose the removed routes endpoint', async () => {
-    const response = await TestApp.create().request(
+    const response = await create().request(
       '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000',
       { headers: TestApp.auth.headers },
     )
@@ -348,14 +469,17 @@ describe('GET /funding/quotes', () => {
 
 describe('GET /funding/chains', () => {
   test('lists only inputs supported by quote providers', async () => {
-    const response = await TestApp.client().v1.funding.chains.$get(undefined, TestApp.auth)
+    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.listFundingChains.Response)
+    const body = await TestApp.json(response, Funding.schema.getFundingChains.Response)
 
     expect(body.data.map((chain) => chain.id)).toEqual([
       'eip155:1',
-      'eip155:8453',
       'eip155:56',
+      'eip155:8453',
+      'eip155:137',
       'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
       'tron:0x2b6653dc',
     ])
@@ -369,135 +493,2502 @@ describe('GET /funding/chains', () => {
 })
 
 describe('GET /funding/providers', () => {
-  test('lists quote providers and their configuration status', async () => {
-    const app = TestApp.create({ funding: { adapters: { relay: relayAdapter() } } })
+  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.listProviders.Response)
+    const body = await TestApp.json(response, Funding.schema.getFundingProviders.Response)
 
     expect(body.data).toEqual([
-      {
-        id: 'across',
-        kind: 'intentBridge',
-        name: 'Across',
-        requiresApiKey: true,
-        status: 'unconfigured',
-      },
       {
         id: 'relay',
-        kind: 'solverNetwork',
         name: 'Relay',
-        requiresApiKey: false,
-        status: 'configured',
       },
+    ])
+  })
+
+  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' },
       {
-        id: 'rhino',
-        kind: 'bridge',
-        name: 'Rhino',
-        requiresApiKey: false,
-        status: 'unconfigured',
+        destinationToken: depositAddressBody.destinationToken,
+        name: 'address',
+        sourceToken: depositAddressBody.sourceToken,
       },
       {
-        id: 'squid',
-        kind: 'solverNetwork',
-        name: 'Squid',
-        requiresApiKey: true,
-        status: 'unconfigured',
+        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(
       {
-        id: 'symbiosis',
-        kind: 'crossChainDex',
-        name: 'Symbiosis',
-        requiresApiKey: false,
-        status: 'unconfigured',
+        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('does not expose the removed generic provider endpoint', async () => {
-    const response = await TestApp.create().request('/v1/providers', {
-      headers: TestApp.auth.headers,
+  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',
+          }
+        }),
+      ],
     })
-    expect(response.status).toBe(404)
+    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,
+      }
+    `)
   })
-})
 
-const baseUsdcQuery = {
-  sourceAmount: '1000000',
-  sourceChain: 'base',
-  sourceToken: 'USDC',
-} as const
+  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,
+    )
 
-type QuoteQuery = Record<string, string>
+    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",
+        },
+      }
+    `)
+  })
 
-function quoteUrl(query: QuoteQuery = baseUsdcQuery) {
-  return `/v1/funding/quotes?${new URLSearchParams(
-    Object.entries(query).map(([key, value]) => [key, String(value)]),
-  )}`
-}
+  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,
+    )
 
-function relayAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAdapter {
-  return {
-    async probeQuote(input, signal) {
-      onProbe()
-      expect(signal.aborted).toBe(false)
-      expect(input.candidate.id).toBe('base-usdc-tempo-usdce-relay')
-      return {
-        minimumOutputAmount: '980000',
-        outputAmount: '990000',
-        quality: {
-          estimatedSeconds: 4,
-          liquiditySource: 'providerQuote',
-          sourceDetail: 'relay:quote-v2',
-          tier: 'liquid',
-        },
-        sampledAt: '2026-01-01T00:00:00Z',
-        status: 'available',
+    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)
+  })
 
-function acrossAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAdapter {
-  return {
-    async probeQuote(input, signal) {
-      onProbe()
-      expect(signal.aborted).toBe(false)
-      expect(input.candidate.id).toBe('base-usdc-tempo-usdce-across')
-      return {
-        expiresAt: '2026-01-01T00:01:00Z',
-        minimumOutputAmount: '988000',
-        outputAmount: '990000',
-        quality: {
-          estimatedSeconds: 2,
-          liquiditySource: 'providerQuote',
-          sourceDetail: 'across:swap-approval',
-          tier: 'liquid',
-        },
-        sampledAt: '2026-01-01T00:00:00Z',
-        status: 'available',
+  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,
       }
-    },
-  }
-}
+    `,
+    )
+  })
 
-function rhinoAdapter(): FundingQuotes.ProviderAdapter {
-  return {
-    async probeQuote(input, signal) {
-      expect(signal.aborted).toBe(false)
-      expect(input.candidate.id).toBe('solana-usdc-tempo-usdce-rhino')
-      return {
-        outputAmount: '983000',
-        quality: {
-          liquiditySource: 'providerQuote',
-          sourceDetail: 'rhino:bridge-swap-public',
-          tier: 'liquid',
-        },
-        sampledAt: '2026-01-01T00:00:00Z',
-        status: 'available',
+  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,
+  })
 }