tapimo 0.13.0 → 0.15.0

package/dist/apps/{funding → routes}/routes/deposit-addresses.js

@@ -1,39 +1,43 @@
 import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
 import { etag } from 'hono/etag';
 import * as z from 'zod/mini';
 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' };
+/** Zod schemas owned by route deposit-address resources. */
 export var schema;
 (function (schema) {
-    /** One reusable funding deposit address. */
-    schema.DepositAddress = FundingDepositAddress.schema.FundingDepositAddress;
-    /** One detected funding deposit. */
-    schema.Deposit = FundingDeposit.schema.FundingDeposit;
-    /** Schemas for the createFundingDepositAddress operation. */
-    let createFundingDepositAddress;
-    (function (createFundingDepositAddress) {
-        /** Funding deposit address creation request body. */
-        createFundingDepositAddress.Body = OpenApi.component(z
+    /** One reusable route deposit address. */
+    schema.DepositAddress = RoutesDepositAddress.schema.RoutesDepositAddress;
+    /** One detected route deposit. */
+    schema.Deposit = RoutesDeposit.schema.RoutesDeposit;
+    /** Schemas for the createRoutesDepositAddress operation. */
+    let createRoutesDepositAddress;
+    (function (createRoutesDepositAddress) {
+        /** Route deposit address creation request body. */
+        createRoutesDepositAddress.Body = OpenApi.component(z
             .strictObject({
-            amount: FundingTransfer.schema.CreateRequest.shape.amount,
+            amount: RoutesTransfer.schema.CreateRequest.shape.amount,
             destinationToken: z
                 .string()
                 .check(z.minLength(1), z.describe('Tempo destination token symbol, contract address, or token key.'), z.meta({ examples: ['usdt0'] })),
@@ -53,66 +57,66 @@ export var schema;
                 .optional(z.boolean())
                 .check(z.describe('Guarantees normalized 1:1 delivery through a Tempo-funded subsidy.'), z.meta({ examples: [false] })),
         })
-            .check(z.describe('Reusable funding deposit address creation request.')), 'CreateFundingDepositAddressRequest');
-        /** Required headers for funding deposit address creation. */
-        createFundingDepositAddress.Headers = z.object({
+            .check(z.describe('Reusable route deposit address creation request.')), 'CreateRoutesDepositAddressRequest');
+        /** Required headers for route deposit address creation. */
+        createRoutesDepositAddress.Headers = z.object({
             'idempotency-key': z
                 .string()
-                .check(z.minLength(1), 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'] })),
+                .check(z.minLength(1), 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: ['routes_01k1c5j8q8p0be6j5v9m6d1e4r'] })),
         });
         /** The reusable address, with quoted terms only when the provider address was newly stored. */
-        createFundingDepositAddress.Response = OpenApi.component(z
+        createRoutesDepositAddress.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.')), 'CreateFundingDepositAddressResponse');
-    })(createFundingDepositAddress = schema.createFundingDepositAddress || (schema.createFundingDepositAddress = {}));
-    /** Schemas for the getFundingDepositAddress operation. */
-    let getFundingDepositAddress;
-    (function (getFundingDepositAddress) {
-        /** Path parameters for reading a funding deposit address. */
-        getFundingDepositAddress.Params = z
+            .check(z.describe('A reusable route deposit address, including terms sampled for a newly stored provider address.')), 'CreateRoutesDepositAddressResponse');
+    })(createRoutesDepositAddress = schema.createRoutesDepositAddress || (schema.createRoutesDepositAddress = {}));
+    /** Schemas for the getRoutesDepositAddress operation. */
+    let getRoutesDepositAddress;
+    (function (getRoutesDepositAddress) {
+        /** Path parameters for reading a route deposit address. */
+        getRoutesDepositAddress.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'] })),
+                .check(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.'));
-        /** One reusable funding deposit address. */
-        getFundingDepositAddress.Response = schema.DepositAddress;
-    })(getFundingDepositAddress = schema.getFundingDepositAddress || (schema.getFundingDepositAddress = {}));
-    /** Schemas for the listFundingDepositAddresses operation. */
-    let listFundingDepositAddresses;
-    (function (listFundingDepositAddresses) {
-        /** Query parameters for listing funding deposit addresses. */
-        listFundingDepositAddresses.Query = z
+            .check(z.describe('Path parameters for reading a route deposit address.'));
+        /** One reusable route deposit address. */
+        getRoutesDepositAddress.Response = schema.DepositAddress;
+    })(getRoutesDepositAddress = schema.getRoutesDepositAddress || (schema.getRoutesDepositAddress = {}));
+    /** Schemas for the listRoutesDepositAddresses operation. */
+    let listRoutesDepositAddresses;
+    (function (listRoutesDepositAddresses) {
+        /** Query parameters for listing route deposit addresses. */
+        listRoutesDepositAddresses.Query = z
             .object({
             cursor: Schema.Cursor,
             limit: Schema.Limit,
         })
-            .check(z.describe('Paging parameters for listing funding deposit addresses.'));
-        /** One page of reusable funding deposit addresses. */
-        listFundingDepositAddresses.Response = OpenApi.component(z
+            .check(z.describe('Paging parameters for listing route deposit addresses.'));
+        /** One page of reusable route deposit addresses. */
+        listRoutesDepositAddresses.Response = OpenApi.component(z
             .object({
             data: z
                 .array(schema.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');
-    })(listFundingDepositAddresses = schema.listFundingDepositAddresses || (schema.listFundingDepositAddresses = {}));
-    /** Schemas for the reconcileFundingDepositAddress operation. */
-    let reconcileFundingDepositAddress;
-    (function (reconcileFundingDepositAddress) {
-        /** Path parameters for reconciling a funding deposit address. */
-        reconcileFundingDepositAddress.Params = getFundingDepositAddress.Params;
-    })(reconcileFundingDepositAddress = schema.reconcileFundingDepositAddress || (schema.reconcileFundingDepositAddress = {}));
-    /** Schemas for the listFundingDeposits operation. */
-    let listFundingDeposits;
-    (function (listFundingDeposits) {
-        /** Query parameters for listing funding deposits. */
-        listFundingDeposits.Query = z
+            .check(z.describe('A page of reusable route deposit addresses.')), 'RoutesDepositAddressList');
+    })(listRoutesDepositAddresses = schema.listRoutesDepositAddresses || (schema.listRoutesDepositAddresses = {}));
+    /** Schemas for the reconcileRoutesDepositAddress operation. */
+    let reconcileRoutesDepositAddress;
+    (function (reconcileRoutesDepositAddress) {
+        /** Path parameters for reconciling a route deposit address. */
+        reconcileRoutesDepositAddress.Params = getRoutesDepositAddress.Params;
+    })(reconcileRoutesDepositAddress = schema.reconcileRoutesDepositAddress || (schema.reconcileRoutesDepositAddress = {}));
+    /** Schemas for the listRoutesDeposits operation. */
+    let listRoutesDeposits;
+    (function (listRoutesDeposits) {
+        /** Query parameters for listing route deposits. */
+        listRoutesDeposits.Query = z
             .object({
             depositAddress: z
                 .optional(z.string().check(z.minLength(1)))
@@ -125,7 +129,7 @@ export var 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(z.describe('Tempo account that received the deposits.'), z.meta({ examples: [`0x${'11'.repeat(20)}`] })),
@@ -135,11 +139,11 @@ export var schema;
             sourceToken: z
                 .optional(z.string().check(z.minLength(1)))
                 .check(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.'));
         /** One page of detected deposits. */
-        listFundingDeposits.Response = OpenApi.component(z
+        listRoutesDeposits.Response = OpenApi.component(z
             .object({
             data: z.array(schema.Deposit).check(z.describe('Detected deposits on this page, newest first.')),
             meta: z
@@ -147,22 +151,22 @@ export var schema;
                 .check(z.describe('Extra response metadata requested with `include`.')),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A page of visible funding deposits.')), 'FundingDepositList');
-    })(listFundingDeposits = schema.listFundingDeposits || (schema.listFundingDeposits = {}));
-    /** Schemas for the getFundingDeposit operation. */
-    let getFundingDeposit;
-    (function (getFundingDeposit) {
-        /** Path parameters for reading a funding deposit. */
-        getFundingDeposit.Params = z
+            .check(z.describe('A page of visible route deposits.')), 'RoutesDepositList');
+    })(listRoutesDeposits = schema.listRoutesDeposits || (schema.listRoutesDeposits = {}));
+    /** Schemas for the getRoutesDeposit operation. */
+    let getRoutesDeposit;
+    (function (getRoutesDeposit) {
+        /** Path parameters for reading a route deposit. */
+        getRoutesDeposit.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'] })),
+                .check(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.'));
-        /** One detected funding deposit. */
-        getFundingDeposit.Response = schema.Deposit;
-    })(getFundingDeposit = schema.getFundingDeposit || (schema.getFundingDeposit = {}));
+            .check(z.describe('Path parameters for reading a route deposit.'));
+        /** One detected route deposit. */
+        getRoutesDeposit.Response = schema.Deposit;
+    })(getRoutesDeposit = schema.getRoutesDeposit || (schema.getRoutesDeposit = {}));
 })(schema || (schema = {}));
 const tronChainExample = {
     addressFormat: 'base58check',
@@ -196,12 +200,12 @@ const tempoUsdt0Example = {
     tokenKey: 'eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73',
     verified: true,
 };
-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',
@@ -211,8 +215,8 @@ const fundingDepositAddressExample = {
     subsidize: false,
     updatedAt: '2026-08-04T00:00:00.000Z',
 };
-const createdFundingDepositAddressExample = {
-    ...fundingDepositAddressExample,
+const createdRoutesDepositAddressExample = {
+    ...routesDepositAddressExample,
     destinationAmount: Value.tokenAmount({ baseUnits: '1000000', currency: 'USD', decimals: 6 }),
     destinationAmountMin: Value.tokenAmount({
         baseUnits: '1000000',
@@ -223,29 +227,29 @@ const createdFundingDepositAddressExample = {
     quote: { sampledAt: '2026-08-04T00:00:00.000Z' },
     sourceAmount: Value.tokenAmount({ baseUnits: '1000000', currency: 'USD', decimals: 6 }),
 };
-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'],
     status: 'detected',
     updatedAt: '2026-08-04T00:01:00.000Z',
 };
-const fundingDepositsExample = {
-    data: [fundingDepositExample],
+const routesDepositsExample = {
+    data: [routesDepositExample],
     meta: { totalCount: 1, totalCountCapped: false },
     nextCursor: null,
 };
-const fundingDepositAddressesExample = {
-    data: [fundingDepositAddressExample],
+const routesDepositAddressesExample = {
+    data: [routesDepositAddressExample],
     nextCursor: null,
 };
 function resolveDepositFilters(options) {
@@ -321,25 +325,25 @@ function tokenKey(token) {
     })();
     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'],
@@ -355,7 +359,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,
@@ -366,55 +370,85 @@ const idempotencyReplayTtlMs = 86_400_000;
 // Pending claims only cover the bounded provider preparation window.
 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 = {}) {
     return new Hono()
-        .post('/webhooks/funding/:providerId', async (c) => {
+        .post('/webhooks/routes/:providerId', async (c, next) => {
         const provider = c
             .get('providers')
-            .filter(FundingProvider.is)
+            .filter(RoutesProvider.is)
             .find((candidate) => candidate.id === c.req.param('providerId'));
-        if (!provider || !FundingProvider.canReceiveWebhook(provider))
+        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 provider.webhook.receive({
-                body: await c.req.text(),
+            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 FundingProvider.WebhookAuthenticationError)
+            if (cause instanceof RoutesProvider.WebhookAuthenticationError)
                 return c.body(null, 401);
-            if (cause instanceof FundingProvider.WebhookPayloadError)
+            if (cause instanceof RoutesProvider.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, {
+        .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.',
-    }), OpenApi.validate('json', schema.createFundingDepositAddress.Body, {
+        message: 'Route deposit address creation requires an `Idempotency-Key` header.',
+    }), 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.',
@@ -429,9 +463,9 @@ export function 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',
@@ -454,16 +488,48 @@ export function 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',
+                };
+            }
+            catch (cause) {
+                if (cause instanceof RoutesDepositAddresses.OwnerNotFoundError ||
+                    RoutesIdempotency.isOwnerFenceError(cause))
+                    return { type: 'ownerNotFound' };
+                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',
@@ -473,19 +539,19 @@ export function 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);
-            return c.json(Response.validated(schema.createFundingDepositAddress.Response, {
+            return c.json(Response.validated(schema.createRoutesDepositAddress.Response, {
                 ...response,
                 subsidize: response['subsidize'] ?? false,
             }), 200);
         }
         const release = async () => {
             try {
-                await FundingIdempotency.release(db, {
+                await RoutesIdempotency.release(db, {
                     apiKeyId: identity.apiKeyId,
                     createdAt: claim.createdAt,
                     keyHash: identity.keyHash,
@@ -496,8 +562,8 @@ export function depositAddresses(options = {}) {
             }
         };
         const complete = async (database, 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,
@@ -505,18 +571,102 @@ export function 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 = [];
         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',
+                    };
+                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' };
+                if (capacity.type === 'resume')
+                    return {
+                        checkpoint: depositAddressCheckpoint.parse(JSON.parse(capacity.response)),
+                        checkpointFresh: capacity.checkpointFresh,
+                        quoteMatchesRequest: false,
+                        recoveredClaim: capacity.claim,
+                        type: 'resume',
+                    };
+                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'),
@@ -533,33 +683,93 @@ export function depositAddresses(options = {}) {
                     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',
+                };
+            })();
+            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' };
+                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' };
+                return {
+                    recoveredClaim: capacity.type === 'resume' ? capacity.claim : selected.recoveredClaim,
+                    type: 'ready',
+                };
+            })();
+            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 { candidate: selectedCandidate, provider, recipient, refundAddress, result, } = selected;
+            const { candidate: selectedCandidate, provider, recipient, refundAddress, result, } = 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,
@@ -581,10 +791,8 @@ export function 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,
@@ -617,64 +825,124 @@ export function 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));
-            return c.json(created, 200);
+                await options.registerDepositAddress(RoutesDepositAddress.schema.RoutesDepositAddress.parse(created.response));
+            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) {
-                if (cause instanceof FundingDepositAddress.ConflictError)
+            if (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 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,
                 });
             }
             throw cause;
         }
     })
-        .get('/v1/funding/deposit-addresses', Auth.policy({ apiKey: { scopes: ['funding:read'] } }), OpenApi.validate('query', schema.listFundingDepositAddresses.Query, {
+        .get('/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',
@@ -694,7 +962,7 @@ export function 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]) } }
                     : {}),
@@ -706,10 +974,10 @@ export function 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, {
+            return c.json(Response.validated(schema.listRoutesDepositAddresses.Response, {
                 data,
                 nextCursor: page.nextCursor,
             }), 200);
@@ -718,24 +986,24 @@ export function depositAddresses(options = {}) {
             return Response.upstream(c, cause);
         }
     })
-        .get('/v1/funding/deposit-addresses/:id{fda_[A-Za-z0-9_-]+}', Auth.policy({ apiKey: { scopes: ['funding:read'] } }), OpenApi.validate('param', schema.getFundingDepositAddress.Params, {
+        .get('/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',
@@ -754,30 +1022,30 @@ export function 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,
                 });
             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.getFundingDepositAddress.Response, FundingDepositAddress.toPublic(record)), 200);
+            return c.json(Response.validated(schema.getRoutesDepositAddress.Response, RoutesDepositAddress.toPublic(record)), 200);
         }
         catch (cause) {
             return Response.upstream(c, cause);
         }
     })
-        .post('/v1/funding/deposit-addresses/:id{fda_[A-Za-z0-9_-]+}/reconcile', Auth.policy({
-        apiKey: { rateLimit: { limit: 10, period: 'minute' }, scopes: ['funding:write'] },
-    }), OpenApi.validate('param', schema.reconcileFundingDepositAddress.Params, {
+        .post('/v1/routes/deposit-addresses/:id{rda_[A-Za-z0-9_-]+}/reconcile', Auth.policy({
+        apiKey: { rateLimit: { limit: 10, period: 'minute' }, scopes: ['routes:write'] },
+    }), 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,
+        description: 'Queues an immediate provider reconciliation for one reusable route deposit address.',
+        operationId: 'reconcileRoutesDepositAddress',
+        responses: reconcileRoutesDepositAddressResponses,
         summary: 'Reconcile deposit address',
         tags: ['Deposit Addresses'],
     }), async (c) => {
@@ -796,30 +1064,30 @@ export function 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.dispatchReconciliation;
+            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);
         }
@@ -827,20 +1095,20 @@ export function depositAddresses(options = {}) {
             return Response.upstream(c, cause);
         }
     })
-        .get('/v1/funding/deposits', Auth.policy({ apiKey: { scopes: ['funding:read'] } }), OpenApi.validate('query', schema.listFundingDeposits.Query, {
+        .get('/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',
@@ -864,18 +1132,18 @@ export function depositAddresses(options = {}) {
             const catalog = 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;
@@ -887,17 +1155,17 @@ export function 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, {
+            return c.json(Response.validated(schema.listRoutesDeposits.Response, {
                 data,
                 ...(count === undefined
                     ? {}
@@ -914,29 +1182,29 @@ export function depositAddresses(options = {}) {
             return Response.upstream(c, cause);
         }
     })
-        .get('/v1/funding/deposits/:id{fdp_[A-Za-z0-9_-]+}', Auth.policy({ apiKey: { scopes: ['funding:read'] } }), OpenApi.validate('param', schema.getFundingDeposit.Params, {
+        .get('/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, async (c) => {
+    }), routesEtag, async (c) => {
         if (Auth.narrowAccess)
             return Auth.accessError(c);
         if (OpenApi.narrowValidation)
@@ -950,16 +1218,16 @@ export function 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)), 200);
+            return c.json(Response.validated(schema.getRoutesDeposit.Response, RoutesDeposit.toPublic(record)), 200);
         }
         catch (cause) {
             return Response.upstream(c, cause);
@@ -973,7 +1241,14 @@ function depositAddressNotAvailable(c) {
         status: 404,
     });
 }
+function depositAddressLimitExceeded(c) {
+    return Response.error(c, {
+        code: 'routes_deposit_address_limit_exceeded',
+        message: `Route deposit address limit reached (${RoutesDepositAddress.maximumPerCreator}).`,
+        status: 403,
+    });
+}
 class IdempotencyLeaseLostError extends Error {
-    name = 'Funding.IdempotencyLeaseLostError';
+    name = 'Routes.IdempotencyLeaseLostError';
 }
 //# sourceMappingURL=deposit-addresses.js.map