tapimo 0.14.0 → 0.15.0

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

@@ -1,43 +1,48 @@
 import { type Context, Hono } from 'hono'
+import { bodyLimit } from 'hono/body-limit'
 import { etag } from 'hono/etag'
 import * as z from 'zod/mini'
 
 import type * as App from '../../../App.js'
 import * as Db from '../../../db/Db.js'
-import * as FundingDepositAddresses from '../../../db/tables/fundingDepositAddresses.js'
-import * as FundingDeposits from '../../../db/tables/fundingDeposits.js'
-import * as FundingIdempotency from '../../../db/tables/fundingIdempotency.js'
+import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js'
+import * as RoutesDeposits from '../../../db/tables/routesDeposits.js'
+import * as RoutesIdempotency from '../../../db/tables/routesIdempotency.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
 import * as Cursor from '../../../internal/Cursor.js'
-import * as FundingCatalog from '../../../internal/funding/Catalog.js'
-import * as FundingDeposit from '../../../internal/funding/Deposit.js'
-import * as FundingDepositAddress from '../../../internal/funding/DepositAddress.js'
-import * as FundingProvider from '../../../internal/funding/Provider.js'
-import * as FundingTransfer from '../../../internal/funding/Transfer.js'
+import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
+import * as RoutesDeposit from '../../../internal/routes/Deposit.js'
+import * as RoutesDepositAddress from '../../../internal/routes/DepositAddress.js'
+import * as RoutesObservability from '../../../internal/routes/Observability.js'
+import * as RoutesProvider from '../../../internal/routes/Provider.js'
+import * as RoutesSubsidy from '../../../internal/routes/Subsidy.js'
+import * as RoutesTransfer from '../../../internal/routes/Transfer.js'
 import * as Idempotency from '../../../internal/Idempotency.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Value from '../../../internal/Value.js'
 import * as Access from '../Access.js'
-import * as ProviderAttempts from '../ProviderAttempts.js'
 
-/** Zod schemas owned by funding deposit-address resources. */
+/** Matches manual reconciliation's quota for another provider-backed address operation. */
+const creationRateLimit = { limit: 10, period: 'minute' } as const
+
+/** Zod schemas owned by route deposit-address resources. */
 export namespace schema {
-  /** One reusable funding deposit address. */
-  export const DepositAddress = FundingDepositAddress.schema.FundingDepositAddress
+  /** One reusable route deposit address. */
+  export const DepositAddress = RoutesDepositAddress.schema.RoutesDepositAddress
 
-  /** One detected funding deposit. */
-  export const Deposit = FundingDeposit.schema.FundingDeposit
+  /** One detected route deposit. */
+  export const Deposit = RoutesDeposit.schema.RoutesDeposit
 
-  /** Schemas for the createFundingDepositAddress operation. */
-  export namespace createFundingDepositAddress {
-    /** Funding deposit address creation request body. */
+  /** Schemas for the createRoutesDepositAddress operation. */
+  export namespace createRoutesDepositAddress {
+    /** Route deposit address creation request body. */
     export const Body = OpenApi.component(
       z
         .strictObject({
-          amount: FundingTransfer.schema.CreateRequest.shape.amount,
+          amount: RoutesTransfer.schema.CreateRequest.shape.amount,
           destinationToken: z
             .string()
             .check(
@@ -80,11 +85,11 @@ export namespace schema {
               z.meta({ examples: [false] }),
             ),
         })
-        .check(z.describe('Reusable funding deposit address creation request.')),
-      'CreateFundingDepositAddressRequest',
+        .check(z.describe('Reusable route deposit address creation request.')),
+      'CreateRoutesDepositAddressRequest',
     )
 
-    /** Required headers for funding deposit address creation. */
+    /** Required headers for route deposit address creation. */
     export const Headers = z.object({
       'idempotency-key': z
         .string()
@@ -93,7 +98,7 @@ export namespace schema {
           z.describe(
             'Opaque retry key scoped to the API key. Matching requests replay successful responses for 24 hours; changed input conflicts, in-flight requests block, and failed attempts release the key.',
           ),
-          z.meta({ examples: ['funding_01k1c5j8q8p0be6j5v9m6d1e4r'] }),
+          z.meta({ examples: ['routes_01k1c5j8q8p0be6j5v9m6d1e4r'] }),
         ),
     })
 
@@ -101,70 +106,70 @@ export namespace schema {
     export const Response = OpenApi.component(
       z
         .union([
-          FundingDepositAddress.schema.CreatedFundingDepositAddress,
-          FundingDepositAddress.schema.FundingDepositAddress,
+          RoutesDepositAddress.schema.CreatedRoutesDepositAddress,
+          RoutesDepositAddress.schema.RoutesDepositAddress,
         ])
         .check(
           z.describe(
-            'A reusable funding deposit address, including terms sampled for a newly stored provider address.',
+            'A reusable route deposit address, including terms sampled for a newly stored provider address.',
           ),
         ),
-      'CreateFundingDepositAddressResponse',
+      'CreateRoutesDepositAddressResponse',
     )
   }
 
-  /** Schemas for the getFundingDepositAddress operation. */
-  export namespace getFundingDepositAddress {
-    /** Path parameters for reading a funding deposit address. */
+  /** Schemas for the getRoutesDepositAddress operation. */
+  export namespace getRoutesDepositAddress {
+    /** Path parameters for reading a route deposit address. */
     export const Params = z
       .object({
         id: z
           .string()
           .check(
-            z.regex(/^fda_[A-Za-z0-9_-]+$/),
-            z.describe('Funding deposit address ID (`fda_…`).'),
-            z.meta({ examples: ['fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
+            z.regex(/^rda_[A-Za-z0-9_-]+$/),
+            z.describe('Route deposit address ID (`rda_…`).'),
+            z.meta({ examples: ['rda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
           ),
       })
-      .check(z.describe('Path parameters for reading a funding deposit address.'))
+      .check(z.describe('Path parameters for reading a route deposit address.'))
 
-    /** One reusable funding deposit address. */
+    /** One reusable route deposit address. */
     export const Response = DepositAddress
   }
 
-  /** Schemas for the listFundingDepositAddresses operation. */
-  export namespace listFundingDepositAddresses {
-    /** Query parameters for listing funding deposit addresses. */
+  /** Schemas for the listRoutesDepositAddresses operation. */
+  export namespace listRoutesDepositAddresses {
+    /** Query parameters for listing route deposit addresses. */
     export const Query = z
       .object({
         cursor: Schema.Cursor,
         limit: Schema.Limit,
       })
-      .check(z.describe('Paging parameters for listing funding deposit addresses.'))
+      .check(z.describe('Paging parameters for listing route deposit addresses.'))
 
-    /** One page of reusable funding deposit addresses. */
+    /** One page of reusable route deposit addresses. */
     export const Response = OpenApi.component(
       z
         .object({
           data: z
             .array(DepositAddress)
-            .check(z.describe('Funding deposit addresses on this page, newest first.')),
+            .check(z.describe('Route deposit addresses on this page, newest first.')),
           nextCursor: Schema.NextCursor,
         })
-        .check(z.describe('A page of reusable funding deposit addresses.')),
-      'FundingDepositAddressList',
+        .check(z.describe('A page of reusable route deposit addresses.')),
+      'RoutesDepositAddressList',
     )
   }
 
-  /** Schemas for the reconcileFundingDepositAddress operation. */
-  export namespace reconcileFundingDepositAddress {
-    /** Path parameters for reconciling a funding deposit address. */
-    export const Params = getFundingDepositAddress.Params
+  /** Schemas for the reconcileRoutesDepositAddress operation. */
+  export namespace reconcileRoutesDepositAddress {
+    /** Path parameters for reconciling a route deposit address. */
+    export const Params = getRoutesDepositAddress.Params
   }
 
-  /** Schemas for the listFundingDeposits operation. */
-  export namespace listFundingDeposits {
-    /** Query parameters for listing funding deposits. */
+  /** Schemas for the listRoutesDeposits operation. */
+  export namespace listRoutesDeposits {
+    /** Query parameters for listing route deposits. */
     export const Query = z
       .object({
         depositAddress: z
@@ -184,7 +189,7 @@ export namespace schema {
         limit: Schema.Limit,
         provider: z
           .optional(z.string().check(z.minLength(1)))
-          .check(z.describe('Funding provider id.'), z.meta({ examples: ['relay'] })),
+          .check(z.describe('Route provider id.'), z.meta({ examples: ['relay'] })),
         recipient: z
           .optional(Schema.Address)
           .check(
@@ -203,7 +208,7 @@ export namespace schema {
             z.describe('Source token symbol, contract address, or token key.'),
             z.meta({ examples: ['usdt'] }),
           ),
-        status: z.optional(FundingDeposit.schema.Status),
+        status: z.optional(RoutesDeposit.schema.Status),
       })
       .check(z.describe('Optional deposit filters and paging parameters.'))
 
@@ -217,27 +222,27 @@ export namespace schema {
             .check(z.describe('Extra response metadata requested with `include`.')),
           nextCursor: Schema.NextCursor,
         })
-        .check(z.describe('A page of visible funding deposits.')),
-      'FundingDepositList',
+        .check(z.describe('A page of visible route deposits.')),
+      'RoutesDepositList',
     )
   }
 
-  /** Schemas for the getFundingDeposit operation. */
-  export namespace getFundingDeposit {
-    /** Path parameters for reading a funding deposit. */
+  /** Schemas for the getRoutesDeposit operation. */
+  export namespace getRoutesDeposit {
+    /** Path parameters for reading a route deposit. */
     export const Params = z
       .object({
         id: z
           .string()
           .check(
-            z.regex(/^fdp_[A-Za-z0-9_-]+$/),
-            z.describe('Funding deposit id (`fdp_…`).'),
-            z.meta({ examples: ['fdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
+            z.regex(/^rdp_[A-Za-z0-9_-]+$/),
+            z.describe('Route deposit id (`rdp_…`).'),
+            z.meta({ examples: ['rdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
           ),
       })
-      .check(z.describe('Path parameters for reading a funding deposit.'))
+      .check(z.describe('Path parameters for reading a route deposit.'))
 
-    /** One detected funding deposit. */
+    /** One detected route deposit. */
     export const Response = Deposit
   }
 }
@@ -278,12 +283,12 @@ const tempoUsdt0Example = {
   verified: true,
 } as const
 
-const fundingDepositAddressExample = {
+const routesDepositAddressExample = {
   address: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
   createdAt: '2026-08-04T00:00:00.000Z',
   destinationChain: tempoChainExample,
   destinationToken: tempoUsdt0Example,
-  id: 'fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
+  id: 'rda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
   provider: { id: 'relay', name: 'Relay' },
   recipient: `0x${'11'.repeat(20)}`,
   refundAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
@@ -294,8 +299,8 @@ const fundingDepositAddressExample = {
   updatedAt: '2026-08-04T00:00:00.000Z',
 } satisfies z.output<typeof schema.DepositAddress>
 
-const createdFundingDepositAddressExample = {
-  ...fundingDepositAddressExample,
+const createdRoutesDepositAddressExample = {
+  ...routesDepositAddressExample,
   destinationAmount: Value.tokenAmount({ baseUnits: '1000000', currency: 'USD', decimals: 6 }),
   destinationAmountMin: Value.tokenAmount({
     baseUnits: '1000000',
@@ -305,18 +310,18 @@ const createdFundingDepositAddressExample = {
   fees: [],
   quote: { sampledAt: '2026-08-04T00:00:00.000Z' },
   sourceAmount: Value.tokenAmount({ baseUnits: '1000000', currency: 'USD', decimals: 6 }),
-} satisfies z.output<typeof schema.createFundingDepositAddress.Response>
+} satisfies z.output<typeof schema.createRoutesDepositAddress.Response>
 
-const fundingDepositExample = {
+const routesDepositExample = {
   createdAt: '2026-08-04T00:01:00.000Z',
-  depositAddressId: fundingDepositAddressExample.id,
+  depositAddressId: routesDepositAddressExample.id,
   detectionTrigger: 'webhook',
   destinationChain: tempoChainExample,
   destinationToken: tempoUsdt0Example,
-  id: 'fdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx',
+  id: 'rdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx',
   provider: { id: 'relay', name: 'Relay' },
-  recipient: fundingDepositAddressExample.recipient,
-  refundAddress: fundingDepositAddressExample.refundAddress,
+  recipient: routesDepositAddressExample.recipient,
+  refundAddress: routesDepositAddressExample.refundAddress,
   sourceChain: tronChainExample,
   sourceToken: tronUsdtExample,
   sourceTransactionHashes: ['9f2c4c80dbb468878baa8c07ff523e0464bf6437f2a486268508485d83f14d12'],
@@ -324,18 +329,18 @@ const fundingDepositExample = {
   updatedAt: '2026-08-04T00:01:00.000Z',
 } satisfies z.output<typeof schema.Deposit>
 
-const fundingDepositsExample = {
-  data: [fundingDepositExample],
+const routesDepositsExample = {
+  data: [routesDepositExample],
   meta: { totalCount: 1, totalCountCapped: false },
   nextCursor: null,
-} satisfies z.output<typeof schema.listFundingDeposits.Response>
+} satisfies z.output<typeof schema.listRoutesDeposits.Response>
 
-const fundingDepositAddressesExample = {
-  data: [fundingDepositAddressExample],
+const routesDepositAddressesExample = {
+  data: [routesDepositAddressExample],
   nextCursor: null,
-} satisfies z.output<typeof schema.listFundingDepositAddresses.Response>
+} satisfies z.output<typeof schema.listRoutesDepositAddresses.Response>
 
-function resolveDepositFilters(options: resolveDepositFilters.Options): FundingDeposits.Filters {
+function resolveDepositFilters(options: resolveDepositFilters.Options): RoutesDeposits.Filters {
   const { catalog, parameters } = options
   return {
     ...(parameters.depositAddress === undefined
@@ -372,12 +377,12 @@ function resolveDepositFilters(options: resolveDepositFilters.Options): FundingD
 
 declare namespace resolveDepositFilters {
   type Options = {
-    catalog?: FundingCatalog.Snapshot | undefined
-    parameters: z.output<typeof schema.listFundingDeposits.Query>
+    catalog?: RoutesCatalog.Snapshot | undefined
+    parameters: z.output<typeof schema.listRoutesDeposits.Query>
   }
 }
 
-function resolveChainIds(catalog: FundingCatalog.Snapshot | undefined, input: string): string[] {
+function resolveChainIds(catalog: RoutesCatalog.Snapshot | undefined, input: string): string[] {
   const trimmed = input.trim()
   const chain = catalog?.chainsByKey.get(trimmed.toLowerCase())
   if (chain) return [chain.id]
@@ -399,13 +404,13 @@ function resolveTokenKeys(options: resolveTokenKeys.Options): string[] {
 
 declare namespace resolveTokenKeys {
   type Options = {
-    catalog?: FundingCatalog.Snapshot | undefined
+    catalog?: RoutesCatalog.Snapshot | undefined
     input: string
     side: 'destination' | 'source'
   }
 }
 
-type ResolvedToken = FundingCatalog.Snapshot['routes'][number]['route']['source']
+type ResolvedToken = RoutesCatalog.Snapshot['routes'][number]['route']['source']
 
 function matchesToken(token: ResolvedToken, trimmed: string, normalized: string): boolean {
   return (
@@ -434,25 +439,25 @@ function tokenKey(token: ResolvedToken): string {
   return `${token.chain.id}/${namespace}:${token.address}`
 }
 
-const reconcileFundingDepositAddressResponses = (() => {
+const reconcileRoutesDepositAddressResponses = (() => {
   const responses = OpenApi.responses({
     errors: {
       400: { codes: ['param_invalid'] },
       403: {
         codes: ['api_key_forbidden'],
-        description: 'The API key does not grant funding write access.',
+        description: 'The API key does not grant routes write access.',
       },
       404: {
-        codes: ['funding_deposit_address_not_found'],
-        description: 'No visible funding deposit address exists for the identifier.',
+        codes: ['routes_deposit_address_not_found'],
+        description: 'No visible route deposit address exists for the identifier.',
       },
       409: {
-        codes: ['funding_deposit_address_not_active'],
-        description: 'The funding deposit address is not active.',
+        codes: ['routes_deposit_address_not_active'],
+        description: 'The route deposit address is not active.',
       },
       501: {
         codes: ['not_implemented'],
-        description: 'Manual funding reconciliation is not configured.',
+        description: 'Manual routes reconciliation is not configured.',
       },
       502: {
         codes: ['upstream_error'],
@@ -468,7 +473,7 @@ const reconcileFundingDepositAddressResponses = (() => {
   void success
   return {
     202: {
-      description: 'The funding deposit address was queued for reconciliation.',
+      description: 'The route deposit address was queued for reconciliation.',
       headers: { ...OpenApi.successHeaders },
     },
     ...errors,
@@ -482,63 +487,103 @@ const idempotencyPendingTtlMs = 60_000
 
 const depositAddressCheckpoint = Schema.describe(
   z.object({
+    amount: z.optional(RoutesTransfer.schema.CreateRequest.shape.amount),
     candidate: Schema.describe(
       z.object({
-        destinationChain: FundingProvider.schema.ChainRef,
-        destinationToken: FundingProvider.schema.TokenRef,
-        sourceChain: FundingProvider.schema.ChainRef,
-        sourceToken: FundingProvider.schema.TokenRef,
+        destinationChain: RoutesProvider.schema.ChainRef,
+        destinationToken: RoutesProvider.schema.TokenRef,
+        sourceChain: RoutesProvider.schema.ChainRef,
+        sourceToken: RoutesProvider.schema.TokenRef,
       }),
       'Normalized route retained after provider provisioning.',
     ),
-    provider: FundingProvider.schema.ProviderRef,
+    provider: RoutesProvider.schema.ProviderRef,
     recipient: z.string().check(z.describe('Normalized Tempo recipient.')),
     refundAddress: z.string().check(z.describe('Normalized source-chain refund account.')),
-    result: FundingProvider.schema.DepositAddressResult,
+    result: RoutesProvider.schema.DepositAddressResult,
   }),
   'Provider result retained until deposit address creation completes.',
 )
 
-const fundingEtag = etag()
+const routesEtag = etag()
+// Provider callbacks are small JSON documents; bound buffering before signature verification.
+const maxProviderWebhookBodyBytes = 64 * 1_024
 
 /** Mounts reusable deposit-address and detected-deposit routes. */
 export function depositAddresses(options: depositAddresses.Options = {}) {
   return new Hono<App.Environment>()
-    .post('/webhooks/funding/:providerId', async (c) => {
-      const provider = c
-        .get('providers')
-        .filter(FundingProvider.is)
-        .find((candidate) => candidate.id === c.req.param('providerId'))
-      if (!provider || !FundingProvider.canReceiveWebhook(provider)) return c.body(null, 404)
-      try {
-        await provider.webhook.receive({
-          body: await c.req.text(),
-          headers: c.req.raw.headers,
-        })
-        return c.body(null, 204)
-      } catch (cause) {
-        if (cause instanceof FundingProvider.WebhookAuthenticationError) return c.body(null, 401)
-        if (cause instanceof FundingProvider.WebhookPayloadError) return c.body(null, 400)
-        throw cause
-      }
-    })
     .post(
-      '/v1/funding/deposit-addresses',
-      Auth.policy({ apiKey: { scopes: ['funding:write'] } }),
-      OpenApi.validate('header', schema.createFundingDepositAddress.Headers, {
+      '/webhooks/routes/:providerId',
+      async (c, next) => {
+        const provider = c
+          .get('providers')
+          .filter(RoutesProvider.is)
+          .find((candidate) => candidate.id === c.req.param('providerId'))
+        if (!provider || !RoutesProvider.canReceiveWebhook(provider)) return c.body(null, 404)
+        return next()
+      },
+      bodyLimit({
+        maxSize: maxProviderWebhookBodyBytes,
+        onError: (c) => c.body(null, 413),
+      }),
+      async (c) => {
+        const provider = c
+          .get('providers')
+          .filter(RoutesProvider.is)
+          .find((candidate) => candidate.id === c.req.param('providerId'))
+        if (!provider || !RoutesProvider.canReceiveWebhook(provider)) return c.body(null, 404)
+        const body = await c.req.text()
+        try {
+          await RoutesProvider.observe(
+            provider,
+            () =>
+              provider.webhook.receive({
+                body,
+                headers: c.req.raw.headers,
+              }),
+            {
+              onAttempt: (result) => c.set('routesProviderAttempts', [result]),
+              operation: 'receiveWebhook',
+            },
+          )
+          return c.body(null, 204)
+        } catch (cause) {
+          if (cause instanceof RoutesProvider.WebhookAuthenticationError) return c.body(null, 401)
+          if (cause instanceof RoutesProvider.WebhookPayloadError) return c.body(null, 400)
+          throw cause
+        }
+      },
+    )
+    .post(
+      '/v1/routes/deposit-addresses',
+      Auth.policy({
+        apiKey: { rateLimit: creationRateLimit, scopes: ['routes:write'] },
+      }),
+      OpenApi.validate('header', schema.createRoutesDepositAddress.Headers, {
         code: 'idempotency_key_required',
-        message: 'Funding deposit address creation requires an `Idempotency-Key` header.',
+        message: 'Route deposit address creation requires an `Idempotency-Key` header.',
       }),
-      OpenApi.validate('json', schema.createFundingDepositAddress.Body, {
+      OpenApi.validate('json', schema.createRoutesDepositAddress.Body, {
         code: 'body_invalid',
         message: 'Check the request body and try again.',
       }),
       OpenApi.describeRoute({
-        description: 'Creates or returns a reusable deposit address for funding a Tempo account.',
-        operationId: 'createFundingDepositAddress',
+        description: 'Creates or returns a reusable deposit address for routes a Tempo account.',
+        operationId: 'createRoutesDepositAddress',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['body_invalid', 'idempotency_key_required'] },
+            403: {
+              codes: [
+                'billing_past_due',
+                'billing_required',
+                'routes_deposit_address_limit_exceeded',
+                'routes_subsidy_not_enabled',
+              ],
+              description:
+                'The organization cannot create another address or is not eligible for a Tempo-funded Routes subsidy.',
+              name: 'CreateRoutesDepositAddressForbiddenError',
+            },
             404: {
               codes: ['deposit_address_not_available'],
               description: 'No provider can provision the requested reusable address route.',
@@ -553,9 +598,9 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             },
           },
           success: {
-            description: 'The created or matching reusable funding deposit address and quote.',
-            example: createdFundingDepositAddressExample,
-            schema: schema.createFundingDepositAddress.Response,
+            description: 'The created or matching reusable route deposit address and quote.',
+            example: createdRoutesDepositAddressExample,
+            schema: schema.createRoutesDepositAddress.Response,
           },
         }),
         summary: 'Create deposit address',
@@ -579,16 +624,49 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         const db = Db.get(c.get('db'))
         const identity = {
           apiKeyId: principal.id,
+          compatibleRequestHashes: [
+            Idempotency.inputHash({
+              body,
+              endpoint: 'POST /v1/routes/deposit-addresses',
+            }),
+          ],
           keyHash: Idempotency.inputHash(c.req.valid('header')['idempotency-key']),
           requestHash: Idempotency.inputHash({
             body,
-            endpoint: 'POST /v1/funding/deposit-addresses',
+            endpoint: 'POST /v1/routes/deposit-addresses',
+            owner,
           }),
         }
-        const claim = await FundingIdempotency.claim(db, {
-          ...identity,
-          ttlMs: idempotencyPendingTtlMs,
-        })
+        const claimed = await (async () => {
+          try {
+            return {
+              claim: await RoutesDepositAddresses.claimCreation(db, {
+                claim: {
+                  ...identity,
+                  irrevocable: false,
+                  recoveredIrrevocable: subsidize,
+                  ttlMs: idempotencyPendingTtlMs,
+                },
+                orgId: owner.orgId,
+              }),
+              type: 'success',
+            } as const
+          } catch (cause) {
+            if (
+              cause instanceof RoutesDepositAddresses.OwnerNotFoundError ||
+              RoutesIdempotency.isOwnerFenceError(cause)
+            )
+              return { type: 'ownerNotFound' } as const
+            throw cause
+          }
+        })()
+        if (claimed.type === 'ownerNotFound')
+          return Response.error(c, {
+            code: 'api_key_forbidden',
+            message: 'API key organization no longer exists.',
+            status: 403,
+          })
+        const claim = claimed.claim
         if (claim.type === 'mismatch')
           return Response.error(c, {
             code: 'idempotency_conflict',
@@ -598,13 +676,13 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         if (claim.type === 'pending')
           return Response.error(c, {
             code: 'idempotency_in_progress',
-            message: 'An equivalent funding deposit address creation is still running.',
+            message: 'An equivalent route deposit address creation is still running.',
             status: 409,
           })
         if (claim.type === 'replay') {
           const response = JSON.parse(claim.response) as Record<string, unknown>
           return c.json(
-            Response.validated(schema.createFundingDepositAddress.Response, {
+            Response.validated(schema.createRoutesDepositAddress.Response, {
               ...response,
               subsidize: response['subsidize'] ?? false,
             }),
@@ -614,7 +692,7 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
 
         const release = async () => {
           try {
-            await FundingIdempotency.release(db, {
+            await RoutesIdempotency.release(db, {
               apiKeyId: identity.apiKeyId,
               createdAt: claim.createdAt,
               keyHash: identity.keyHash,
@@ -625,13 +703,10 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         }
         const complete = async (
           database: Db.Db,
-          response: z.output<typeof schema.createFundingDepositAddress.Response>,
+          response: z.output<typeof schema.createRoutesDepositAddress.Response>,
         ) => {
-          const validated = Response.validated(
-            schema.createFundingDepositAddress.Response,
-            response,
-          )
-          const completion = await FundingIdempotency.complete(database, {
+          const validated = Response.validated(schema.createRoutesDepositAddress.Response, response)
+          const completion = await RoutesIdempotency.complete(database, {
             apiKeyId: identity.apiKeyId,
             createdAt: claim.createdAt,
             keyHash: identity.keyHash,
@@ -639,19 +714,110 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             response: JSON.stringify(validated),
           })
           if (!completion)
-            throw new IdempotencyLeaseLostError('Funding deposit address creation lease was lost.')
+            throw new IdempotencyLeaseLostError('Route deposit address creation lease was lost.')
           return validated
         }
 
-        const attempts: FundingProvider.ProviderAttempt[] = []
+        const attempts: RoutesProvider.ProviderAttempt[] = []
         const provisioning = { succeeded: claim.type === 'resume' }
         try {
+          if (claim.type === 'claimed' && subsidize) {
+            const policy = await RoutesSubsidy.check(db, {
+              environment: owner.environment,
+              orgId: owner.orgId,
+            })
+            if (policy.type === 'denied') {
+              RoutesObservability.recordSubsidyRejection(c.get('metrics'), {
+                reason: policy.reason,
+                routesEnvironment: owner.environment,
+              })
+              await release()
+              return Response.error(c, {
+                code: policy.reason,
+                message: RoutesSubsidy.denialMessages[policy.reason],
+                status: 403,
+              })
+            }
+          }
           const selected = await (async () => {
             if (claim.type === 'resume')
-              return depositAddressCheckpoint.parse(JSON.parse(claim.response))
-            const catalog = await FundingCatalog.snapshot(c)
-            const providers = c.get('providers').filter(FundingProvider.is)
-            const provisioned = await FundingProvider.createDepositAddress({
+              return {
+                checkpoint: depositAddressCheckpoint.parse(JSON.parse(claim.response)),
+                checkpointFresh: claim.checkpointFresh,
+                ...(claim.recoveredClaim === undefined
+                  ? {}
+                  : { recoveredClaim: claim.recoveredClaim }),
+                quoteMatchesRequest: claim.checkpointFresh,
+                type: 'resume',
+              } as const
+            const catalog = await RoutesCatalog.snapshot(c)
+            const providers = c.get('providers').filter(RoutesProvider.is)
+            const selection = RoutesProvider.selectDepositAddress({
+              catalog,
+              destinationChainId: c.get('chainId'),
+              destinationToken: body.destinationToken,
+              providers,
+              recipient: body.recipient,
+              refundAddress: body.refundAddress,
+              sourceChain: body.sourceChain,
+              sourceToken: body.sourceToken,
+            })
+            if (!selection) return undefined
+            const match = {
+              destinationTokenKey: selection.candidate.destinationToken.tokenKey,
+              environment: owner.environment,
+              orgId: owner.orgId,
+              ...(owner.projectId === undefined ? {} : { projectId: owner.projectId }),
+              recipient: selection.recipient,
+              refundAddress: selection.refundAddress,
+              sourceChainId: selection.candidate.sourceChain.id,
+              sourceTokenKey: selection.candidate.sourceToken.tokenKey,
+              subsidize,
+            }
+            const capacity = await RoutesDepositAddresses.validateCreationCapacity(db, {
+              claim: {
+                apiKeyId: identity.apiKeyId,
+                createdAt: claim.createdAt,
+                keyHash: identity.keyHash,
+              },
+              match,
+              matchHash: Idempotency.inputHash(match),
+              maxPerCreator: RoutesDepositAddress.maximumPerCreator,
+              orgId: owner.orgId,
+              pendingTtlMs: idempotencyPendingTtlMs,
+              replayTtlMs: idempotencyReplayTtlMs,
+              serializeMatchingResponse: (record) =>
+                JSON.stringify(
+                  Response.validated(
+                    schema.createRoutesDepositAddress.Response,
+                    RoutesDepositAddress.toPublic(record),
+                  ),
+                ),
+            })
+            if (capacity.type === 'existing')
+              return { record: capacity.record, type: 'existing' } as const
+            if (capacity.type === 'resume')
+              return {
+                checkpoint: depositAddressCheckpoint.parse(JSON.parse(capacity.response)),
+                checkpointFresh: capacity.checkpointFresh,
+                quoteMatchesRequest: false,
+                recoveredClaim: capacity.claim,
+                type: 'resume',
+              } as const
+            if (subsidize) {
+              const marked = await RoutesIdempotency.markProviderAttempt(db, {
+                apiKeyId: identity.apiKeyId,
+                createdAt: claim.createdAt,
+                keyHash: identity.keyHash,
+                ttlMs: idempotencyPendingTtlMs,
+              })
+              if (!marked)
+                throw new IdempotencyLeaseLostError(
+                  'Route deposit address creation lease was lost.',
+                )
+              provisioning.succeeded = true
+            }
+            const provisioned = await RoutesProvider.createDepositAddress({
               amount: body.amount,
               catalog,
               destinationChainId: c.get('chainId'),
@@ -667,30 +833,103 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             if (!provisioned) return undefined
             provisioning.succeeded = true
             const checkpoint = depositAddressCheckpoint.parse({
+              amount: body.amount,
               candidate: provisioned.candidate,
               provider: provisioned.provider,
               recipient: provisioned.recipient,
               refundAddress: provisioned.refundAddress,
               result: provisioned.result,
             })
-            const stored = await FundingIdempotency.checkpoint(db, {
+            return {
+              checkpoint,
+              checkpointFresh: true,
+              quoteMatchesRequest: true,
+              type: 'provisioned',
+            } as const
+          })()
+          if (attempts.length > 0)
+            c.set('routesProviderAttempts', attempts.map(RoutesProvider.formatAttempt))
+          if (!selected) {
+            await release()
+            return depositAddressNotAvailable(c)
+          }
+          if (selected.type === 'existing') {
+            const response = Response.validated(
+              schema.createRoutesDepositAddress.Response,
+              RoutesDepositAddress.toPublic(selected.record),
+            )
+            if (options.registerDepositAddress)
+              await options.registerDepositAddress(
+                RoutesDepositAddress.schema.RoutesDepositAddress.parse(response),
+              )
+            return c.json(response, 200)
+          }
+          const resumed = await (async () => {
+            if (selected.type !== 'resume')
+              return { recoveredClaim: undefined, type: 'ready' } as const
+            const match = {
+              destinationTokenKey: selected.checkpoint.candidate.destinationToken.tokenKey,
+              environment: owner.environment,
+              orgId: owner.orgId,
+              ...(owner.projectId === undefined ? {} : { projectId: owner.projectId }),
+              recipient: selected.checkpoint.recipient,
+              refundAddress: selected.checkpoint.refundAddress,
+              sourceChainId: selected.checkpoint.candidate.sourceChain.id,
+              sourceTokenKey: selected.checkpoint.candidate.sourceToken.tokenKey,
+              subsidize,
+            }
+            const capacity = await RoutesDepositAddresses.validateCreationCapacity(db, {
+              claim: {
+                apiKeyId: identity.apiKeyId,
+                createdAt: claim.createdAt,
+                keyHash: identity.keyHash,
+              },
+              match,
+              matchHash: Idempotency.inputHash(match),
+              maxPerCreator: RoutesDepositAddress.maximumPerCreator,
+              orgId: owner.orgId,
+              pendingTtlMs: idempotencyPendingTtlMs,
+              ...(selected.recoveredClaim === undefined
+                ? {}
+                : { recoveredClaim: selected.recoveredClaim }),
+              replayTtlMs: idempotencyReplayTtlMs,
+              serializeMatchingResponse: (record) =>
+                JSON.stringify(
+                  Response.validated(
+                    schema.createRoutesDepositAddress.Response,
+                    RoutesDepositAddress.toPublic(record),
+                  ),
+                ),
+            })
+            if (capacity.type === 'existing')
+              return { record: capacity.record, type: 'existing' } as const
+            return {
+              recoveredClaim: capacity.type === 'resume' ? capacity.claim : selected.recoveredClaim,
+              type: 'ready',
+            } as const
+          })()
+          if (resumed.type === 'existing') {
+            const response = Response.validated(
+              schema.createRoutesDepositAddress.Response,
+              RoutesDepositAddress.toPublic(resumed.record),
+            )
+            if (options.registerDepositAddress)
+              await options.registerDepositAddress(
+                RoutesDepositAddress.schema.RoutesDepositAddress.parse(response),
+              )
+            return c.json(response, 200)
+          }
+
+          if (selected.type === 'provisioned') {
+            const stored = await RoutesIdempotency.checkpoint(db, {
               apiKeyId: identity.apiKeyId,
               createdAt: claim.createdAt,
               keyHash: identity.keyHash,
               replayTtlMs: idempotencyReplayTtlMs,
-              response: JSON.stringify(checkpoint),
+              response: JSON.stringify(selected.checkpoint),
             })
             if (!stored)
-              throw new IdempotencyLeaseLostError(
-                'Funding deposit address creation lease was lost.',
-              )
-            return checkpoint
-          })()
-          if (attempts.length > 0)
-            c.set('fundingProviderAttempts', attempts.map(ProviderAttempts.format))
-          if (!selected) {
-            await release()
-            return depositAddressNotAvailable(c)
+              throw new IdempotencyLeaseLostError('Route deposit address creation lease was lost.')
           }
 
           const {
@@ -699,10 +938,13 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             recipient,
             refundAddress,
             result,
-          } = selected
+          } = selected.checkpoint
           const created = await db.transaction(async (tx) => {
-            const stored = await FundingDepositAddress.createOrGet(tx, {
-              apiKeyId: principal.id,
+            const persist =
+              selected.type === 'resume'
+                ? RoutesDepositAddress.recoverOrGet
+                : RoutesDepositAddress.createOrGet
+            const stored = await persist(tx, {
               deliveryStrategy: 'provider',
               environment: owner.environment,
               orgId: owner.orgId,
@@ -725,9 +967,8 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
                 subsidize,
               },
             })
-            const record = FundingDepositAddress.toPublic(stored.record)
-            if (stored.type === 'existing') return complete(tx, record)
-            return complete(tx, {
+            const record = RoutesDepositAddress.toPublic(stored.record)
+            const quoted = {
               ...record,
               destinationAmount: Value.tokenAmount({
                 baseUnits: result.destinationAmount,
@@ -761,44 +1002,115 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
                 sampledAt: result.sampledAt,
               },
               sourceAmount: Value.tokenAmount({
-                baseUnits: body.amount,
+                baseUnits: selected.checkpoint.amount ?? body.amount,
                 currency: selectedCandidate.sourceToken.currency,
                 decimals: selectedCandidate.sourceToken.decimals,
               }),
-            })
+            }
+            const response = await complete(
+              tx,
+              stored.type === 'existing' || !selected.quoteMatchesRequest ? record : quoted,
+            )
+            if (resumed.recoveredClaim)
+              await RoutesIdempotency.complete(tx, {
+                ...resumed.recoveredClaim,
+                replayTtlMs: idempotencyReplayTtlMs,
+                response: JSON.stringify(
+                  stored.type === 'existing' ||
+                    !selected.checkpointFresh ||
+                    (selected.checkpoint.amount === undefined && !selected.quoteMatchesRequest)
+                    ? record
+                    : quoted,
+                ),
+              })
+            return { record: stored.record, response, type: stored.type }
           })
+          if (created.type === 'created') {
+            if ('sourceAmount' in created.response)
+              RoutesObservability.recordRouteQuote(c.get('metrics'), {
+                destinationAmount: created.response.destinationAmount,
+                destinationChain: created.response.destinationChain,
+                destinationToken: created.response.destinationToken,
+                feePayer: subsidize ? 'tempo' : 'customer',
+                fees: created.response.fees,
+                routesEnvironment: owner.environment,
+                method: 'deposit_address',
+                provider: created.response.provider,
+                sourceAmount: created.response.sourceAmount,
+                sourceChain: created.response.sourceChain,
+                sourceToken: created.response.sourceToken,
+              })
+            RoutesObservability.recordDepositAddress(c.get('metrics'), {
+              record: created.record,
+            })
+          }
           if (options.registerDepositAddress)
             await options.registerDepositAddress(
-              FundingDepositAddress.schema.FundingDepositAddress.parse(created),
+              RoutesDepositAddress.schema.RoutesDepositAddress.parse(created.response),
             )
-          return c.json(created, 200)
+          return c.json(created.response, 200)
         } catch (cause) {
           if (!provisioning.succeeded) await release()
-          if (cause instanceof FundingProvider.InvalidRefundAddressError)
+          if (cause instanceof RoutesProvider.InvalidRefundAddressError)
             return Response.error(c, {
               code: 'body_invalid',
               message: 'Invalid `refundAddress`.',
               status: 400,
             })
-          if (cause instanceof FundingProvider.UnsupportedSourceChainError)
+          if (cause instanceof RoutesProvider.UnsupportedSourceChainError)
             return depositAddressNotAvailable(c)
           if (
-            cause instanceof FundingDepositAddress.ConflictError ||
-            cause instanceof FundingProvider.ProviderQuoteError
+            cause instanceof RoutesDepositAddress.OwnerNotFoundError ||
+            RoutesIdempotency.isOwnerFenceError(cause)
+          )
+            return Response.error(c, {
+              code: 'api_key_forbidden',
+              message: 'API key organization no longer exists.',
+              status: 403,
+            })
+          if (cause instanceof RoutesDepositAddresses.OwnerNotFoundError)
+            return Response.error(c, {
+              code: 'api_key_forbidden',
+              message: 'API key organization no longer exists.',
+              status: 403,
+            })
+          if (
+            cause instanceof RoutesDepositAddresses.CapacityClaimNotFoundError ||
+            cause instanceof RoutesDepositAddresses.MatchInProgressError
+          )
+            return Response.error(c, {
+              code: 'idempotency_in_progress',
+              message: 'An equivalent route deposit address creation is still running.',
+              status: 409,
+            })
+          if (
+            cause instanceof RoutesDepositAddress.ConflictError ||
+            cause instanceof RoutesDepositAddress.LimitExceededError ||
+            cause instanceof RoutesDepositAddresses.LimitExceededError ||
+            cause instanceof RoutesProvider.ProviderQuoteError
           ) {
-            if (cause instanceof FundingDepositAddress.ConflictError)
+            if (
+              cause instanceof RoutesDepositAddress.LimitExceededError ||
+              cause instanceof RoutesDepositAddresses.LimitExceededError
+            ) {
+              RoutesObservability.recordDepositAddressLimitRejection(c.get('metrics'), {
+                routesEnvironment: owner.environment,
+              })
+              return depositAddressLimitExceeded(c)
+            }
+            if (cause instanceof RoutesDepositAddress.ConflictError)
               return Response.error(c, {
                 code: 'upstream_error',
-                message: 'The funding provider returned a conflicting deposit address.',
+                message: 'The route provider returned a conflicting deposit address.',
                 status: 502,
               })
-            if (cause.fundingProviderAttempts.length > 0)
-              c.set('fundingProviderAttempts', cause.fundingProviderAttempts)
+            if (cause.routesProviderAttempts.length > 0)
+              c.set('routesProviderAttempts', cause.routesProviderAttempts)
             if (cause.providerFailure) c.set('providerFailure', cause.providerFailure)
             if (cause.providerFailures) c.set('providerFailures', cause.providerFailures)
             return Response.error(c, {
               code: 'upstream_error',
-              message: 'The funding provider could not provision the deposit address.',
+              message: 'The route provider could not provision the deposit address.',
               status: 502,
             })
           }
@@ -807,23 +1119,23 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
       },
     )
     .get(
-      '/v1/funding/deposit-addresses',
-      Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
-      OpenApi.validate('query', schema.listFundingDepositAddresses.Query, {
+      '/v1/routes/deposit-addresses',
+      Auth.policy({ apiKey: { scopes: ['routes:read'] } }),
+      OpenApi.validate('query', schema.listRoutesDepositAddresses.Query, {
         code: 'query_invalid',
         message: 'Check the query parameters and try again.',
       }),
       OpenApi.describeRoute({
-        description: 'Lists reusable funding deposit addresses, newest first.',
-        operationId: 'listFundingDepositAddresses',
+        description: 'Lists reusable route deposit addresses, newest first.',
+        operationId: 'listRoutesDepositAddresses',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['query_invalid'] },
           },
           success: {
-            description: 'A page of reusable funding deposit addresses.',
-            example: fundingDepositAddressesExample,
-            schema: schema.listFundingDepositAddresses.Response,
+            description: 'A page of reusable route deposit addresses.',
+            example: routesDepositAddressesExample,
+            schema: schema.listRoutesDepositAddresses.Response,
           },
         }),
         summary: 'List deposit addresses',
@@ -844,7 +1156,7 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         const { cursor, limit } = c.req.valid('query')
         const decoded = cursor ? Cursor.decode(cursor, ['timestamp', 'id']) : undefined
         try {
-          const rows = await FundingDepositAddresses.list(db, {
+          const rows = await RoutesDepositAddresses.listByOwner(db, {
             ...(decoded
               ? { cursor: { createdAt: String(decoded[0]), id: String(decoded[1]) } }
               : {}),
@@ -856,12 +1168,12 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             limit,
             rows,
           })
-          const data = page.rows.map(FundingDepositAddress.toPublic)
+          const data = page.rows.map(RoutesDepositAddress.toPublic)
 
           c.header('Cache-Control', Cache.policies.noStore)
           c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key')
           return c.json(
-            Response.validated(schema.listFundingDepositAddresses.Response, {
+            Response.validated(schema.listRoutesDepositAddresses.Response, {
               data,
               nextCursor: page.nextCursor,
             }),
@@ -873,27 +1185,27 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
       },
     )
     .get(
-      '/v1/funding/deposit-addresses/:id{fda_[A-Za-z0-9_-]+}',
-      Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
-      OpenApi.validate('param', schema.getFundingDepositAddress.Params, {
+      '/v1/routes/deposit-addresses/:id{rda_[A-Za-z0-9_-]+}',
+      Auth.policy({ apiKey: { scopes: ['routes:read'] } }),
+      OpenApi.validate('param', schema.getRoutesDepositAddress.Params, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
       }),
       OpenApi.describeRoute({
-        description: 'Returns one reusable funding deposit address.',
-        operationId: 'getFundingDepositAddress',
+        description: 'Returns one reusable route deposit address.',
+        operationId: 'getRoutesDepositAddress',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['param_invalid'] },
             404: {
-              codes: ['funding_deposit_address_not_found'],
-              description: 'No visible funding deposit address exists for the identifier.',
+              codes: ['routes_deposit_address_not_found'],
+              description: 'No visible route deposit address exists for the identifier.',
             },
           },
           success: {
-            description: 'The requested funding deposit address.',
-            example: fundingDepositAddressExample,
-            schema: schema.getFundingDepositAddress.Response,
+            description: 'The requested route deposit address.',
+            example: routesDepositAddressExample,
+            schema: schema.getRoutesDepositAddress.Response,
           },
         }),
         summary: 'Get deposit address',
@@ -913,11 +1225,11 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         const db = Db.get(c.get('db'))
         const { id } = c.req.valid('param')
         try {
-          const record = await FundingDepositAddresses.getOwned(db, owner, id)
+          const record = await RoutesDepositAddresses.getOwned(db, owner, id)
           if (!record)
             return Response.error(c, {
-              code: 'funding_deposit_address_not_found',
-              message: 'Funding deposit address not found',
+              code: 'routes_deposit_address_not_found',
+              message: 'Route deposit address not found',
               status: 404,
             })
 
@@ -925,8 +1237,8 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
           c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key')
           return c.json(
             Response.validated(
-              schema.getFundingDepositAddress.Response,
-              FundingDepositAddress.toPublic(record),
+              schema.getRoutesDepositAddress.Response,
+              RoutesDepositAddress.toPublic(record),
             ),
             200,
           )
@@ -936,19 +1248,19 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
       },
     )
     .post(
-      '/v1/funding/deposit-addresses/:id{fda_[A-Za-z0-9_-]+}/reconcile',
+      '/v1/routes/deposit-addresses/:id{rda_[A-Za-z0-9_-]+}/reconcile',
       Auth.policy({
-        apiKey: { rateLimit: { limit: 10, period: 'minute' }, scopes: ['funding:write'] },
+        apiKey: { rateLimit: { limit: 10, period: 'minute' }, scopes: ['routes:write'] },
       }),
-      OpenApi.validate('param', schema.reconcileFundingDepositAddress.Params, {
+      OpenApi.validate('param', schema.reconcileRoutesDepositAddress.Params, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
       }),
       OpenApi.describeRoute({
         description:
-          'Queues an immediate provider reconciliation for one reusable funding deposit address.',
-        operationId: 'reconcileFundingDepositAddress',
-        responses: reconcileFundingDepositAddressResponses,
+          'Queues an immediate provider reconciliation for one reusable route deposit address.',
+        operationId: 'reconcileRoutesDepositAddress',
+        responses: reconcileRoutesDepositAddressResponses,
         summary: 'Reconcile deposit address',
         tags: ['Deposit Addresses'],
       }),
@@ -968,31 +1280,31 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         const db = Db.get(c.get('db'))
         const { id } = c.req.valid('param')
         try {
-          const record = await FundingDepositAddresses.getOwned(db, owner, id)
+          const record = await RoutesDepositAddresses.getOwned(db, owner, id)
           if (!record)
             return Response.error(c, {
-              code: 'funding_deposit_address_not_found',
-              message: 'Funding deposit address not found',
+              code: 'routes_deposit_address_not_found',
+              message: 'Route deposit address not found',
               status: 404,
             })
           if (record.status !== 'active')
             return Response.error(c, {
-              code: 'funding_deposit_address_not_active',
-              message: 'Funding deposit address is not active',
+              code: 'routes_deposit_address_not_active',
+              message: 'Route deposit address is not active',
               status: 409,
             })
           const dispatch = options.dispatchDepositReconciliation
           if (!dispatch)
             return Response.error(c, {
               code: 'not_implemented',
-              message: 'Manual funding reconciliation is not configured',
+              message: 'Manual routes reconciliation is not configured',
               status: 501,
             })
 
           await dispatch({
             addressId: record.id,
             trigger: 'manual',
-            type: 'funding:deposit-address:reconcile',
+            type: 'routes:deposit-address:reconcile',
           })
           return c.body(null, 202)
         } catch (cause) {
@@ -1001,23 +1313,23 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
       },
     )
     .get(
-      '/v1/funding/deposits',
-      Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
-      OpenApi.validate('query', schema.listFundingDeposits.Query, {
+      '/v1/routes/deposits',
+      Auth.policy({ apiKey: { scopes: ['routes:read'] } }),
+      OpenApi.validate('query', schema.listRoutesDeposits.Query, {
         code: 'query_invalid',
         message: 'Check the query parameters and try again.',
       }),
       OpenApi.describeRoute({
         description: 'Lists visible deposits, optionally filtered, newest first.',
-        operationId: 'listFundingDeposits',
+        operationId: 'listRoutesDeposits',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['query_invalid'] },
           },
           success: {
-            description: 'A page of visible funding deposits.',
-            example: fundingDepositsExample,
-            schema: schema.listFundingDeposits.Response,
+            description: 'A page of visible route deposits.',
+            example: routesDepositsExample,
+            schema: schema.listRoutesDeposits.Response,
           },
         }),
         summary: 'List deposits',
@@ -1043,18 +1355,18 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             parameters.destinationToken !== undefined ||
             parameters.sourceChain !== undefined ||
             parameters.sourceToken !== undefined
-              ? await FundingCatalog.snapshot(c)
+              ? await RoutesCatalog.snapshot(c)
               : undefined
           const filters = resolveDepositFilters({ catalog, parameters })
           // Counts are best-effort and share every ownership and filter predicate
           // with the page query. A failure omits `meta` rather than failing the page.
           const countPromise = include.includes('totalCount')
-            ? FundingDeposits.count(db, {
+            ? RoutesDeposits.count(db, {
                 ...filters,
                 cap: Schema.countCap,
                 owner,
               }).catch(() => {
-                c.set('fundingDepositCountFailed', true)
+                c.set('routesDepositCountFailed', true)
                 return undefined
               })
             : undefined
@@ -1066,19 +1378,19 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
             limit: limit + 1,
             owner,
           }
-          const rows = await FundingDeposits.list(db, paging)
+          const rows = await RoutesDeposits.listByOwner(db, paging)
           const page = Cursor.paginate({
             key: (record) => [record.createdAt, record.id],
             limit,
             rows,
           })
-          const data = page.rows.map(FundingDeposit.toPublic)
+          const data = page.rows.map(RoutesDeposit.toPublic)
           const count = await countPromise
 
           c.header('Cache-Control', Cache.policies.noStore)
           c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key')
           return c.json(
-            Response.validated(schema.listFundingDeposits.Response, {
+            Response.validated(schema.listRoutesDeposits.Response, {
               data,
               ...(count === undefined
                 ? {}
@@ -1098,33 +1410,33 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
       },
     )
     .get(
-      '/v1/funding/deposits/:id{fdp_[A-Za-z0-9_-]+}',
-      Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
-      OpenApi.validate('param', schema.getFundingDeposit.Params, {
+      '/v1/routes/deposits/:id{rdp_[A-Za-z0-9_-]+}',
+      Auth.policy({ apiKey: { scopes: ['routes:read'] } }),
+      OpenApi.validate('param', schema.getRoutesDeposit.Params, {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
       }),
       OpenApi.describeRoute({
         description: 'Returns one detected deposit and its delivery status.',
-        operationId: 'getFundingDeposit',
+        operationId: 'getRoutesDeposit',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['param_invalid'] },
             404: {
-              codes: ['funding_deposit_not_found'],
-              description: 'No visible funding deposit exists for the identifier.',
+              codes: ['routes_deposit_not_found'],
+              description: 'No visible route deposit exists for the identifier.',
             },
           },
           success: {
-            description: 'The requested funding deposit.',
-            example: fundingDepositExample,
-            schema: schema.getFundingDeposit.Response,
+            description: 'The requested route deposit.',
+            example: routesDepositExample,
+            schema: schema.getRoutesDeposit.Response,
           },
         }),
         summary: 'Get deposit',
         tags: ['Deposit Addresses'],
       }),
-      fundingEtag,
+      routesEtag,
       async (c) => {
         if (Auth.narrowAccess) return Auth.accessError(c)
         if (OpenApi.narrowValidation)
@@ -1139,18 +1451,18 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         const db = Db.get(c.get('db'))
         const { id } = c.req.valid('param')
         try {
-          const record = await FundingDeposits.getOwned(db, owner, id)
+          const record = await RoutesDeposits.getOwned(db, owner, id)
           if (!record)
             return Response.error(c, {
-              code: 'funding_deposit_not_found',
-              message: 'Funding deposit not found',
+              code: 'routes_deposit_not_found',
+              message: 'Route deposit not found',
               status: 404,
             })
 
           c.header('Cache-Control', Cache.policies.state)
           c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key')
           return c.json(
-            Response.validated(schema.getFundingDeposit.Response, FundingDeposit.toPublic(record)),
+            Response.validated(schema.getRoutesDeposit.Response, RoutesDeposit.toPublic(record)),
             200,
           )
         } catch (cause) {
@@ -1165,10 +1477,10 @@ export declare namespace depositAddresses {
   type Options = {
     /** Enqueues one deposit address for asynchronous reconciliation. */
     dispatchDepositReconciliation?:
-      | ((message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>)
+      | ((message: RoutesProvider.Webhook.receive.Dispatchable) => Promise<void>)
       | undefined
     /** Registers a created address with a source-chain observer. */
-    registerDepositAddress?: ((address: FundingDepositAddress.Public) => Promise<void>) | undefined
+    registerDepositAddress?: ((address: RoutesDepositAddress.Public) => Promise<void>) | undefined
   }
 }
 
@@ -1180,6 +1492,14 @@ function depositAddressNotAvailable(c: Context<App.Environment>) {
   })
 }
 
+function depositAddressLimitExceeded(c: Context<App.Environment>) {
+  return Response.error(c, {
+    code: 'routes_deposit_address_limit_exceeded',
+    message: `Route deposit address limit reached (${RoutesDepositAddress.maximumPerCreator}).`,
+    status: 403,
+  })
+}
+
 class IdempotencyLeaseLostError extends Error {
-  override name = 'Funding.IdempotencyLeaseLostError'
+  override name = 'Routes.IdempotencyLeaseLostError'
 }