tapimo 0.13.0 → 0.15.0

package/src/apps/{funding → routes}/routes/deposit-addresses.test.ts

@@ -2,39 +2,47 @@ import { Hash, Hex } from 'ox'
 
 import { tempoMainnet } from 'viem/tempo/chains'
 
-import * as FundingDepositAddresses from '../../../db/tables/fundingDepositAddresses.js'
+import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js'
 
-import * as FundingIdempotencyTable from '../../../db/tables/fundingIdempotency.js'
+import * as RoutesIdempotencyTable from '../../../db/tables/routesIdempotency.js'
+
+import * as Organizations from '../../../db/tables/organizations.js'
+
+import * as RoutesSubsidies from '../../../db/tables/routesSubsidies.js'
+
+import * as StripeCustomers from '../../../db/tables/stripeCustomers.js'
 
 import * as Cache from '../../../internal/Cache.js'
 
 import * as Cursor from '../../../internal/Cursor.js'
 
-import * as FundingDeposit from '../../../internal/funding/Deposit.js'
+import * as RoutesDeposit from '../../../internal/routes/Deposit.js'
 
-import * as FundingDepositAddress from '../../../internal/funding/DepositAddress.js'
+import * as RoutesDepositAddress from '../../../internal/routes/DepositAddress.js'
 
-import * as FundingProvider from '../../../internal/funding/Provider.js'
+import * as RoutesProvider from '../../../internal/routes/Provider.js'
 
 import * as Idempotency from '../../../internal/Idempotency.js'
 
-import * as Across from '../../../internal/funding/providers/across.js'
+import * as Across from '../../../internal/routes/providers/across.js'
 
-import * as Relay from '../../../internal/funding/providers/relay.js'
+import * as Relay from '../../../internal/routes/providers/relay.js'
 
-import * as Rhino from '../../../internal/funding/providers/rhino.js'
+import * as Rhino from '../../../internal/routes/providers/rhino.js'
 
-import * as Squid from '../../../internal/funding/providers/squid.js'
+import * as Squid from '../../../internal/routes/providers/squid.js'
 
-import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
+import * as Symbiosis from '../../../internal/routes/providers/symbiosis.js'
 
 import type * as Log from '../../../internal/Log.js'
 
+import * as Metrics from '../../../Metrics.js'
+
 import * as TestApp from '../../../../test/App.js'
 
-import * as TestFunding from '../../../../test/Funding.js'
+import * as TestRoutes from '../../../../test/Routes.js'
 
-import * as Funding from './deposit-addresses.js'
+import * as Routes from './deposit-addresses.js'
 
 const db = TestApp.database()
 const relayApiKey = process.env.RELAY_API_KEY
@@ -45,7 +53,7 @@ const providers = [
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
+  Relay.relay({ userAddresses: TestRoutes.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',
@@ -54,7 +62,7 @@ const providers = [
   Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
 ] as const
 
-beforeAll(() => TestFunding.publish(db))
+beforeAll(() => TestRoutes.publish(db))
 
 function create(options: TestApp.create.Options = {}) {
   return TestApp.create({ ...options, db })
@@ -80,21 +88,21 @@ function dereference(spec: ComponentSpec, schema: JsonSchema): JsonSchema {
   return spec.components.schemas[name]!
 }
 
-test('publishes generator-ready funding deposit contracts', async () => {
+test('publishes generator-ready route deposit contracts', async () => {
   const spec = await (await create({ auth: false }).request('/openapi.json')).json()
   const depositAddressPath = Object.keys(spec.paths).find(
-    (path) => path.includes('/v1/funding/deposit-addresses/{') && !path.endsWith('/reconcile'),
+    (path) => path.includes('/v1/routes/deposit-addresses/{') && !path.endsWith('/reconcile'),
   )!
   const depositPath = Object.keys(spec.paths).find((path) =>
-    path.includes('/v1/funding/deposits/{'),
+    path.includes('/v1/routes/deposits/{'),
   )!
   const reconcilePath = Object.keys(spec.paths).find((path) => path.endsWith('/reconcile'))!
   const operations = {
-    createAddress: spec.paths['/v1/funding/deposit-addresses'].post,
+    createAddress: spec.paths['/v1/routes/deposit-addresses'].post,
     getAddress: spec.paths[depositAddressPath].get,
     getDeposit: spec.paths[depositPath].get,
-    listAddresses: spec.paths['/v1/funding/deposit-addresses'].get,
-    listDeposits: spec.paths['/v1/funding/deposits'].get,
+    listAddresses: spec.paths['/v1/routes/deposit-addresses'].get,
+    listDeposits: spec.paths['/v1/routes/deposits'].get,
     reconcileAddress: spec.paths[reconcilePath].post,
   }
   const summarize = (operation: (typeof operations)[keyof typeof operations]) => ({
@@ -115,47 +123,47 @@ test('publishes generator-ready funding deposit contracts', async () => {
 
   expect({
     components: [
-      'CreateFundingDepositAddressRequest',
-      'CreateFundingDepositAddressResponse',
-      'CreatedFundingDepositAddress',
-      'FundingDeposit',
-      'FundingDepositAddress',
-      'FundingDepositAddressList',
-      'FundingDepositList',
-      'FundingDepositStatusReason',
+      'CreateRoutesDepositAddressRequest',
+      'CreateRoutesDepositAddressResponse',
+      'CreatedRoutesDepositAddress',
+      'RoutesDeposit',
+      'RoutesDepositAddress',
+      'RoutesDepositAddressList',
+      'RoutesDepositList',
+      'RoutesDepositStatusReason',
     ].filter((name) => spec.components.schemas[name]),
     formats: {
-      addressCreatedAt: spec.components.schemas.FundingDepositAddress.properties.createdAt.format,
-      addressUpdatedAt: spec.components.schemas.FundingDepositAddress.properties.updatedAt.format,
-      depositCreatedAt: spec.components.schemas.FundingDeposit.properties.createdAt.format,
-      depositUpdatedAt: spec.components.schemas.FundingDeposit.properties.updatedAt.format,
+      addressCreatedAt: spec.components.schemas.RoutesDepositAddress.properties.createdAt.format,
+      addressUpdatedAt: spec.components.schemas.RoutesDepositAddress.properties.updatedAt.format,
+      depositCreatedAt: spec.components.schemas.RoutesDeposit.properties.createdAt.format,
+      depositUpdatedAt: spec.components.schemas.RoutesDeposit.properties.updatedAt.format,
     },
     models: {
       address: {
-        destinationChain: spec.components.schemas.FundingDepositAddress.properties.destinationChain,
-        destinationToken: spec.components.schemas.FundingDepositAddress.properties.destinationToken,
-        provider: spec.components.schemas.FundingDepositAddress.properties.provider,
-        sourceChain: spec.components.schemas.FundingDepositAddress.properties.sourceChain,
-        sourceToken: spec.components.schemas.FundingDepositAddress.properties.sourceToken,
+        destinationChain: spec.components.schemas.RoutesDepositAddress.properties.destinationChain,
+        destinationToken: spec.components.schemas.RoutesDepositAddress.properties.destinationToken,
+        provider: spec.components.schemas.RoutesDepositAddress.properties.provider,
+        sourceChain: spec.components.schemas.RoutesDepositAddress.properties.sourceChain,
+        sourceToken: spec.components.schemas.RoutesDepositAddress.properties.sourceToken,
       },
-      addressList: spec.components.schemas.FundingDepositAddressList.properties.data.items,
-      createResponse: spec.components.schemas.CreateFundingDepositAddressResponse.anyOf,
+      addressList: spec.components.schemas.RoutesDepositAddressList.properties.data.items,
+      createResponse: spec.components.schemas.CreateRoutesDepositAddressResponse.anyOf,
       createdAddress: {
         feeToken: dereference(
           spec,
-          spec.components.schemas.CreatedFundingDepositAddress.properties.fees.items,
+          spec.components.schemas.CreatedRoutesDepositAddress.properties.fees.items,
         ).properties!['token'],
-        quote: spec.components.schemas.CreatedFundingDepositAddress.properties.quote,
+        quote: spec.components.schemas.CreatedRoutesDepositAddress.properties.quote,
       },
       deposit: {
-        destinationChain: spec.components.schemas.FundingDeposit.properties.destinationChain,
-        destinationToken: spec.components.schemas.FundingDeposit.properties.destinationToken,
-        provider: spec.components.schemas.FundingDeposit.properties.provider,
-        sourceChain: spec.components.schemas.FundingDeposit.properties.sourceChain,
-        sourceToken: spec.components.schemas.FundingDeposit.properties.sourceToken,
-        statusReason: spec.components.schemas.FundingDeposit.properties.statusReason,
+        destinationChain: spec.components.schemas.RoutesDeposit.properties.destinationChain,
+        destinationToken: spec.components.schemas.RoutesDeposit.properties.destinationToken,
+        provider: spec.components.schemas.RoutesDeposit.properties.provider,
+        sourceChain: spec.components.schemas.RoutesDeposit.properties.sourceChain,
+        sourceToken: spec.components.schemas.RoutesDeposit.properties.sourceToken,
+        statusReason: spec.components.schemas.RoutesDeposit.properties.statusReason,
       },
-      depositList: spec.components.schemas.FundingDepositList.properties.data.items,
+      depositList: spec.components.schemas.RoutesDepositList.properties.data.items,
     },
     operations: {
       createAddress: summarize(operations.createAddress),
@@ -167,19 +175,19 @@ test('publishes generator-ready funding deposit contracts', async () => {
     },
     sharedErrorCodes: {
       addressNotActive:
-        spec.components.schemas.FundingDepositAddressNotActiveError.properties.error.properties.code
+        spec.components.schemas.RoutesDepositAddressNotActiveError.properties.error.properties.code
           .enum,
       addressNotAvailable:
         spec.components.schemas.DepositAddressNotAvailableError.properties.error.properties.code
           .enum,
       addressNotFound:
-        spec.components.schemas.FundingDepositAddressNotFoundError.properties.error.properties.code
+        spec.components.schemas.RoutesDepositAddressNotFoundError.properties.error.properties.code
           .enum,
       createInvalid:
         spec.components.schemas.ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError.properties
           .error.properties.code.enum,
       depositNotFound:
-        spec.components.schemas.FundingDepositNotFoundError.properties.error.properties.code.enum,
+        spec.components.schemas.RoutesDepositNotFoundError.properties.error.properties.code.enum,
       idempotencyConflict:
         spec.components.schemas.IdempotencyConflictOrIdempotencyInProgressError.properties.error
           .properties.code.enum,
@@ -191,18 +199,22 @@ test('publishes generator-ready funding deposit contracts', async () => {
       queryInvalid:
         spec.components.schemas.ApiKeyMalformedOrQueryInvalidError.properties.error.properties.code
           .enum,
+      subsidyRejected:
+        spec.components.schemas.CreateRoutesDepositAddressForbiddenError.properties.error.properties
+          .code.enum,
     },
+    statusReasons: spec.components.schemas.RoutesDepositStatusReason.properties.code.enum,
   }).toMatchInlineSnapshot(`
     {
       "components": [
-        "CreateFundingDepositAddressRequest",
-        "CreateFundingDepositAddressResponse",
-        "CreatedFundingDepositAddress",
-        "FundingDeposit",
-        "FundingDepositAddress",
-        "FundingDepositAddressList",
-        "FundingDepositList",
-        "FundingDepositStatusReason",
+        "CreateRoutesDepositAddressRequest",
+        "CreateRoutesDepositAddressResponse",
+        "CreatedRoutesDepositAddress",
+        "RoutesDeposit",
+        "RoutesDepositAddress",
+        "RoutesDepositAddressList",
+        "RoutesDepositList",
+        "RoutesDepositStatusReason",
       ],
       "formats": {
         "addressCreatedAt": "date-time",
@@ -213,62 +225,62 @@ test('publishes generator-ready funding deposit contracts', async () => {
       "models": {
         "address": {
           "destinationChain": {
-            "$ref": "#/components/schemas/FundingChain",
+            "$ref": "#/components/schemas/RoutesChain",
           },
           "destinationToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
           "provider": {
-            "$ref": "#/components/schemas/FundingProvider",
+            "$ref": "#/components/schemas/RoutesProvider",
           },
           "sourceChain": {
-            "$ref": "#/components/schemas/FundingChain",
+            "$ref": "#/components/schemas/RoutesChain",
           },
           "sourceToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
         },
         "addressList": {
-          "$ref": "#/components/schemas/FundingDepositAddress",
+          "$ref": "#/components/schemas/RoutesDepositAddress",
         },
         "createResponse": [
           {
-            "$ref": "#/components/schemas/CreatedFundingDepositAddress",
+            "$ref": "#/components/schemas/CreatedRoutesDepositAddress",
           },
           {
-            "$ref": "#/components/schemas/FundingDepositAddress",
+            "$ref": "#/components/schemas/RoutesDepositAddress",
           },
         ],
         "createdAddress": {
           "feeToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
           "quote": {
-            "$ref": "#/components/schemas/FundingQuoteDetails",
+            "$ref": "#/components/schemas/RoutesQuoteDetails",
           },
         },
         "deposit": {
           "destinationChain": {
-            "$ref": "#/components/schemas/FundingChain",
+            "$ref": "#/components/schemas/RoutesChain",
           },
           "destinationToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
           "provider": {
-            "$ref": "#/components/schemas/FundingProvider",
+            "$ref": "#/components/schemas/RoutesProvider",
           },
           "sourceChain": {
-            "$ref": "#/components/schemas/FundingChain",
+            "$ref": "#/components/schemas/RoutesChain",
           },
           "sourceToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
           "statusReason": {
-            "$ref": "#/components/schemas/FundingDepositStatusReason",
+            "$ref": "#/components/schemas/RoutesDepositStatusReason",
           },
         },
         "depositList": {
-          "$ref": "#/components/schemas/FundingDeposit",
+          "$ref": "#/components/schemas/RoutesDeposit",
         },
       },
       "operations": {
@@ -281,7 +293,7 @@ test('publishes generator-ready funding deposit contracts', async () => {
               "$ref": "#/components/schemas/AuthenticationError",
             },
             "403": {
-              "$ref": "#/components/schemas/ForbiddenError",
+              "$ref": "#/components/schemas/CreateRoutesDepositAddressForbiddenError",
             },
             "404": {
               "$ref": "#/components/schemas/DepositAddressNotAvailableError",
@@ -296,12 +308,12 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "createFundingDepositAddress",
+          "operationId": "createRoutesDepositAddress",
           "request": {
-            "$ref": "#/components/schemas/CreateFundingDepositAddressRequest",
+            "$ref": "#/components/schemas/CreateRoutesDepositAddressRequest",
           },
           "response": {
-            "$ref": "#/components/schemas/CreateFundingDepositAddressResponse",
+            "$ref": "#/components/schemas/CreateRoutesDepositAddressResponse",
           },
         },
         "getAddress": {
@@ -316,7 +328,7 @@ test('publishes generator-ready funding deposit contracts', async () => {
               "$ref": "#/components/schemas/ForbiddenError",
             },
             "404": {
-              "$ref": "#/components/schemas/FundingDepositAddressNotFoundError",
+              "$ref": "#/components/schemas/RoutesDepositAddressNotFoundError",
             },
             "429": "#/components/responses/RateLimited",
             "500": "#/components/responses/InternalError",
@@ -325,10 +337,10 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "getFundingDepositAddress",
+          "operationId": "getRoutesDepositAddress",
           "request": undefined,
           "response": {
-            "$ref": "#/components/schemas/FundingDepositAddress",
+            "$ref": "#/components/schemas/RoutesDepositAddress",
           },
         },
         "getDeposit": {
@@ -343,7 +355,7 @@ test('publishes generator-ready funding deposit contracts', async () => {
               "$ref": "#/components/schemas/ForbiddenError",
             },
             "404": {
-              "$ref": "#/components/schemas/FundingDepositNotFoundError",
+              "$ref": "#/components/schemas/RoutesDepositNotFoundError",
             },
             "429": "#/components/responses/RateLimited",
             "500": "#/components/responses/InternalError",
@@ -352,10 +364,10 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "getFundingDeposit",
+          "operationId": "getRoutesDeposit",
           "request": undefined,
           "response": {
-            "$ref": "#/components/schemas/FundingDeposit",
+            "$ref": "#/components/schemas/RoutesDeposit",
           },
         },
         "listAddresses": {
@@ -376,10 +388,10 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "listFundingDepositAddresses",
+          "operationId": "listRoutesDepositAddresses",
           "request": undefined,
           "response": {
-            "$ref": "#/components/schemas/FundingDepositAddressList",
+            "$ref": "#/components/schemas/RoutesDepositAddressList",
           },
         },
         "listDeposits": {
@@ -400,10 +412,10 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "listFundingDeposits",
+          "operationId": "listRoutesDeposits",
           "request": undefined,
           "response": {
-            "$ref": "#/components/schemas/FundingDepositList",
+            "$ref": "#/components/schemas/RoutesDepositList",
           },
         },
         "reconcileAddress": {
@@ -418,10 +430,10 @@ test('publishes generator-ready funding deposit contracts', async () => {
               "$ref": "#/components/schemas/ForbiddenError",
             },
             "404": {
-              "$ref": "#/components/schemas/FundingDepositAddressNotFoundError",
+              "$ref": "#/components/schemas/RoutesDepositAddressNotFoundError",
             },
             "409": {
-              "$ref": "#/components/schemas/FundingDepositAddressNotActiveError",
+              "$ref": "#/components/schemas/RoutesDepositAddressNotActiveError",
             },
             "429": "#/components/responses/RateLimited",
             "500": "#/components/responses/InternalError",
@@ -433,20 +445,20 @@ test('publishes generator-ready funding deposit contracts', async () => {
             },
             "504": "#/components/responses/RequestTimeout",
           },
-          "operationId": "reconcileFundingDepositAddress",
+          "operationId": "reconcileRoutesDepositAddress",
           "request": undefined,
           "response": undefined,
         },
       },
       "sharedErrorCodes": {
         "addressNotActive": [
-          "funding_deposit_address_not_active",
+          "routes_deposit_address_not_active",
         ],
         "addressNotAvailable": [
           "deposit_address_not_available",
         ],
         "addressNotFound": [
-          "funding_deposit_address_not_found",
+          "routes_deposit_address_not_found",
         ],
         "createInvalid": [
           "api_key_malformed",
@@ -454,7 +466,7 @@ test('publishes generator-ready funding deposit contracts', async () => {
           "idempotency_key_required",
         ],
         "depositNotFound": [
-          "funding_deposit_not_found",
+          "routes_deposit_not_found",
         ],
         "idempotencyConflict": [
           "idempotency_conflict",
@@ -471,18 +483,41 @@ test('publishes generator-ready funding deposit contracts', async () => {
           "api_key_malformed",
           "query_invalid",
         ],
+        "subsidyRejected": [
+          "api_key_forbidden",
+          "api_key_ip_forbidden",
+          "billing_past_due",
+          "billing_required",
+          "forbidden",
+          "routes_deposit_address_limit_exceeded",
+          "routes_subsidy_not_enabled",
+        ],
       },
+      "statusReasons": [
+        "billing_past_due",
+        "billing_required",
+        "delivery_failed",
+        "delivery_liquidity_unavailable",
+        "manual_recovery_required",
+        "refund_failed",
+        "routes_subsidy_limit_exceeded",
+        "routes_subsidy_not_enabled",
+        "source_amount_not_supported",
+        "source_token_mismatch",
+        "subsidy_balance_unavailable",
+        "subsidy_failed",
+      ],
     }
   `)
 })
 
-describe('POST /funding/deposit-addresses', () => {
-  test('requires funding:write and an idempotency key', async () => {
+describe('POST /routes/deposit-addresses', () => {
+  test('requires routes: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)
+    expect((await postDepositAddress(app, { key: routesReader })).status).toBe(403)
     const response = await postDepositAddress(app, {
-      headers: { authorization: `Bearer ${fundingWriter.token}` },
+      headers: { authorization: `Bearer ${routesWriter.token}` },
     })
     expect(response.status).toBe(400)
     expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
@@ -524,11 +559,289 @@ describe('POST /funding/deposit-addresses', () => {
     )
   })
 
+  test('supports a legacy organization-less API key', async () => {
+    const response = await postDepositAddress(
+      transfersApp({
+        providers: [depositAddressProvider('TNWSLbWRWwZmFR2P1EV5ba53B5by2eqUkF')],
+      }),
+      { key: routesLegacyWriter },
+    )
+
+    expect(response.status).toBe(200)
+    expect(await Organizations.get(db, routesLegacyWriter.id)).toMatchObject({
+      id: routesLegacyWriter.id,
+      userId: null,
+    })
+  })
+
+  test('rejects a missing policy, records its bounded reason, and releases the claim', async () => {
+    await Organizations.upsert(db, {
+      id: routesSubsidyDisabledWriter.orgId,
+      name: 'Routes subsidy disabled',
+    })
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const metrics = Metrics.from({
+      count(name, value, tags) {
+        counts.push([name, value, tags])
+      },
+      flush() {},
+      gauge() {},
+      histogram() {},
+    })
+    const app = transfersApp({
+      metrics,
+      providers: [depositAddressProvider('TFvF6WzyeRKMM8NcbddxL88mZXTeuUWA8Z')],
+    })
+    const body = { ...depositAddressBody, subsidize: true }
+    const idempotencyKey = nextDepositAddressKey()
+    const rejected = await postDepositAddress(app, {
+      body,
+      idempotencyKey,
+      key: routesSubsidyDisabledWriter,
+    })
+
+    expect({ body: await rejected.json(), status: rejected.status }).toMatchInlineSnapshot(
+      {
+        body: { requestId: expect.any(String) },
+      },
+      `
+      {
+        "body": {
+          "error": {
+            "code": "routes_subsidy_not_enabled",
+            "message": "Routes subsidies are not enabled for this organization.",
+          },
+          "requestId": Any<String>,
+        },
+        "status": 403,
+      }
+    `,
+    )
+    expect(counts.find(([name]) => name === 'routes_subsidy_request_rejection_count')).toEqual([
+      'routes_subsidy_request_rejection_count',
+      1,
+      {
+        reason: 'routes_subsidy_not_enabled',
+        routes_environment: 'production',
+      },
+    ])
+
+    await enableRoutesSubsidy(routesSubsidyDisabledWriter, 'active')
+    expect(
+      (
+        await postDepositAddress(app, {
+          body,
+          idempotencyKey,
+          key: routesSubsidyDisabledWriter,
+        })
+      ).status,
+    ).toBe(200)
+  })
+
+  test('requires active production billing for an enabled policy', async () => {
+    await enableRoutesSubsidy(routesSubsidyBillingWriter)
+    await enableRoutesSubsidy(routesSubsidyPastDueWriter, 'past_due')
+    const app = transfersApp({ providers: [depositAddressProvider()] })
+
+    const required = await postDepositAddress(app, {
+      body: { ...depositAddressBody, subsidize: true },
+      key: routesSubsidyBillingWriter,
+    })
+    const pastDue = await postDepositAddress(app, {
+      body: { ...depositAddressBody, subsidize: true },
+      key: routesSubsidyPastDueWriter,
+    })
+
+    expect([
+      { body: await required.json(), status: required.status },
+      { body: await pastDue.json(), status: pastDue.status },
+    ]).toMatchInlineSnapshot(
+      [{ body: { requestId: expect.any(String) } }, { body: { requestId: expect.any(String) } }],
+      `
+      [
+        {
+          "body": {
+            "error": {
+              "code": "billing_required",
+              "message": "Billing required.",
+            },
+            "requestId": Any<String>,
+          },
+          "status": 403,
+        },
+        {
+          "body": {
+            "error": {
+              "code": "billing_past_due",
+              "message": "Billing past due.",
+            },
+            "requestId": Any<String>,
+          },
+          "status": 403,
+        },
+      ]
+    `,
+    )
+  })
+
+  test('replays a completed subsidy after policy and billing change', async () => {
+    await enableRoutesSubsidy(routesSubsidyReplayWriter, 'active')
+    const app = transfersApp({
+      providers: [depositAddressProvider('TG1YyTqihYBVjbzaoEm5gUdiZDNwHndhRg')],
+    })
+    const body = { ...depositAddressBody, subsidize: true }
+    const idempotencyKey = nextDepositAddressKey()
+    const first = await postDepositAddress(app, {
+      body,
+      idempotencyKey,
+      key: routesSubsidyReplayWriter,
+    })
+    const firstBody = await first.json()
+    await RoutesSubsidies.removeOrganization(db, routesSubsidyReplayWriter.orgId)
+    await StripeCustomers.setStatus(db, routesSubsidyReplayWriter.orgId, 'past_due')
+    const replay = await postDepositAddress(app, {
+      body,
+      idempotencyKey,
+      key: routesSubsidyReplayWriter,
+    })
+
+    expect({ body: await replay.json(), status: replay.status }).toEqual({ body: firstBody, status: 200 }) // prettier-ignore
+  })
+
+  test('preserves a subsidized claim after an ambiguous provider failure', async () => {
+    await enableRoutesSubsidy(routesSubsidyReplayWriter, 'active')
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider(undefined, () => {
+          throw new Error('connection closed after dispatch')
+        }),
+      ],
+    })
+    const body = {
+      ...depositAddressBody,
+      recipient: `0x${'22'.repeat(20)}`,
+      subsidize: true,
+    }
+    const idempotencyKey = nextDepositAddressKey()
+    const first = await postDepositAddress(app, {
+      body,
+      idempotencyKey,
+      key: routesSubsidyReplayWriter,
+    })
+    const retry = await postDepositAddress(app, {
+      body,
+      idempotencyKey,
+      key: routesSubsidyReplayWriter,
+    })
+
+    expect([first.status, retry.status]).toEqual([502, 409])
+    await expect(
+      db.kysely
+        .selectFrom('routes_idempotency_requests')
+        .select(['irrevocable', 'status'])
+        .where('apiKeyId', '=', routesSubsidyReplayWriter.id)
+        .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({ irrevocable: true, status: 'pending' })
+  })
+
+  test('resumes an expired provisioned subsidy without replaying stale quote terms', async () => {
+    await Organizations.upsert(db, {
+      id: routesSubsidyResumeWriter.orgId,
+      name: 'Routes subsidy resume',
+    })
+    const histograms: Parameters<Metrics.Metrics['histogram']>[] = []
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value, tags) {
+        histograms.push([name, value, tags])
+      },
+    })
+    const body = { ...depositAddressBody, subsidize: true }
+    const idempotencyKey = nextDepositAddressKey()
+    const identity = {
+      apiKeyId: routesSubsidyResumeWriter.id,
+      keyHash: Idempotency.inputHash(idempotencyKey),
+      requestHash: Idempotency.inputHash({
+        body,
+        endpoint: 'POST /v1/routes/deposit-addresses',
+      }),
+    }
+    const claim = await RoutesIdempotencyTable.claim(db, {
+      ...identity,
+      irrevocable: true,
+      operation: RoutesIdempotencyTable.operations.depositAddress,
+      orgId: routesSubsidyResumeWriter.orgId,
+      ttlMs: 60_000,
+    })
+    if (claim.type !== 'claimed') throw new Error('Expected a fresh idempotency claim.')
+    const snapshot = TestRoutes.depositAddressSnapshot({
+      address: 'TG6rrQgTkf3e85cYzqtD2q8fYuJDdM99Rx',
+      subsidize: true,
+    })
+    await RoutesIdempotencyTable.checkpoint(db, {
+      apiKeyId: identity.apiKeyId,
+      createdAt: claim.createdAt,
+      keyHash: identity.keyHash,
+      replayTtlMs: 86_400_000,
+      response: JSON.stringify({
+        candidate: {
+          destinationChain: snapshot.destinationChain,
+          destinationToken: snapshot.destinationToken,
+          sourceChain: snapshot.sourceChain,
+          sourceToken: snapshot.sourceToken,
+        },
+        provider: snapshot.provider,
+        recipient: snapshot.recipient,
+        refundAddress: snapshot.refundAddress,
+        result: {
+          address: snapshot.address,
+          correlation: { requestId: 'relay_resume_request' },
+          destinationAmount: '1000000',
+          destinationAmountMin: '1000000',
+          fees: [],
+          sampledAt: '2026-08-04T00:00:00.000Z',
+        },
+      }),
+    })
+    await db.kysely
+      .updateTable('routes_idempotency_requests')
+      .set({ expiresAt: new Date(0).toISOString() })
+      .where('apiKeyId', '=', identity.apiKeyId)
+      .where('keyHash', '=', identity.keyHash)
+      .execute()
+
+    const response = await postDepositAddress(transfersApp({ metrics, providers: [] }), {
+      body,
+      idempotencyKey,
+      key: routesSubsidyResumeWriter,
+    })
+
+    expect(response.status).toBe(200)
+    const responseBody = await TestApp.json(
+      response,
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    expect(responseBody.subsidize).toBe(true)
+    expect(responseBody).not.toHaveProperty('quote')
+    expect(
+      histograms.filter(
+        ([name]) =>
+          name.startsWith('routes_customer_') ||
+          name.startsWith('routes_tempo_provider_fee_') ||
+          name === 'routes_selection_delta_bps',
+      ),
+    ).toEqual([])
+  })
+
   test('creates a reusable address and persists private provider correlation', async () => {
-    let seen: FundingProvider.createDepositAddress.Parameters | undefined
-    const registered: FundingDepositAddress.Public[] = []
+    await Organizations.upsert(db, { id: routesWriter.orgId, name: 'Routes' })
+    let seen: RoutesProvider.createDepositAddress.Parameters | undefined
+    const registered: RoutesDepositAddress.Public[] = []
     const app = transfersApp({
-      funding: {
+      routes: {
         registerDepositAddress: async (address) => {
           registered.push(address)
         },
@@ -544,7 +857,7 @@ describe('POST /funding/deposit-addresses', () => {
     })
     expect(response.status).toBe(200)
     expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
+    const body = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
     expect(body).toMatchObject({
       address: 'TBXSw8fM4jpQkGc6zZjsVABFpVN7UvXPdV',
       destinationToken: { symbol: 'USDT0' },
@@ -559,7 +872,7 @@ describe('POST /funding/deposit-addresses', () => {
       recipient: depositAddressBody.recipient,
       refundAddress: depositAddressBody.refundAddress,
     })
-    const record = await FundingDepositAddresses.get(db, body.id)
+    const record = await RoutesDepositAddresses.get(db, body.id)
     expect(record).toMatchObject({
       deliveryStrategy: 'provider',
       providerOutputToken: body.destinationToken,
@@ -655,7 +968,7 @@ describe('POST /funding/deposit-addresses', () => {
           sourceToken: identifier.sourceToken,
         },
       })
-      const body = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
+      const body = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
       results.push({
         destinationToken: body.destinationToken.symbol,
         name: identifier.name,
@@ -700,14 +1013,14 @@ describe('POST /funding/deposit-addresses', () => {
     })
     const first = await TestApp.json(
       await postDepositAddress(app, { body, idempotencyKey: nextDepositAddressKey() }),
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
     const second = await TestApp.json(
       await postDepositAddress(app, {
         body: { ...body, amount: '200000000' },
         idempotencyKey: nextDepositAddressKey(),
       }),
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
     if (!('sourceAmount' in first)) throw new Error('Expected newly provisioned terms.')
 
@@ -725,7 +1038,7 @@ describe('POST /funding/deposit-addresses', () => {
       },
       `
       {
-        "calls": 2,
+        "calls": 1,
         "firstHasQuote": true,
         "firstId": Any<String>,
         "firstSourceAmount": "100000000",
@@ -738,7 +1051,8 @@ describe('POST /funding/deposit-addresses', () => {
   })
 
   test('stores subsidized addresses as a separate reusable identity', async () => {
-    const inputs: FundingProvider.createDepositAddress.Parameters[] = []
+    await enableRoutesSubsidy(routesSubsidyWriter, 'active')
+    const inputs: RoutesProvider.createDepositAddress.Parameters[] = []
     const app = transfersApp({
       providers: [
         withCreateDepositAddress('relay', async (input) => {
@@ -761,12 +1075,15 @@ describe('POST /funding/deposit-addresses', () => {
       sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
     }
     const standard = await TestApp.json(
-      await postDepositAddress(app, { body }),
-      Funding.schema.createFundingDepositAddress.Response,
+      await postDepositAddress(app, { body, key: routesSubsidyWriter }),
+      Routes.schema.createRoutesDepositAddress.Response,
     )
     const subsidized = await TestApp.json(
-      await postDepositAddress(app, { body: { ...body, subsidize: true } }),
-      Funding.schema.createFundingDepositAddress.Response,
+      await postDepositAddress(app, {
+        body: { ...body, subsidize: true },
+        key: routesSubsidyWriter,
+      }),
+      Routes.schema.createRoutesDepositAddress.Response,
     )
 
     expect({
@@ -787,8 +1104,37 @@ describe('POST /funding/deposit-addresses', () => {
     `)
   })
 
+  test('reuses a subsidized address across API keys in one organization', async () => {
+    await enableRoutesSubsidy(routesSubsidyWriter, 'active')
+    let calls = 0
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider(`0x${'34'.repeat(20)}`, () => {
+          calls += 1
+        }),
+      ],
+    })
+    const body = {
+      ...depositAddressBody,
+      refundAddress: `0x${'35'.repeat(20)}`,
+      sourceChain: 'base',
+      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+      subsidize: true,
+    }
+    const first = await TestApp.json(
+      await postDepositAddress(app, { body, key: routesSubsidyWriter }),
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    const second = await TestApp.json(
+      await postDepositAddress(app, { body, key: routesSubsidyWriterSecond }),
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+
+    expect({ calls, reused: first.id === second.id }).toEqual({ calls: 1, reused: true })
+  })
+
   test('normalizes EVM accounts before provisioning and matching', async () => {
-    const inputs: FundingProvider.createDepositAddress.Parameters[] = []
+    const inputs: RoutesProvider.createDepositAddress.Parameters[] = []
     const recipient = '0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD'
     const refundAddress = '0x1234567890AbcdEF1234567890aBcdef12345678'
     const body = {
@@ -807,7 +1153,7 @@ describe('POST /funding/deposit-addresses', () => {
     })
     const first = await TestApp.json(
       await postDepositAddress(app, { body, idempotencyKey: nextDepositAddressKey() }),
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
     const second = await TestApp.json(
       await postDepositAddress(app, {
@@ -818,7 +1164,7 @@ describe('POST /funding/deposit-addresses', () => {
         },
         idempotencyKey: nextDepositAddressKey(),
       }),
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
 
     expect({
@@ -837,10 +1183,6 @@ describe('POST /funding/deposit-addresses', () => {
             "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
             "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
           },
-          {
-            "recipient": "0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD",
-            "refundAddress": "0x1234567890AbcdEF1234567890aBcdef12345678",
-          },
         ],
         "reused": true,
         "second": {
@@ -860,7 +1202,7 @@ describe('POST /funding/deposit-addresses', () => {
         }),
         { body, idempotencyKey: nextDepositAddressKey() },
       ),
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
 
     let calls = 0
@@ -876,7 +1218,7 @@ describe('POST /funding/deposit-addresses', () => {
       body: { ...body, amount: '200000000' },
       idempotencyKey,
     })
-    const second = await TestApp.json(response, Funding.schema.createFundingDepositAddress.Response)
+    const second = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
 
     expect({
       address: second.address,
@@ -891,7 +1233,7 @@ describe('POST /funding/deposit-addresses', () => {
       `
       {
         "address": Any<String>,
-        "calls": 1,
+        "calls": 0,
         "hasQuote": false,
         "reused": true,
         "status": 200,
@@ -905,10 +1247,118 @@ describe('POST /funding/deposit-addresses', () => {
           body: { ...body, amount: '200000000' },
           idempotencyKey,
         }),
-        Funding.schema.createFundingDepositAddress.Response,
+        Routes.schema.createRoutesDepositAddress.Response,
       ),
     ).toEqual(second)
-    expect(calls).toBe(1)
+    expect(calls).toBe(0)
+  })
+
+  test('retains the provider checkpoint when address persistence fails', async () => {
+    const address = 'TKJebW6SdoJhgkKU13BeKCbrMzT6HeQhJ6'
+    const body = { ...depositAddressBody, recipient: `0x${'66'.repeat(20)}` }
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const histograms: Parameters<Metrics.Metrics['histogram']>[] = []
+    const metrics = Metrics.from({
+      count(name, value, tags) {
+        counts.push([name, value, tags])
+      },
+      flush() {},
+      gauge() {},
+      histogram(name, value, tags) {
+        histograms.push([name, value, tags])
+      },
+    })
+    await db.kysely.deleteFrom('routes_deposit_addresses').where('address', '=', address).execute()
+    await seedDepositAddress({
+      orgId: routesForeignWriter.orgId,
+      snapshot: TestRoutes.depositAddressSnapshot({
+        address,
+        provider: { id: 'relay', name: 'Relay' },
+        recipient: `0x${'33'.repeat(20)}`,
+      }),
+    })
+    const idempotencyKey = nextDepositAddressKey()
+    let calls = 0
+    const app = transfersApp({
+      metrics,
+      providers: [
+        depositAddressProvider(address, () => {
+          calls += 1
+        }),
+      ],
+    })
+    const response = await postDepositAddress(app, { body, idempotencyKey })
+
+    expect(response.status).toBe(502)
+    await expect(
+      db.kysely
+        .selectFrom('routes_idempotency_requests')
+        .select(['response', 'status'])
+        .where('apiKeyId', '=', routesWriter.id)
+        .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({ response: expect.any(String), status: 'provisioned' })
+
+    await db.kysely
+      .deleteFrom('routes_deposit_addresses')
+      .where('orgId', '=', routesForeignWriter.orgId)
+      .where('address', '=', address)
+      .execute()
+    const recoveredIdempotencyKey = nextDepositAddressKey()
+    const recovered = await postDepositAddress(app, {
+      body: { ...body, amount: '200000000' },
+      idempotencyKey: recoveredIdempotencyKey,
+      key: routesWriterSecond,
+    })
+    expect({ calls, status: recovered.status }).toEqual({ calls: 1, status: 200 })
+    const recoveredBody = await TestApp.json(
+      recovered,
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    expect(recoveredBody).toMatchObject({
+      address,
+    })
+    expect(recoveredBody).not.toHaveProperty('quote')
+    expect(counts.filter(([name]) => name === 'routes_resource_transition_count')).toEqual([
+      [
+        'routes_resource_transition_count',
+        1,
+        {
+          from_status: 'none',
+          method: 'deposit_address',
+          provider: 'relay',
+          reason: 'none',
+          resource: 'deposit_address',
+          routes_environment: 'production',
+          to_status: 'active',
+        },
+      ],
+    ])
+    expect(
+      histograms.filter(
+        ([name]) =>
+          name.startsWith('routes_customer_') ||
+          name.startsWith('routes_tempo_provider_fee_') ||
+          name === 'routes_selection_delta_bps',
+      ),
+    ).toEqual([])
+    const original = await postDepositAddress(app, { body, idempotencyKey })
+    expect(
+      await TestApp.json(original, Routes.schema.createRoutesDepositAddress.Response),
+    ).toMatchObject({ sourceAmount: { baseUnits: '100000000' } })
+    await expect(
+      db.kysely
+        .selectFrom('routes_idempotency_requests')
+        .select('status')
+        .where('apiKeyId', 'in', [routesWriter.id, routesWriterSecond.id])
+        .where('keyHash', 'in', [
+          Idempotency.inputHash(idempotencyKey),
+          Idempotency.inputHash(recoveredIdempotencyKey),
+        ])
+        .where('operation', '=', RoutesIdempotencyTable.operations.depositAddress)
+        .orderBy('apiKeyId')
+        .execute(),
+    ).resolves.toEqual([{ status: 'completed' }, { status: 'completed' }])
   })
 
   test('rejects a refund address from another chain', async () => {
@@ -969,12 +1419,12 @@ describe('POST /funding/deposit-addresses', () => {
     }
     const idempotencyKey = nextDepositAddressKey()
     const first = await postDepositAddress(app, { body: requestBody, idempotencyKey })
-    const response = await TestApp.json(first, Funding.schema.createFundingDepositAddress.Response)
+    const response = await TestApp.json(first, Routes.schema.createRoutesDepositAddress.Response)
     const { subsidize: _, ...legacy } = response
     await db.kysely
-      .updateTable('funding_idempotency_requests')
+      .updateTable('routes_idempotency_requests')
       .set({ response: JSON.stringify(legacy) })
-      .where('apiKeyId', '=', fundingWriter.id)
+      .where('apiKeyId', '=', routesWriter.id)
       .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
       .returningAll()
       .executeTakeFirstOrThrow()
@@ -982,7 +1432,7 @@ describe('POST /funding/deposit-addresses', () => {
     const replay = await postDepositAddress(app, { body: requestBody, idempotencyKey })
     const response_replay = await TestApp.json(
       replay,
-      Funding.schema.createFundingDepositAddress.Response,
+      Routes.schema.createRoutesDepositAddress.Response,
     )
 
     expect({ status: replay.status, subsidize: response_replay.subsidize }).toMatchInlineSnapshot(`
@@ -995,12 +1445,15 @@ describe('POST /funding/deposit-addresses', () => {
 
   test('preserves the idempotency fingerprint when subsidize is omitted', async () => {
     const idempotencyKey = nextDepositAddressKey()
-    await FundingIdempotencyTable.claim(db, {
-      apiKeyId: fundingWriter.id,
+    await RoutesIdempotencyTable.claim(db, {
+      apiKeyId: routesWriter.id,
+      irrevocable: false,
       keyHash: Idempotency.inputHash(idempotencyKey),
+      operation: RoutesIdempotencyTable.operations.depositAddress,
+      orgId: routesWriter.orgId,
       requestHash: Idempotency.inputHash({
         body: depositAddressBody,
-        endpoint: 'POST /v1/funding/deposit-addresses',
+        endpoint: 'POST /v1/routes/deposit-addresses',
       }),
       ttlMs: 60_000,
     })
@@ -1016,7 +1469,7 @@ describe('POST /funding/deposit-addresses', () => {
         "body": {
           "error": {
             "code": "idempotency_in_progress",
-            "message": "An equivalent funding deposit address creation is still running.",
+            "message": "An equivalent route deposit address creation is still running.",
           },
           "requestId": Any<String>,
         },
@@ -1028,9 +1481,12 @@ describe('POST /funding/deposit-addresses', () => {
 
   test('includes the creation endpoint in the idempotency fingerprint', async () => {
     const idempotencyKey = nextDepositAddressKey()
-    await FundingIdempotencyTable.claim(db, {
-      apiKeyId: fundingWriter.id,
+    await RoutesIdempotencyTable.claim(db, {
+      apiKeyId: routesWriter.id,
+      irrevocable: false,
       keyHash: Idempotency.inputHash(idempotencyKey),
+      operation: RoutesIdempotencyTable.operations.depositAddress,
+      orgId: routesWriter.orgId,
       requestHash: Idempotency.inputHash(depositAddressBody),
       ttlMs: 60_000,
     })
@@ -1081,19 +1537,355 @@ describe('POST /funding/deposit-addresses', () => {
       status: 502,
     })
   })
+
+  test('caps new addresses before provisioning while allowing reusable matches', async () => {
+    await Organizations.upsert(db, { id: routesLimitWriter.orgId, name: 'Routes limit' })
+    await seedDepositAddress({
+      orgId: routesLimitWriter.orgId,
+      snapshot: TestRoutes.depositAddressSnapshot({
+        address: 'limit-existing-address',
+        provider: { id: 'relay', name: 'Relay' },
+        recipient: depositAddressBody.recipient,
+      }),
+    })
+    for (let index = 0; index < RoutesDepositAddress.maximumPerCreator - 1; index++)
+      await seedDepositAddress({
+        orgId: routesLimitWriter.orgId,
+        snapshot: TestRoutes.depositAddressSnapshot({
+          address: `limit-address-${index}`,
+          provider: { id: 'relay', name: 'Relay' },
+          recipient: `0x${index.toString(16).padStart(40, '0')}`,
+        }),
+      })
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const metrics = Metrics.from({
+      count(name, value, tags) {
+        counts.push([name, value, tags])
+      },
+      flush() {},
+      gauge() {},
+      histogram() {},
+    })
+    let provisions = 0
+    const app = transfersApp({
+      metrics,
+      providers: [
+        depositAddressProvider(undefined, () => {
+          provisions++
+        }),
+      ],
+    })
+    const response = await postDepositAddress(app, {
+      body: { ...depositAddressBody, recipient: `0x${'22'.repeat(20)}` },
+      key: routesLimitWriter,
+    })
+
+    expect({
+      body: await response.json(),
+      metric: counts.find(([name]) => name === 'routes_deposit_address_limit_rejection_count'),
+      provisions,
+      status: response.status,
+    }).toMatchInlineSnapshot(
+      { body: { requestId: expect.any(String) } },
+      `
+      {
+        "body": {
+          "error": {
+            "code": "routes_deposit_address_limit_exceeded",
+            "message": "Route deposit address limit reached (100).",
+          },
+          "requestId": Any<String>,
+        },
+        "metric": [
+          "routes_deposit_address_limit_rejection_count",
+          1,
+          {
+            "routes_environment": "production",
+          },
+        ],
+        "provisions": 0,
+        "status": 403,
+      }
+    `,
+    )
+    const reused = await postDepositAddress(app, { key: routesLimitWriter })
+    expect(reused.status).toBe(200)
+    expect(provisions).toBe(0)
+    expect(await RoutesDepositAddresses.countByOrganization(db, routesLimitWriter.orgId)).toBe(
+      RoutesDepositAddress.maximumPerCreator,
+    )
+
+    const recoveryBody = {
+      ...depositAddressBody,
+      recipient: `0x${'33'.repeat(20)}`,
+      subsidize: true,
+    }
+    const recoverySourceKey = nextDepositAddressKey()
+    const recoveryRetryKey = nextDepositAddressKey()
+    const recoveryIdentity = {
+      apiKeyId: routesLimitWriter.id,
+      keyHash: Idempotency.inputHash(recoverySourceKey),
+      requestHash: Idempotency.inputHash({
+        body: recoveryBody,
+        endpoint: 'POST /v1/routes/deposit-addresses',
+      }),
+    }
+    const recoveryClaim = await RoutesIdempotencyTable.claim(db, {
+      ...recoveryIdentity,
+      irrevocable: true,
+      operation: RoutesIdempotencyTable.operations.depositAddress,
+      orgId: routesLimitWriter.orgId,
+      ttlMs: 60_000,
+    })
+    if (recoveryClaim.type !== 'claimed') throw new Error('Expected a recovery claim.')
+    const recoverySnapshot = TestRoutes.depositAddressSnapshot({
+      address: 'TPnd4mS1qPSySdshZ9BuS2mGtWuxBq4uc5',
+      recipient: recoveryBody.recipient,
+      subsidize: true,
+    })
+    await RoutesIdempotencyTable.checkpoint(db, {
+      apiKeyId: recoveryIdentity.apiKeyId,
+      createdAt: recoveryClaim.createdAt,
+      keyHash: recoveryIdentity.keyHash,
+      replayTtlMs: 86_400_000,
+      response: JSON.stringify({
+        candidate: {
+          destinationChain: recoverySnapshot.destinationChain,
+          destinationToken: recoverySnapshot.destinationToken,
+          sourceChain: recoverySnapshot.sourceChain,
+          sourceToken: recoverySnapshot.sourceToken,
+        },
+        provider: recoverySnapshot.provider,
+        recipient: recoverySnapshot.recipient,
+        refundAddress: recoverySnapshot.refundAddress,
+        result: {
+          address: recoverySnapshot.address,
+          correlation: { requestId: 'relay_limit_recovery' },
+          destinationAmount: '1000000',
+          destinationAmountMin: '1000000',
+          fees: [],
+          sampledAt: '2026-09-04T00:00:00.000Z',
+        },
+      }),
+    })
+
+    const recovered = await postDepositAddress(transfersApp({ providers: [] }), {
+      body: recoveryBody,
+      idempotencyKey: recoveryRetryKey,
+      key: routesLimitWriterSecond,
+    })
+    expect(recovered.status).toBe(200)
+    expect(await RoutesDepositAddresses.countByOrganization(db, routesLimitWriter.orgId)).toBe(
+      RoutesDepositAddress.maximumPerCreator + 1,
+    )
+    await expect(
+      db.kysely
+        .selectFrom('routes_idempotency_requests')
+        .select('status')
+        .where('keyHash', 'in', [recoveryIdentity.keyHash, Idempotency.inputHash(recoveryRetryKey)])
+        .orderBy('apiKeyId')
+        .execute(),
+    ).resolves.toEqual([{ status: 'completed' }, { status: 'completed' }])
+  })
+
+  test('reserves the final address slot before provider provisioning', async () => {
+    await Organizations.upsert(db, { id: routesRaceWriter.orgId, name: 'Routes race' })
+    for (let index = 0; index < RoutesDepositAddress.maximumPerCreator - 1; index++)
+      await seedDepositAddress({
+        orgId: routesRaceWriter.orgId,
+        snapshot: TestRoutes.depositAddressSnapshot({
+          provider: { id: `relay_race_${index}`, name: 'Relay' },
+          recipient: `0x${index.toString(16).padStart(40, '0')}`,
+        }),
+      })
+    const entered = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    let provisions = 0
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider('TRXcKoEvHr6Y38VMcDYGBEYKznvH3XUX4g', async () => {
+          provisions++
+          entered.resolve()
+          await release.promise
+        }),
+      ],
+    })
+    const first = postDepositAddress(app, { key: routesRaceWriter })
+    await entered.promise
+
+    const rejected = await postDepositAddress(app, {
+      body: { ...depositAddressBody, recipient: `0x${'99'.repeat(20)}` },
+      key: routesRaceWriter,
+    })
+    expect(rejected.status).toBe(403)
+    expect(provisions).toBe(1)
+
+    release.resolve()
+    expect((await first).status).toBe(200)
+    expect(await RoutesDepositAddresses.countByOrganization(db, routesRaceWriter.orgId)).toBe(
+      RoutesDepositAddress.maximumPerCreator,
+    )
+    await db.kysely
+      .deleteFrom('routes_deposit_addresses')
+      .where('orgId', '=', routesRaceWriter.orgId)
+      .execute()
+  })
+
+  test('joins concurrent reusable-match provisioning across idempotency keys', async () => {
+    await Organizations.upsert(db, { id: routesRaceWriter.orgId, name: 'Routes match race' })
+    const entered = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    let provisions = 0
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider('TT5rFsXYCrnzdE2q1WdR9F2SuVY59A4hoM', async () => {
+          provisions++
+          entered.resolve()
+          await release.promise
+        }),
+      ],
+    })
+    const first = postDepositAddress(app, {
+      idempotencyKey: 'routes_match_race_first',
+      key: routesRaceWriter,
+    })
+    await entered.promise
+
+    const joined = await postDepositAddress(app, {
+      body: { ...depositAddressBody, amount: '200000000' },
+      idempotencyKey: 'routes_match_race_second',
+      key: routesRaceWriter,
+    })
+    expect({ body: await joined.json(), provisions, status: joined.status }).toMatchInlineSnapshot(
+      { body: { requestId: expect.any(String) } },
+      `
+      {
+        "body": {
+          "error": {
+            "code": "idempotency_in_progress",
+            "message": "An equivalent route deposit address creation is still running.",
+          },
+          "requestId": Any<String>,
+        },
+        "provisions": 1,
+        "status": 409,
+      }
+    `,
+    )
+
+    release.resolve()
+    expect((await first).status).toBe(200)
+    const retried = await postDepositAddress(app, {
+      body: { ...depositAddressBody, amount: '200000000' },
+      idempotencyKey: 'routes_match_race_second',
+      key: routesRaceWriter,
+    })
+    expect(retried.status).toBe(200)
+    expect(provisions).toBe(1)
+  })
+
+  test('shares the final address slot across sibling organizations', async () => {
+    const userId = 'usr_routes_owner_race'
+    await Organizations.create(db, {
+      id: routesOwnerRaceWriter.orgId,
+      name: 'Routes owner race',
+      userId,
+    })
+    await Organizations.create(db, {
+      id: routesOwnerRaceSiblingWriter.orgId,
+      name: 'Routes owner race sibling',
+      userId,
+    })
+    for (let index = 0; index < RoutesDepositAddress.maximumPerCreator - 1; index++)
+      await seedDepositAddress({
+        orgId: routesOwnerRaceWriter.orgId,
+        snapshot: TestRoutes.depositAddressSnapshot({
+          provider: { id: `relay_owner_race_${index}`, name: 'Relay' },
+          recipient: `0x${index.toString(16).padStart(40, '0')}`,
+        }),
+      })
+    const entered = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    let provisions = 0
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider('TUe6BwpA7sVTDKaJQoia7FWZpC9sK8WM2t', async () => {
+          provisions++
+          entered.resolve()
+          await release.promise
+        }),
+      ],
+    })
+    const first = postDepositAddress(app, { key: routesOwnerRaceSiblingWriter })
+    await entered.promise
+
+    const rejected = await postDepositAddress(app, { key: routesOwnerRaceWriter })
+    expect(rejected.status).toBe(403)
+    expect(provisions).toBe(1)
+
+    release.resolve()
+    expect((await first).status).toBe(200)
+    expect(
+      (await RoutesDepositAddresses.countByOrganization(db, routesOwnerRaceWriter.orgId)) +
+        (await RoutesDepositAddresses.countByOrganization(db, routesOwnerRaceSiblingWriter.orgId)),
+    ).toBe(RoutesDepositAddress.maximumPerCreator)
+
+    expect(await Organizations.deleteOrganization(db, routesOwnerRaceWriter.orgId)).toBe(true)
+    await Organizations.create(db, {
+      id: routesOwnerRaceReplacementWriter.orgId,
+      name: 'Routes owner race replacement',
+      userId,
+    })
+    const replacement = await postDepositAddress(app, {
+      key: routesOwnerRaceReplacementWriter,
+    })
+    expect(replacement.status).toBe(403)
+    expect(provisions).toBe(1)
+  })
+
+  test('fences organization deletion while subsidized provider provisioning is in flight', async () => {
+    await enableRoutesSubsidy(routesSubsidyRaceWriter, 'active')
+    const entered = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const app = transfersApp({
+      providers: [
+        depositAddressProvider('TWCL826n2tBuoR7mp6oj5FzgitmfWSwCGZ', async () => {
+          entered.resolve()
+          await release.promise
+        }),
+      ],
+    })
+    const creation = postDepositAddress(app, {
+      body: { ...depositAddressBody, subsidize: true },
+      key: routesSubsidyRaceWriter,
+    })
+    await entered.promise
+
+    await expect(
+      Organizations.deleteOrganization(db, routesSubsidyRaceWriter.orgId),
+    ).rejects.toThrow(Organizations.IrrevocableDepositAddressError)
+    expect(await Organizations.get(db, routesSubsidyRaceWriter.orgId)).toBeDefined()
+
+    release.resolve()
+    expect((await creation).status).toBe(200)
+  })
 })
 
-describe('POST /webhooks/funding/relay', () => {
+describe('POST /webhooks/routes/relay', () => {
   test('authenticates and enqueues a bounded reconciliation hint', async () => {
     const secret = 'relay-webhook-secret'
     const address = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay', name: 'Relay' },
         recipient: `0x${'99'.repeat(20)}`,
       }),
     })
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
+    const entries: Log.Entry[] = []
     const app = transfersApp({
+      logger: (entry) => {
+        entries.push(entry)
+      },
       providers: [
         Relay.relay({
           apiKey: secret,
@@ -1121,7 +1913,7 @@ describe('POST /webhooks/funding/relay', () => {
       Hex.fromString(secret),
       Hex.fromString(`${timestamp}.${body}`),
     ).slice(2)
-    const response = await app.request('/webhooks/funding/relay', {
+    const response = await app.request('/webhooks/routes/relay', {
       body,
       headers: {
         'x-signature-sha256': signature,
@@ -1130,8 +1922,13 @@ describe('POST /webhooks/funding/relay', () => {
       method: 'POST',
     })
 
-    expect({ dispatched, status: response.status }).toMatchInlineSnapshot(
+    expect({
+      attempt: entries.at(-1)?.routesProviderAttempts?.[0],
+      dispatched,
+      status: response.status,
+    }).toMatchInlineSnapshot(
       {
+        attempt: { durationMs: expect.any(Number) },
         dispatched: [
           {
             webhookTiming: {
@@ -1145,12 +1942,18 @@ describe('POST /webhooks/funding/relay', () => {
       },
       `
       {
+        "attempt": {
+          "durationMs": Any<Number>,
+          "id": "relay",
+          "operation": "receiveWebhook",
+          "outcome": "success",
+        },
         "dispatched": [
           {
             "addressId": "${address.id}",
             "requestId": "relay-child-request",
             "trigger": "webhook",
-            "type": "funding:deposit-address:reconcile",
+            "type": "routes:deposit-address:reconcile",
             "webhookTiming": {
               "enqueuedAt": Any<String>,
               "providerStatus": "pending",
@@ -1175,16 +1978,46 @@ describe('POST /webhooks/funding/relay', () => {
         }),
       ],
     })
-    const response = await app.request('/webhooks/funding/relay', {
+    const response = await app.request('/webhooks/routes/relay', {
       body: '{}',
       method: 'POST',
     })
 
     expect(response.status).toMatchInlineSnapshot('401')
   })
+
+  test('rejects oversized events before signature verification', async () => {
+    const app = transfersApp({
+      providers: [
+        Relay.relay({
+          apiKey: 'relay-webhook-secret',
+          webhook: { db, dispatch: async () => {} },
+        }),
+      ],
+    })
+    const response = await app.request('/webhooks/routes/relay', {
+      body: 'x'.repeat(64 * 1_024 + 1),
+      headers: {
+        'x-signature-sha256': 'a'.repeat(64),
+        'x-signature-timestamp': String(Date.now()),
+      },
+      method: 'POST',
+    })
+
+    expect(response.status).toMatchInlineSnapshot('413')
+  })
+
+  test('rejects unknown providers before reading oversized events', async () => {
+    const response = await transfersApp().request('/webhooks/routes/unknown', {
+      body: 'x'.repeat(64 * 1_024 + 1),
+      method: 'POST',
+    })
+
+    expect(response.status).toMatchInlineSnapshot('404')
+  })
 })
 
-describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
+describe.skipIf(!relayApiKey)('POST /routes/deposit-addresses (relay)', () => {
   test('provisions and persists a reusable address through Relay', async () => {
     const app = transfersApp({
       providers: [Relay.relay({ apiKey: relayApiKey })],
@@ -1194,96 +2027,14 @@ describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
     })
 
     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)
+    const body = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
+    expect(body).toMatchObject({
+      address: expect.any(String),
+      id: expect.any(String),
+      provider: { id: 'relay' },
+      status: 'active',
+    })
+    const record = await RoutesDepositAddresses.get(db, body.id)
     expect(record).toMatchInlineSnapshot(
       {
         address: expect.any(String),
@@ -1293,20 +2044,21 @@ describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
         providerRequestIds: [expect.any(String)],
         providerState: expect.any(Object),
         snapshot: { address: expect.any(String) },
+        statusUpdatedAt: expect.any(String),
         updatedAt: expect.any(String),
       },
       `
       {
         "address": Any<String>,
-        "apiKeyId": "key_funding_writer",
         "createdAt": Any<String>,
+        "creatorUserId": null,
         "deliveryStrategy": "provider",
         "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
         "environment": "production",
         "id": Any<String>,
         "lastPolledAt": null,
         "nextPollAt": Any<String>,
-        "orgId": "org_funding",
+        "orgId": "org_routes",
         "pollFailureCount": 0,
         "pollLeaseUntil": null,
         "pollLeaseVersion": 0,
@@ -1373,6 +2125,7 @@ describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
         "sourceChainId": "tron:0x2b6653dc",
         "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
         "status": "active",
+        "statusUpdatedAt": Any<String>,
         "subsidize": false,
         "updatedAt": Any<String>,
         "version": 1,
@@ -1382,32 +2135,32 @@ describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
   })
 })
 
-describe('GET /funding/deposit-addresses', () => {
+describe('GET /routes/deposit-addresses', () => {
   test('pages organization addresses and narrows project-attributed keys', async () => {
     const app = transfersApp()
-    const first = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
-    const second = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
-    const third = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
+    const first = await seedDepositAddress({ orgId: routesAddressListReader.orgId })
+    const second = await seedDepositAddress({ orgId: routesAddressListReader.orgId })
+    const third = await seedDepositAddress({ orgId: routesAddressListReader.orgId })
     const project = await seedDepositAddress({
-      orgId: fundingAddressListReader.orgId,
-      projectId: fundingAddressListProjectReader.projectId,
+      orgId: routesAddressListReader.orgId,
+      projectId: routesAddressListProjectReader.projectId,
     })
     const sibling = await seedDepositAddress({
-      orgId: fundingAddressListReader.orgId,
-      projectId: 'prj_funding_address_list_sibling',
+      orgId: routesAddressListReader.orgId,
+      projectId: 'prj_routes_address_list_sibling',
     })
-    const sixth = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
-    await seedDepositAddress({ orgId: fundingForeign.orgId })
+    const sixth = await seedDepositAddress({ orgId: routesAddressListReader.orgId })
+    await seedDepositAddress({ orgId: routesForeign.orgId })
     await seedDepositAddress({
       environment: 'sandbox',
-      orgId: fundingAddressListReader.orgId,
+      orgId: routesAddressListReader.orgId,
     })
 
-    const path = '/v1/funding/deposit-addresses'
+    const path = '/v1/routes/deposit-addresses'
     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}?limit=5`, as(fundingAddressListReader))
+    const response = await app.request(`${path}?limit=5`, as(routesAddressListReader))
     expect(response.status).toBe(200)
     expect({
       cacheControl: response.headers.get('cache-control'),
@@ -1418,7 +2171,7 @@ describe('GET /funding/deposit-addresses', () => {
       etag: null,
       vary: 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key',
     })
-    const body = await TestApp.json(response, Funding.schema.listFundingDepositAddresses.Response)
+    const body = await TestApp.json(response, Routes.schema.listRoutesDepositAddresses.Response)
     expect(body.data.map((address) => address.id)).toEqual([
       sixth.id,
       sibling.id,
@@ -1429,29 +2182,29 @@ describe('GET /funding/deposit-addresses', () => {
     expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
 
     const next = await TestApp.json(
-      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(fundingAddressListReader)),
-      Funding.schema.listFundingDepositAddresses.Response,
+      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(routesAddressListReader)),
+      Routes.schema.listRoutesDepositAddresses.Response,
     )
     expect(next.data.map((address) => address.id)).toEqual([first.id])
     expect(next.nextCursor).toBeNull()
 
     const projectBody = await TestApp.json(
-      await app.request(path, as(fundingAddressListProjectReader)),
-      Funding.schema.listFundingDepositAddresses.Response,
+      await app.request(path, as(routesAddressListProjectReader)),
+      Routes.schema.listRoutesDepositAddresses.Response,
     )
     expect(projectBody.data.map((address) => address.id)).toEqual([project.id])
   })
 })
 
-describe('GET /funding/deposit-addresses/:id', () => {
-  test('requires funding:read and returns the owned address', async () => {
+describe('GET /routes/deposit-addresses/:id', () => {
+  test('requires routes:read and returns the owned address', async () => {
     const app = transfersApp()
     const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}`
+    const path = `/v1/routes/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))
+    const response = await app.request(path, as(routesReader))
     expect(response.status).toBe(200)
     expect({
       cacheControl: response.headers.get('cache-control'),
@@ -1465,8 +2218,8 @@ describe('GET /funding/deposit-addresses/:id', () => {
     expect(response.headers.get('vary')).toBe(
       'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key',
     )
-    const body = await TestApp.json(response, Funding.schema.getFundingDepositAddress.Response)
-    expect(body).toEqual(FundingDepositAddress.toPublic(record))
+    const body = await TestApp.json(response, Routes.schema.getRoutesDepositAddress.Response)
+    expect(body).toEqual(RoutesDepositAddress.toPublic(record))
     expect(body).not.toHaveProperty('providerOutputToken')
     expect(body).not.toHaveProperty('providerRequestIds')
   })
@@ -1474,40 +2227,40 @@ describe('GET /funding/deposit-addresses/:id', () => {
   test('hides foreign, project-inaccessible, and absent addresses', async () => {
     const app = transfersApp()
     const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}`
+    const path = `/v1/routes/deposit-addresses/${record.id}`
 
-    for (const key of [fundingForeign, fundingProjectReader]) {
+    for (const key of [routesForeign, routesProjectReader]) {
       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',
+        'routes_deposit_address_not_found',
       )
     }
 
     const absent = await app.request(
-      '/v1/funding/deposit-addresses/fda_000000000000000_000000000000000000000000',
-      as(fundingReader),
+      '/v1/routes/deposit-addresses/rda_000000000000000_000000000000000000000000',
+      as(routesReader),
     )
     expect(absent.status).toBe(404)
   })
 })
 
-describe('POST /funding/deposit-addresses/:id/reconcile', () => {
-  test('requires funding:write and queues the owned active address', async () => {
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+describe('POST /routes/deposit-addresses/:id/reconcile', () => {
+  test('requires routes:write and queues the owned active address', async () => {
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
     const app = transfersApp({
-      funding: {
-        dispatchReconciliation: async (message) => {
+      routes: {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
     })
     const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}/reconcile`
+    const path = `/v1/routes/deposit-addresses/${record.id}/reconcile`
     expect((await app.request(path, { method: 'POST' })).status).toBe(401)
-    expect((await app.request(path, { ...as(fundingReader), method: 'POST' })).status).toBe(403)
+    expect((await app.request(path, { ...as(routesReader), method: 'POST' })).status).toBe(403)
 
-    const response = await app.request(path, { ...as(fundingWriter), method: 'POST' })
+    const response = await app.request(path, { ...as(routesWriter), method: 'POST' })
     expect({
       body: await response.text(),
       cacheControl: response.headers.get('cache-control'),
@@ -1527,60 +2280,60 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
           {
             "addressId": "${record.id}",
             "trigger": "manual",
-            "type": "funding:deposit-address:reconcile",
+            "type": "routes:deposit-address:reconcile",
           },
         ],
         "rateLimit": {
           "limit": "10",
           "remaining": "9",
-          "scope": "funding:write",
+          "scope": "routes:write",
         },
         "status": 202,
         "vary": "Accept-Encoding, Authorization, Tempo-API-Key",
       }
     `)
-    expect(await FundingDepositAddresses.get(db, record.id)).toEqual(record)
+    expect(await RoutesDepositAddresses.get(db, record.id)).toEqual(record)
   })
 
   test('hides foreign, project-inaccessible, and absent addresses', async () => {
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
     const app = transfersApp({
-      funding: {
-        dispatchReconciliation: async (message) => {
+      routes: {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
     })
     const record = await seedDepositAddress()
-    const path = `/v1/funding/deposit-addresses/${record.id}/reconcile`
+    const path = `/v1/routes/deposit-addresses/${record.id}/reconcile`
 
-    for (const key of [fundingForeignWriter, fundingProjectWriter]) {
+    for (const key of [routesForeignWriter, routesProjectWriter]) {
       const response = await app.request(path, { ...as(key), method: 'POST' })
       expect(response.status).toBe(404)
       expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
-        'funding_deposit_address_not_found',
+        'routes_deposit_address_not_found',
       )
     }
 
     const absent = await app.request(
-      '/v1/funding/deposit-addresses/fda_000000000000000_000000000000000000000000/reconcile',
-      { ...as(fundingWriter), method: 'POST' },
+      '/v1/routes/deposit-addresses/rda_000000000000000_000000000000000000000000/reconcile',
+      { ...as(routesWriter), method: 'POST' },
     )
     expect(absent.status).toBe(404)
     expect(dispatched).toEqual([])
   })
 
   test('rejects inactive addresses and unavailable reconciliation', async () => {
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
     const configured = transfersApp({
-      funding: {
-        dispatchReconciliation: async (message) => {
+      routes: {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
     })
     const record = await seedDepositAddress()
-    const transition = await FundingDepositAddress.transition(db, {
+    const transition = await RoutesDepositAddress.transition(db, {
       expectedVersion: record.version,
       id: record.id,
       status: 'action-required',
@@ -1588,18 +2341,18 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
     expect(transition.type).toBe('applied')
 
     const inactive = await configured.request(
-      `/v1/funding/deposit-addresses/${record.id}/reconcile`,
-      { ...as(fundingWriter), method: 'POST' },
+      `/v1/routes/deposit-addresses/${record.id}/reconcile`,
+      { ...as(routesWriter), method: 'POST' },
     )
     expect({
       code: ((await inactive.json()) as { error: { code: string } }).error.code,
       status: inactive.status,
-    }).toEqual({ code: 'funding_deposit_address_not_active', status: 409 })
+    }).toEqual({ code: 'routes_deposit_address_not_active', status: 409 })
 
     const active = await seedDepositAddress()
     const unavailable = await transfersApp().request(
-      `/v1/funding/deposit-addresses/${active.id}/reconcile`,
-      { ...as(fundingWriter), method: 'POST' },
+      `/v1/routes/deposit-addresses/${active.id}/reconcile`,
+      { ...as(routesWriter), method: 'POST' },
     )
     expect({
       code: ((await unavailable.json()) as { error: { code: string } }).error.code,
@@ -1610,15 +2363,15 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
 
   test('returns an upstream error when the queue rejects the message', async () => {
     const app = transfersApp({
-      funding: {
-        dispatchReconciliation: async () => {
+      routes: {
+        dispatchDepositReconciliation: async () => {
           throw new Error('queue unavailable')
         },
       },
     })
     const record = await seedDepositAddress()
-    const response = await app.request(`/v1/funding/deposit-addresses/${record.id}/reconcile`, {
-      ...as(fundingWriter),
+    const response = await app.request(`/v1/routes/deposit-addresses/${record.id}/reconcile`, {
+      ...as(routesWriter),
       method: 'POST',
     })
 
@@ -1629,11 +2382,11 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
   })
 })
 
-describe('GET /funding/deposits?depositAddress', () => {
+describe('GET /routes/deposits?depositAddress', () => {
   test('pages deposits newest-first under an owned address', async () => {
     const app = transfersApp()
     const address = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
+      snapshot: TestRoutes.depositAddressSnapshot({
         address: 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE',
         provider: { id: 'relay_list_deposit_address', name: 'Relay' },
         recipient: `0x${'41'.repeat(20)}`,
@@ -1647,8 +2400,8 @@ describe('GET /funding/deposits?depositAddress', () => {
     const sixth = await seedDeposit(address)
 
     const response = await app.request(
-      `/v1/funding/deposits?depositAddress=${address.address}&limit=5`,
-      as(fundingReader),
+      `/v1/routes/deposits?depositAddress=${address.address}&limit=5`,
+      as(routesReader),
     )
     expect(response.status).toBe(200)
     expect({
@@ -1660,7 +2413,7 @@ describe('GET /funding/deposits?depositAddress', () => {
         "etag": null,
       }
     `)
-    const body = await TestApp.json(response, Funding.schema.listFundingDeposits.Response)
+    const body = await TestApp.json(response, Routes.schema.listRoutesDeposits.Response)
     expect(body.data.map((deposit) => deposit.id)).toEqual([
       sixth.id,
       fifth.id,
@@ -1672,10 +2425,10 @@ describe('GET /funding/deposits?depositAddress', () => {
 
     const next = await TestApp.json(
       await app.request(
-        `/v1/funding/deposits?depositAddress=${address.address}&limit=5&cursor=${body.nextCursor}`,
-        as(fundingReader),
+        `/v1/routes/deposits?depositAddress=${address.address}&limit=5&cursor=${body.nextCursor}`,
+        as(routesReader),
       ),
-      Funding.schema.listFundingDeposits.Response,
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(next.data.map((deposit) => deposit.id)).toEqual([first.id])
     expect(next.nextCursor).toBeNull()
@@ -1684,14 +2437,14 @@ describe('GET /funding/deposits?depositAddress', () => {
   test('returns a provider-observed deposit before source verification', async () => {
     const app = transfersApp()
     const address = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
+      snapshot: TestRoutes.depositAddressSnapshot({
         address: 'TF17BgPaZYbz8oxbjhriubPDsA7ArKoLX3',
         provider: { id: 'relay_observed', name: 'Relay' },
         recipient: `0x${'31'.repeat(20)}`,
       }),
     })
     const sourceTransactionHash = `0x${'ab'.repeat(32)}`
-    await FundingDeposit.create(db, {
+    await RoutesDeposit.create(db, {
       now: new Date('2026-01-04T00:00:00.000Z'),
       providerRequestId: 'relay-observed-request',
       snapshot: {
@@ -1709,11 +2462,11 @@ describe('GET /funding/deposits?depositAddress', () => {
     })
 
     const response = await app.request(
-      `/v1/funding/deposits?depositAddress=${address.address}`,
-      as(fundingReader),
+      `/v1/routes/deposits?depositAddress=${address.address}`,
+      as(routesReader),
     )
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingDeposits.Response)
+    const body = await TestApp.json(response, Routes.schema.listRoutesDeposits.Response)
     expect(body).toMatchInlineSnapshot(
       {
         data: [
@@ -1786,8 +2539,8 @@ describe('GET /funding/deposits?depositAddress', () => {
   test('hides a foreign deposit address', async () => {
     const app = transfersApp()
     const address = await seedDepositAddress({
-      orgId: fundingForeign.orgId,
-      snapshot: TestFunding.depositAddressSnapshot({
+      orgId: routesForeign.orgId,
+      snapshot: TestRoutes.depositAddressSnapshot({
         address: 'TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb',
         provider: { id: 'relay_foreign_deposit_address', name: 'Relay' },
         recipient: `0x${'42'.repeat(20)}`,
@@ -1795,50 +2548,50 @@ describe('GET /funding/deposits?depositAddress', () => {
     })
     await seedDeposit(address)
     const response = await app.request(
-      `/v1/funding/deposits?depositAddress=${address.address}`,
-      as(fundingReader),
+      `/v1/routes/deposits?depositAddress=${address.address}`,
+      as(routesReader),
     )
     expect(response.status).toBe(200)
-    expect(await TestApp.json(response, Funding.schema.listFundingDeposits.Response)).toEqual({
+    expect(await TestApp.json(response, Routes.schema.listRoutesDeposits.Response)).toEqual({
       data: [],
       nextCursor: null,
     })
   })
 })
 
-describe('GET /funding/deposits', () => {
+describe('GET /routes/deposits', () => {
   test('pages organization deposits and narrows project-attributed keys', async () => {
     const app = transfersApp()
-    const firstAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
-    const secondAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
-    const thirdAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const firstAddress = await seedDepositAddress({ orgId: routesDepositListReader.orgId })
+    const secondAddress = await seedDepositAddress({ orgId: routesDepositListReader.orgId })
+    const thirdAddress = await seedDepositAddress({ orgId: routesDepositListReader.orgId })
     const projectAddress = await seedDepositAddress({
-      orgId: fundingDepositListReader.orgId,
-      projectId: fundingDepositListProjectReader.projectId,
+      orgId: routesDepositListReader.orgId,
+      projectId: routesDepositListProjectReader.projectId,
     })
     const siblingAddress = await seedDepositAddress({
-      orgId: fundingDepositListReader.orgId,
-      projectId: 'prj_funding_deposit_list_sibling',
+      orgId: routesDepositListReader.orgId,
+      projectId: 'prj_routes_deposit_list_sibling',
     })
-    const sixthAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const sixthAddress = await seedDepositAddress({ orgId: routesDepositListReader.orgId })
     const first = await seedDeposit(firstAddress)
     const second = await seedDeposit(secondAddress)
     const third = await seedDeposit(thirdAddress)
     const project = await seedDeposit(projectAddress)
     const sibling = await seedDeposit(siblingAddress)
     const sixth = await seedDeposit(sixthAddress)
-    const foreignAddress = await seedDepositAddress({ orgId: fundingForeign.orgId })
+    const foreignAddress = await seedDepositAddress({ orgId: routesForeign.orgId })
     await seedDeposit(foreignAddress)
     const sandboxAddress = await seedDepositAddress({
       environment: 'sandbox',
-      orgId: fundingDepositListReader.orgId,
+      orgId: routesDepositListReader.orgId,
     })
     await seedDeposit(sandboxAddress)
 
-    const path = '/v1/funding/deposits'
-    const response = await app.request(`${path}?limit=5`, as(fundingDepositListReader))
+    const path = '/v1/routes/deposits'
+    const response = await app.request(`${path}?limit=5`, as(routesDepositListReader))
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingDeposits.Response)
+    const body = await TestApp.json(response, Routes.schema.listRoutesDeposits.Response)
     expect(body.data.map((deposit) => deposit.id)).toEqual([
       sixth.id,
       sibling.id,
@@ -1849,47 +2602,47 @@ describe('GET /funding/deposits', () => {
     expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
 
     const next = await TestApp.json(
-      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(fundingDepositListReader)),
-      Funding.schema.listFundingDeposits.Response,
+      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(routesDepositListReader)),
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(next.data.map((deposit) => deposit.id)).toEqual([first.id])
     expect(next.nextCursor).toBeNull()
 
     const projectBody = await TestApp.json(
-      await app.request(path, as(fundingDepositListProjectReader)),
-      Funding.schema.listFundingDeposits.Response,
+      await app.request(path, as(routesDepositListProjectReader)),
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(projectBody.data.map((deposit) => deposit.id)).toEqual([project.id])
   })
 })
 
-describe('GET /funding/deposits?recipient', () => {
-  test('requires funding:read and pages recipient deposits across addresses', async () => {
+describe('GET /routes/deposits?recipient', () => {
+  test('requires routes:read and pages recipient deposits across addresses', async () => {
     const app = transfersApp()
     const recipient = '0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD'
-    const path = `/v1/funding/deposits?recipient=${recipient.toLowerCase()}`
+    const path = `/v1/routes/deposits?recipient=${recipient.toLowerCase()}`
     expect((await app.request(path)).status).toBe(401)
     expect((await app.request(path, as(TestApp.key))).status).toBe(403)
     expect(
-      (await app.request('/v1/funding/deposits?depositAddress=', as(fundingReader))).status,
+      (await app.request('/v1/routes/deposits?depositAddress=', as(routesReader))).status,
     ).toBe(400)
     expect(
       (
         await app.request(
           `${path}&depositAddress=TJRabPrwbZy45sbavfcjinPJC18kjpRTv8`,
-          as(fundingReader),
+          as(routesReader),
         )
       ).status,
     ).toBe(200)
 
     const firstAddress = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_account_first', name: 'Relay' },
         recipient,
       }),
     })
     const secondAddress = await seedDepositAddress({
-      snapshot: TestFunding.depositAddressSnapshot({
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_account_second', name: 'Relay' },
         recipient,
         subsidize: true,
@@ -1904,15 +2657,15 @@ describe('GET /funding/deposits?recipient', () => {
     const unrelatedAddress = await seedDepositAddress()
     await seedDeposit(unrelatedAddress)
     const foreignAddress = await seedDepositAddress({
-      orgId: fundingForeign.orgId,
-      snapshot: TestFunding.depositAddressSnapshot({
+      orgId: routesForeign.orgId,
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_account_foreign', name: 'Relay' },
         recipient,
       }),
     })
     await seedDeposit(foreignAddress)
 
-    const response = await app.request(`${path}&limit=5`, as(fundingReader))
+    const response = await app.request(`${path}&limit=5`, as(routesReader))
     expect(response.status).toBe(200)
     expect({
       cacheControl: response.headers.get('cache-control'),
@@ -1925,7 +2678,7 @@ describe('GET /funding/deposits?recipient', () => {
         "vary": "Accept-Encoding, Authorization, Tempo-API-Key",
       }
     `)
-    const body = await TestApp.json(response, Funding.schema.listFundingDeposits.Response)
+    const body = await TestApp.json(response, Routes.schema.listRoutesDeposits.Response)
     expect(body.data.map((deposit) => deposit.id)).toEqual([
       sixth.id,
       fifth.id,
@@ -1936,8 +2689,8 @@ describe('GET /funding/deposits?recipient', () => {
     expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
 
     const next = await TestApp.json(
-      await app.request(`${path}&limit=5&cursor=${body.nextCursor}`, as(fundingReader)),
-      Funding.schema.listFundingDeposits.Response,
+      await app.request(`${path}&limit=5&cursor=${body.nextCursor}`, as(routesReader)),
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(next.data.map((deposit) => deposit.id)).toEqual([first.id])
     expect(next.nextCursor).toBeNull()
@@ -1947,15 +2700,15 @@ describe('GET /funding/deposits?recipient', () => {
     const app = transfersApp()
     const recipient = `0x${'ab'.repeat(20)}`
     const projectAddress = await seedDepositAddress({
-      projectId: fundingProjectReader.projectId,
-      snapshot: TestFunding.depositAddressSnapshot({
+      projectId: routesProjectReader.projectId,
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_account_project', name: 'Relay' },
         recipient,
       }),
     })
     const siblingAddress = await seedDepositAddress({
-      projectId: 'prj_funding_other',
-      snapshot: TestFunding.depositAddressSnapshot({
+      projectId: 'prj_routes_other',
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_account_sibling', name: 'Relay' },
         recipient,
       }),
@@ -1964,27 +2717,27 @@ describe('GET /funding/deposits?recipient', () => {
     await seedDeposit(siblingAddress)
 
     const body = await TestApp.json(
-      await app.request(`/v1/funding/deposits?recipient=${recipient}`, as(fundingProjectReader)),
-      Funding.schema.listFundingDeposits.Response,
+      await app.request(`/v1/routes/deposits?recipient=${recipient}`, as(routesProjectReader)),
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(body.data.map((deposit) => deposit.id)).toEqual([projectDeposit.id])
   })
 })
 
-describe('GET /funding/deposits?filters', () => {
+describe('GET /routes/deposits?filters', () => {
   test('AND-combines canonical aliases and includes the matching count', async () => {
     const app = transfersApp()
-    const snapshot = TestFunding.depositAddressSnapshot({
+    const snapshot = TestRoutes.depositAddressSnapshot({
       address: 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE',
     })
     const address = await seedDepositAddress({
-      orgId: fundingDepositFilterReader.orgId,
+      orgId: routesDepositFilterReader.orgId,
       snapshot,
     })
     const deposit = await seedDeposit(address)
     const unrelatedAddress = await seedDepositAddress({
-      orgId: fundingDepositFilterReader.orgId,
-      snapshot: TestFunding.depositAddressSnapshot({
+      orgId: routesDepositFilterReader.orgId,
+      snapshot: TestRoutes.depositAddressSnapshot({
         provider: { id: 'relay_unrelated', name: 'Relay' },
         recipient: `0x${'22'.repeat(20)}`,
       }),
@@ -2002,21 +2755,21 @@ describe('GET /funding/deposits?filters', () => {
     })
 
     const body = await TestApp.json(
-      await app.request(`/v1/funding/deposits?${query}`, as(fundingDepositFilterReader)),
-      Funding.schema.listFundingDeposits.Response,
+      await app.request(`/v1/routes/deposits?${query}`, as(routesDepositFilterReader)),
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(body).toEqual({
-      data: [FundingDeposit.toPublic(deposit)],
+      data: [RoutesDeposit.toPublic(deposit)],
       meta: { totalCount: 1, totalCountCapped: false },
       nextCursor: null,
     })
 
     const empty = await TestApp.json(
       await app.request(
-        '/v1/funding/deposits?sourceToken=unknown&include=totalCount',
-        as(fundingDepositFilterReader),
+        '/v1/routes/deposits?sourceToken=unknown&include=totalCount',
+        as(routesDepositFilterReader),
       ),
-      Funding.schema.listFundingDeposits.Response,
+      Routes.schema.listRoutesDeposits.Response,
     )
     expect(empty).toEqual({
       data: [],
@@ -2026,7 +2779,7 @@ describe('GET /funding/deposits?filters', () => {
   })
 })
 
-describe('GET /funding/deposits/:id', () => {
+describe('GET /routes/deposits/:id', () => {
   test('returns the owned deposit without private reconciliation state', async () => {
     const app = transfersApp()
     const address = await seedDepositAddress()
@@ -2034,11 +2787,11 @@ describe('GET /funding/deposits/:id', () => {
       providerRequestIds: ['relay-private'],
       providerState: { request: 'private' },
     })
-    const response = await app.request(`/v1/funding/deposits/${record.id}`, as(fundingReader))
+    const response = await app.request(`/v1/routes/deposits/${record.id}`, as(routesReader))
     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))
+    const body = await TestApp.json(response, Routes.schema.getRoutesDeposit.Response)
+    expect(body).toEqual(RoutesDeposit.toPublic(record))
     expect(body).not.toHaveProperty('providerRequestIds')
     expect(body).not.toHaveProperty('providerState')
   })
@@ -2047,14 +2800,14 @@ describe('GET /funding/deposits/:id', () => {
     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/routes/deposits/${record.id}`, as(routesForeign))).status).toBe(
+      404,
+    )
     expect(
       (
         await app.request(
-          '/v1/funding/deposits/fdp_000000000000000_000000000000000000000000',
-          as(fundingReader),
+          '/v1/routes/deposits/rdp_000000000000000_000000000000000000000000',
+          as(routesReader),
         )
       ).status,
     ).toBe(404)
@@ -2073,7 +2826,7 @@ const depositAddressBody = {
 let depositAddressIdempotencySequence = 0
 
 function nextDepositAddressKey() {
-  return `funding_deposit_address_${depositAddressIdempotencySequence++}`
+  return `routes_deposit_address_${depositAddressIdempotencySequence++}`
 }
 
 function postDepositAddress(
@@ -2085,10 +2838,10 @@ function postDepositAddress(
     key?: { token: string } | undefined
   } = {},
 ) {
-  return app.request('/v1/funding/deposit-addresses', {
+  return app.request('/v1/routes/deposit-addresses', {
     body: JSON.stringify(options.body ?? depositAddressBody),
     headers: options.headers ?? {
-      authorization: `Bearer ${(options.key ?? fundingWriter).token}`,
+      authorization: `Bearer ${(options.key ?? routesWriter).token}`,
       'content-type': 'application/json',
       'idempotency-key': options.idempotencyKey ?? nextDepositAddressKey(),
     },
@@ -2097,20 +2850,22 @@ function postDepositAddress(
 }
 
 function withCreateDepositAddress(
-  id: FundingProvider.ProviderId,
-  createDepositAddress: NonNullable<FundingProvider.Provider['createDepositAddress']>,
+  id: RoutesProvider.ProviderId,
+  createDepositAddress: NonNullable<RoutesProvider.Provider['createDepositAddress']>,
 ) {
   const provider = providers.find((entry) => entry.id === id)
   if (!provider) throw new Error(`Missing ${id} provider`)
-  return FundingProvider.from({ ...provider, createDepositAddress })
+  return RoutesProvider.from({ ...provider, createDepositAddress })
 }
 
 function depositAddressProvider(
   address = 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
-  onCreate: (input: FundingProvider.createDepositAddress.Parameters) => void = () => {},
+  onCreate: (
+    input: RoutesProvider.createDepositAddress.Parameters,
+  ) => void | Promise<void> = () => {},
 ) {
   return withCreateDepositAddress('relay', async (input) => {
-    onCreate(input)
+    await onCreate(input)
     return {
       address,
       correlation: {
@@ -2125,87 +2880,199 @@ function depositAddressProvider(
   })
 }
 
-const fundingReader = {
-  id: 'key_funding',
-  orgId: 'org_funding',
-  scopes: ['funding:read'],
-  token: 'secret_funding_reader',
+const routesReader = {
+  id: 'key_routes',
+  orgId: 'org_routes',
+  scopes: ['routes:read'],
+  token: 'secret_routes_reader',
+} satisfies TestApp.kvStore.Key
+
+const routesAddressListReader = {
+  id: 'key_routes_address_list',
+  orgId: 'org_routes_address_list',
+  scopes: ['routes:read'],
+  token: 'secret_routes_address_list',
 } satisfies TestApp.kvStore.Key
 
-const fundingAddressListReader = {
-  id: 'key_funding_address_list',
-  orgId: 'org_funding_address_list',
-  scopes: ['funding:read'],
-  token: 'secret_funding_address_list',
+const routesAddressListProjectReader = {
+  id: 'key_routes_address_list_project',
+  orgId: routesAddressListReader.orgId,
+  projectId: 'prj_routes_address_list',
+  scopes: ['routes:read'],
+  token: 'secret_routes_address_list_project',
 } satisfies TestApp.kvStore.Key
 
-const fundingAddressListProjectReader = {
-  id: 'key_funding_address_list_project',
-  orgId: fundingAddressListReader.orgId,
-  projectId: 'prj_funding_address_list',
-  scopes: ['funding:read'],
-  token: 'secret_funding_address_list_project',
+const routesDepositListReader = {
+  id: 'key_routes_deposit_list',
+  orgId: 'org_routes_deposit_list',
+  scopes: ['routes:read'],
+  token: 'secret_routes_deposit_list',
 } satisfies TestApp.kvStore.Key
 
-const fundingDepositListReader = {
-  id: 'key_funding_deposit_list',
-  orgId: 'org_funding_deposit_list',
-  scopes: ['funding:read'],
-  token: 'secret_funding_deposit_list',
+const routesDepositFilterReader = {
+  id: 'key_routes_deposit_filter',
+  orgId: 'org_routes_deposit_filter',
+  scopes: ['routes:read'],
+  token: 'secret_routes_deposit_filter',
 } satisfies TestApp.kvStore.Key
 
-const fundingDepositFilterReader = {
-  id: 'key_funding_deposit_filter',
-  orgId: 'org_funding_deposit_filter',
-  scopes: ['funding:read'],
-  token: 'secret_funding_deposit_filter',
+const routesDepositListProjectReader = {
+  id: 'key_routes_deposit_list_project',
+  orgId: routesDepositListReader.orgId,
+  projectId: 'prj_routes_deposit_list',
+  scopes: ['routes:read'],
+  token: 'secret_routes_deposit_list_project',
 } satisfies TestApp.kvStore.Key
 
-const fundingDepositListProjectReader = {
-  id: 'key_funding_deposit_list_project',
-  orgId: fundingDepositListReader.orgId,
-  projectId: 'prj_funding_deposit_list',
-  scopes: ['funding:read'],
-  token: 'secret_funding_deposit_list_project',
+const routesProjectReader = {
+  id: 'key_routes_project',
+  orgId: 'org_routes',
+  projectId: 'prj_routes',
+  scopes: ['routes:read'],
+  token: 'secret_routes_project',
 } satisfies TestApp.kvStore.Key
 
-const fundingProjectReader = {
-  id: 'key_funding_project',
-  orgId: 'org_funding',
-  projectId: 'prj_funding',
-  scopes: ['funding:read'],
-  token: 'secret_funding_project',
+const routesForeign = {
+  id: 'key_routes_other',
+  orgId: 'org_routes_other',
+  scopes: ['routes:read'],
+  token: 'secret_routes_other',
 } satisfies TestApp.kvStore.Key
 
-const fundingForeign = {
-  id: 'key_funding_other',
-  orgId: 'org_funding_other',
-  scopes: ['funding:read'],
-  token: 'secret_funding_other',
+/** Key with routes write access in a different organization. */
+const routesForeignWriter = {
+  id: 'key_routes_other_writer',
+  orgId: routesForeign.orgId,
+  scopes: ['routes:write'],
+  token: 'secret_routes_other_writer',
 } satisfies TestApp.kvStore.Key
 
-/** Key with funding write access in a different organization. */
-const fundingForeignWriter = {
-  id: 'key_funding_other_writer',
-  orgId: fundingForeign.orgId,
-  scopes: ['funding:write'],
-  token: 'secret_funding_other_writer',
+/** Project-attributed routes writer in the owning organization. */
+const routesProjectWriter = {
+  id: 'key_routes_project_writer',
+  orgId: routesReader.orgId,
+  projectId: routesProjectReader.projectId,
+  scopes: ['routes:write'],
+  token: 'secret_routes_project_writer',
 } satisfies TestApp.kvStore.Key
 
-/** Project-attributed funding writer in the owning organization. */
-const fundingProjectWriter = {
-  id: 'key_funding_project_writer',
-  orgId: fundingReader.orgId,
-  projectId: fundingProjectReader.projectId,
-  scopes: ['funding:write'],
-  token: 'secret_funding_project_writer',
+const routesSubsidyBillingWriter = {
+  id: 'key_routes_subsidy_billing',
+  orgId: 'org_routes_subsidy_billing',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_billing',
 } satisfies TestApp.kvStore.Key
 
-const fundingWriter = {
-  id: 'key_funding_writer',
-  orgId: 'org_funding',
-  scopes: ['funding:read', 'funding:write'],
-  token: 'secret_funding_writer',
+const routesSubsidyDisabledWriter = {
+  id: 'key_routes_subsidy_disabled',
+  orgId: 'org_routes_subsidy_disabled',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_disabled',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyPastDueWriter = {
+  id: 'key_routes_subsidy_past_due',
+  orgId: 'org_routes_subsidy_past_due',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_past_due',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyReplayWriter = {
+  id: 'key_routes_subsidy_replay',
+  orgId: 'org_routes_subsidy_replay',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_replay',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyResumeWriter = {
+  id: 'key_routes_subsidy_resume',
+  orgId: 'org_routes_subsidy_resume',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_resume',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyWriter = {
+  id: 'key_routes_subsidy',
+  orgId: 'org_routes_subsidy',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyWriterSecond = {
+  id: 'key_routes_subsidy_second',
+  orgId: routesSubsidyWriter.orgId,
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_second',
+} satisfies TestApp.kvStore.Key
+
+const routesWriter = {
+  id: 'key_routes_writer',
+  orgId: 'org_routes',
+  scopes: ['routes:read', 'routes:write'],
+  token: 'secret_routes_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesWriterSecond = {
+  id: 'key_routes_writer_second',
+  orgId: routesWriter.orgId,
+  scopes: ['routes:read', 'routes:write'],
+  token: 'secret_routes_writer_second',
+} satisfies TestApp.kvStore.Key
+
+const routesLimitWriter = {
+  id: 'key_routes_limit_writer',
+  orgId: 'org_routes_limit',
+  scopes: ['routes:write'],
+  token: 'secret_routes_limit_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesLimitWriterSecond = {
+  id: 'key_routes_limit_writer_second',
+  orgId: routesLimitWriter.orgId,
+  scopes: ['routes:write'],
+  token: 'secret_routes_limit_writer_second',
+} satisfies TestApp.kvStore.Key
+
+const routesLegacyWriter = {
+  id: 'key_routes_legacy_writer',
+  orgId: 'key_routes_legacy_writer',
+  scopes: ['routes:write'],
+  token: 'secret_routes_legacy_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesRaceWriter = {
+  id: 'key_routes_race_writer',
+  orgId: 'org_routes_race',
+  scopes: ['routes:write'],
+  token: 'secret_routes_race_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesOwnerRaceWriter = {
+  id: 'key_routes_owner_race_writer',
+  orgId: 'org_routes_owner_race',
+  scopes: ['routes:write'],
+  token: 'secret_routes_owner_race_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesOwnerRaceSiblingWriter = {
+  id: 'key_routes_owner_race_sibling_writer',
+  orgId: 'org_routes_owner_race_sibling',
+  scopes: ['routes:write'],
+  token: 'secret_routes_owner_race_sibling_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesOwnerRaceReplacementWriter = {
+  id: 'key_routes_owner_race_replacement_writer',
+  orgId: 'org_routes_owner_race_replacement',
+  scopes: ['routes:write'],
+  token: 'secret_routes_owner_race_replacement_writer',
+} satisfies TestApp.kvStore.Key
+
+const routesSubsidyRaceWriter = {
+  id: 'key_routes_subsidy_race_writer',
+  orgId: 'org_routes_subsidy_race',
+  scopes: ['routes:write'],
+  token: 'secret_routes_subsidy_race_writer',
 } satisfies TestApp.kvStore.Key
 
 function transfersApp(options: TestApp.create.Options = {}) {
@@ -2214,41 +3081,74 @@ function transfersApp(options: TestApp.create.Options = {}) {
     auth: {
       keys: [
         TestApp.key,
-        fundingAddressListProjectReader,
-        fundingAddressListReader,
-        fundingDepositFilterReader,
-        fundingDepositListProjectReader,
-        fundingDepositListReader,
-        fundingForeign,
-        fundingForeignWriter,
-        fundingProjectReader,
-        fundingProjectWriter,
-        fundingReader,
-        fundingWriter,
+        routesAddressListProjectReader,
+        routesAddressListReader,
+        routesDepositFilterReader,
+        routesDepositListProjectReader,
+        routesDepositListReader,
+        routesForeign,
+        routesForeignWriter,
+        routesProjectReader,
+        routesProjectWriter,
+        routesReader,
+        routesLegacyWriter,
+        routesLimitWriter,
+        routesLimitWriterSecond,
+        routesOwnerRaceReplacementWriter,
+        routesOwnerRaceSiblingWriter,
+        routesOwnerRaceWriter,
+        routesRaceWriter,
+        routesSubsidyBillingWriter,
+        routesSubsidyDisabledWriter,
+        routesSubsidyPastDueWriter,
+        routesSubsidyRaceWriter,
+        routesSubsidyReplayWriter,
+        routesSubsidyResumeWriter,
+        routesSubsidyWriter,
+        routesSubsidyWriterSecond,
+        routesWriter,
+        routesWriterSecond,
       ],
     },
     defaultChainId: options.defaultChainId ?? tempoMainnet.id,
   })
 }
 
+async function enableRoutesSubsidy(
+  key: TestApp.kvStore.Key,
+  billingStatus?: StripeCustomers.Status,
+) {
+  await Organizations.upsert(db, { id: key.orgId, name: key.orgId })
+  await RoutesSubsidies.upsertOrganization(db, {
+    frequency: 'tx',
+    maxAmount: '5',
+    orgId: key.orgId,
+  })
+  if (!billingStatus) return
+  await StripeCustomers.create(db, {
+    orgId: key.orgId,
+    stripeCustomerId: `cus_${key.id}`,
+  })
+  await StripeCustomers.setStatus(db, key.orgId, billingStatus)
+}
+
 function as(key: { token: string }) {
   return { headers: { authorization: `Bearer ${key.token}` } } as const
 }
 
 let seedDepositAddressSecond = 0
 
-function seedDepositAddress(input: Partial<FundingDepositAddress.create.Input> = {}) {
+function seedDepositAddress(input: Partial<RoutesDepositAddress.create.Input> = {}) {
   const index = seedDepositAddressSecond++
   const now = new Date(Date.UTC(2026, 0, 3, 0, 0, index))
-  return FundingDepositAddress.create(db, {
-    apiKeyId: fundingReader.id,
+  return RoutesDepositAddress.create(db, {
     deliveryStrategy: 'provider',
     environment: 'production',
-    id: FundingDepositAddress.generateId(now),
+    id: RoutesDepositAddress.generateId(now),
     now,
-    orgId: fundingReader.orgId,
-    providerOutputToken: TestFunding.providerOutputToken(),
-    snapshot: TestFunding.depositAddressSnapshot({
+    orgId: routesReader.orgId,
+    providerOutputToken: TestRoutes.providerOutputToken(),
+    snapshot: TestRoutes.depositAddressSnapshot({
       provider: { id: `relay_route_${index}`, name: 'Relay' },
       recipient: `0x${index.toString(16).padStart(40, '0')}`,
     }),
@@ -2260,15 +3160,15 @@ let seedDepositSecond = 0
 
 function seedDeposit(
   address: Awaited<ReturnType<typeof seedDepositAddress>>,
-  input: Partial<FundingDeposit.create.Input> = {},
+  input: Partial<RoutesDeposit.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, {
+  return RoutesDeposit.create(db, {
     now,
     providerRequestId: `relay_request_${index}`,
-    snapshot: TestFunding.depositSnapshot(address.id, {
+    snapshot: TestRoutes.depositSnapshot(address.id, {
       provider: address.snapshot.provider,
       sourceTransactionHashes: [sourceTransactionHash],
     }),