tapimo 0.15.0 → 0.18.0

package/dist/apps/routes/routes/deposit-addresses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deposit-addresses.d.ts","sourceRoot":"","sources":["../../../../src/apps/routes/routes/deposit-addresses.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAU3C,OAAO,KAAK,oBAAoB,MAAM,4CAA4C,CAAA;AAElF,OAAO,KAAK,cAAc,MAAM,sCAAsC,CAAA;AAKtE,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAQzD,4DAA4D;AAC5D,yBAAiB,MAAM,CAAC;IACtB,0CAA0C;IACnC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAmD,CAAA;IAE9E,kCAAkC;IAC3B,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAqC,CAAA;IAEzD,4DAA4D;IAC5D,UAAiB,0BAA0B,CAAC;QAC1C,mDAAmD;QAC5C,MAAM,IAAI;;;;;;;;0BAgDhB,CAAA;QAED,2DAA2D;QACpD,MAAM,OAAO;;yBAUlB,CAAA;QAEF,+FAA+F;QACxF,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYpB,CAAA;KACF;IAED,yDAAyD;IACzD,UAAiB,uBAAuB,CAAC;QACvC,2DAA2D;QACpD,MAAM,MAAM;;yBAUyD,CAAA;QAE5E,0CAA0C;QACnC,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAiB,CAAA;KACvC;IAED,4DAA4D;IAC5D,UAAiB,0BAA0B,CAAC;QAC1C,4DAA4D;QACrD,MAAM,KAAK;;;yBAK4D,CAAA;QAE9E,oDAAoD;QAC7C,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUpB,CAAA;KACF;IAED,+DAA+D;IAC/D,UAAiB,6BAA6B,CAAC;QAC7C,+DAA+D;QACxD,MAAM,MAAM;;yBAAiC,CAAA;KACrD;IAED,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,mDAAmD;QAC5C,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;yBAwCqD,CAAA;QAEvE,qCAAqC;QAC9B,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAWpB,CAAA;KACF;IAED,kDAAkD;IAClD,UAAiB,gBAAgB,CAAC;QAChC,mDAAmD;QAC5C,MAAM,MAAM;;yBAUiD,CAAA;QAEpE,kCAAkC;QAC3B,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAU,CAAA;KAChC;CACF;AAwQD,mEAAmE;AACnE,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,gBAAgB,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAg8BtE;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,0CAA0C;IAC1C,KAAK,OAAO,GAAG;QACb,oEAAoE;QACpE,6BAA6B,CAAC,EAC1B,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GACzE,SAAS,CAAA;QACb,gEAAgE;QAChE,sBAAsB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,oBAAoB,CAAC,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAA;KAC/F,CAAA;CACF"}
+{"version":3,"file":"deposit-addresses.d.ts","sourceRoot":"","sources":["../../../../src/apps/routes/routes/deposit-addresses.ts"],"names":[],"mappings":"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"}

package/dist/apps/routes/routes/deposit-addresses.js

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { etag } from 'hono/etag';
+import { Value as core_Value } from 'ox';
 import * as z from 'zod/mini';
 import * as Db from '../../../db/Db.js';
 import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js';
@@ -13,6 +14,7 @@ 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 RoutesPolicy from '../../../internal/routes/Policy.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';
@@ -378,8 +380,10 @@ const depositAddressCheckpoint = Schema.describe(z.object({
         sourceToken: RoutesProvider.schema.TokenRef,
     }), 'Normalized route retained after provider provisioning.'),
     provider: RoutesProvider.schema.ProviderRef,
+    policyVersions: z.optional(z.array(z.number().check(z.int(), z.nonnegative()))),
     recipient: z.string().check(z.describe('Normalized Tempo recipient.')),
     refundAddress: z.string().check(z.describe('Normalized source-chain refund account.')),
+    routePolicy: z.optional(RoutesPolicy.schema.Commitment),
     result: RoutesProvider.schema.DepositAddressResult,
 }), 'Provider result retained until deposit address creation completes.');
 const routesEtag = etag();
@@ -438,24 +442,32 @@ export function depositAddresses(options = {}) {
         operationId: 'createRoutesDepositAddress',
         responses: OpenApi.responses({
             errors: {
-                400: { codes: ['body_invalid', 'idempotency_key_required'] },
+                400: { codes: ['amount_too_low', 'body_invalid', 'idempotency_key_required'] },
                 403: {
                     codes: [
                         'billing_past_due',
                         'billing_required',
                         'routes_deposit_address_limit_exceeded',
+                        'routes_not_allowed',
+                        'routes_subsidy_not_allowed',
                         'routes_subsidy_not_enabled',
+                        'routes_suspended',
                     ],
                     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.',
+                    codes: ['deposit_address_not_available', 'quote_not_available'],
+                    description: 'The reusable address route or current quote is unavailable.',
                 },
                 409: {
-                    codes: ['idempotency_conflict', 'idempotency_in_progress'],
-                    description: 'The Idempotency-Key conflicts with an existing or in-flight request.',
+                    codes: [
+                        'idempotency_conflict',
+                        'idempotency_in_progress',
+                        'route_policy_changed',
+                        'route_policy_identity_conflict',
+                    ],
+                    description: 'The request conflicts with an existing address, policy, or in-flight request.',
                 },
                 502: {
                     codes: ['upstream_error'],
@@ -577,28 +589,30 @@ export function depositAddresses(options = {}) {
         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,
+            const policyContext = await Access.loadPolicy(c);
+            if (!policyContext)
+                throw new Error('Missing route policy context for API key.');
+            const legacy = Access.isLegacy(policyContext);
+            const policy = legacy && claim.type === 'claimed' && subsidize
+                ? await RoutesSubsidy.check(db, owner)
+                : undefined;
+            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,
                 });
-                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')
+                if (claim.type === 'resume') {
+                    const checkpoint = depositAddressCheckpoint.parse(JSON.parse(claim.response));
                     return {
-                        checkpoint: depositAddressCheckpoint.parse(JSON.parse(claim.response)),
+                        checkpoint,
                         checkpointFresh: claim.checkpointFresh,
                         ...(claim.recoveredClaim === undefined
                             ? {}
@@ -606,10 +620,14 @@ export function depositAddresses(options = {}) {
                         quoteMatchesRequest: claim.checkpointFresh,
                         type: 'resume',
                     };
-                const catalog = await RoutesCatalog.snapshot(c);
-                const providers = c.get('providers').filter(RoutesProvider.is);
-                const selection = RoutesProvider.selectDepositAddress({
-                    catalog,
+                }
+                const fullCatalog = await RoutesCatalog.snapshot(c);
+                const catalog = Access.filterCatalog(fullCatalog, policyContext, subsidize);
+                const providers = c
+                    .get('providers')
+                    .filter(RoutesProvider.is)
+                    .filter((provider) => !subsidize || options.depositSubsidyAccount || provider.id === 'relay');
+                const request = {
                     destinationChainId: c.get('chainId'),
                     destinationToken: body.destinationToken,
                     providers,
@@ -617,13 +635,88 @@ export function depositAddresses(options = {}) {
                     refundAddress: body.refundAddress,
                     sourceChain: body.sourceChain,
                     sourceToken: body.sourceToken,
+                };
+                const candidates = RoutesProvider.getDepositAddressCandidates({
+                    ...request,
+                    catalog: fullCatalog,
+                });
+                if (candidates.length > 0 &&
+                    !candidates.some(({ candidate }) => catalog.routes.some((entry) => entry.route === candidate.route)))
+                    throw new Access.PolicyError(subsidize ? 'routes_subsidy_not_allowed' : 'routes_not_allowed');
+                if (candidates.length === 0)
+                    return undefined;
+                const commitments = new Map();
+                if (subsidize && !legacy) {
+                    let denied;
+                    for (const { candidate } of RoutesProvider.getDepositAddressCandidates({
+                        ...request,
+                        catalog,
+                    })) {
+                        try {
+                            commitments.set(candidate.route, await Access.commitment(db, policyContext, RoutesPolicy.fromRoute({
+                                providerId: candidate.provider.id,
+                                route: candidate.route,
+                            }), options.depositSubsidyMaxAmount ?? '0'));
+                        }
+                        catch (cause) {
+                            if (!(cause instanceof Access.PolicyError))
+                                throw cause;
+                            denied = cause;
+                        }
+                    }
+                    if (commitments.size === 0 && denied)
+                        throw denied;
+                }
+                const selection = RoutesProvider.selectDepositAddress({
+                    ...request,
+                    catalog: subsidize && !legacy
+                        ? {
+                            ...catalog,
+                            routes: catalog.routes.filter((entry) => commitments.has(entry.route)),
+                        }
+                        : catalog,
                 });
                 if (!selection)
                     return undefined;
+                const commitment = commitments.get(selection.candidate.route);
+                const subsidyMaxAmount = (() => {
+                    if (commitment)
+                        return commitment.maxAmount;
+                    if (policy?.type !== 'allowed')
+                        return undefined;
+                    const maximum = core_Value.from(policy.maxAmount, 6);
+                    const platform = core_Value.from(options.depositSubsidyMaxAmount ?? '0', 6);
+                    return core_Value.format(maximum < platform ? maximum : platform, 6);
+                })();
+                // Relay pins sponsorship to the address, including addresses created under legacy grants.
+                const routePolicy = commitment ??
+                    (selection.candidate.provider.id === 'relay' && subsidyMaxAmount !== undefined
+                        ? {
+                            maxAmount: subsidyMaxAmount,
+                            scope: policyContext.scope,
+                            subsidyPayer: 'enterprise',
+                            versions: policyContext.versions,
+                        }
+                        : undefined);
                 const match = {
                     destinationTokenKey: selection.candidate.destinationToken.tokenKey,
                     environment: owner.environment,
                     orgId: owner.orgId,
+                    ...(!legacy || (subsidize && selection.candidate.provider.id === 'relay')
+                        ? {
+                            policyKey: RoutesPolicy.depositKey({
+                                ...(subsidize && selection.candidate.provider.id === 'relay'
+                                    ? { fixedRate: '1:1' }
+                                    : {}),
+                                routePolicy,
+                            }),
+                        }
+                        : {}),
+                    ...(legacy && !routePolicy
+                        ? {}
+                        : {
+                            providerId: selection.candidate.provider.id,
+                        }),
                     ...(owner.projectId === undefined ? {} : { projectId: owner.projectId }),
                     recipient: selection.recipient,
                     refundAddress: selection.refundAddress,
@@ -632,6 +725,7 @@ export function depositAddresses(options = {}) {
                     subsidize,
                 };
                 const capacity = await RoutesDepositAddresses.validateCreationCapacity(db, {
+                    checkPolicy: (tx) => Access.assertPolicy(tx, policyContext),
                     claim: {
                         apiKeyId: identity.apiKeyId,
                         createdAt: claim.createdAt,
@@ -668,7 +762,10 @@ export function depositAddresses(options = {}) {
                 }
                 const provisioned = await RoutesProvider.createDepositAddress({
                     amount: body.amount,
-                    catalog,
+                    catalog: {
+                        ...catalog,
+                        routes: catalog.routes.filter((entry) => entry.route === selection.candidate.route),
+                    },
                     destinationChainId: c.get('chainId'),
                     destinationToken: body.destinationToken,
                     onAttempt: (attempt) => attempts.push(attempt),
@@ -678,6 +775,7 @@ export function depositAddresses(options = {}) {
                     sourceChain: body.sourceChain,
                     sourceToken: body.sourceToken,
                     subsidize,
+                    subsidyMaxAmount,
                 });
                 if (!provisioned)
                     return undefined;
@@ -686,8 +784,10 @@ export function depositAddresses(options = {}) {
                     amount: body.amount,
                     candidate: provisioned.candidate,
                     provider: provisioned.provider,
+                    ...(legacy ? {} : { policyVersions: policyContext.versions }),
                     recipient: provisioned.recipient,
                     refundAddress: provisioned.refundAddress,
+                    routePolicy,
                     result: provisioned.result,
                 });
                 return {
@@ -716,6 +816,22 @@ export function depositAddresses(options = {}) {
                     destinationTokenKey: selected.checkpoint.candidate.destinationToken.tokenKey,
                     environment: owner.environment,
                     orgId: owner.orgId,
+                    ...(selected.checkpoint.policyVersions === undefined &&
+                        selected.checkpoint.result.correlation.fixedRate === undefined &&
+                        selected.checkpoint.routePolicy === undefined
+                        ? {}
+                        : {
+                            policyKey: RoutesPolicy.depositKey({
+                                fixedRate: selected.checkpoint.result.correlation.fixedRate,
+                                routePolicy: selected.checkpoint.routePolicy,
+                            }),
+                        }),
+                    ...(selected.checkpoint.routePolicy === undefined &&
+                        selected.checkpoint.policyVersions === undefined
+                        ? {}
+                        : {
+                            providerId: selected.checkpoint.provider.id,
+                        }),
                     ...(owner.projectId === undefined ? {} : { projectId: owner.projectId }),
                     recipient: selected.checkpoint.recipient,
                     refundAddress: selected.checkpoint.refundAddress,
@@ -724,6 +840,9 @@ export function depositAddresses(options = {}) {
                     subsidize,
                 };
                 const capacity = await RoutesDepositAddresses.validateCreationCapacity(db, {
+                    ...(claim.type === 'resume'
+                        ? {}
+                        : { checkPolicy: (tx) => Access.assertPolicy(tx, policyContext) }),
                     claim: {
                         apiKeyId: identity.apiKeyId,
                         createdAt: claim.createdAt,
@@ -753,6 +872,12 @@ export function depositAddresses(options = {}) {
                     await options.registerDepositAddress(RoutesDepositAddress.schema.RoutesDepositAddress.parse(response));
                 return c.json(response, 200);
             }
+            // A resumed provider checkpoint still needs a settler before creating a subsidized address.
+            if (selected.type === 'resume' &&
+                subsidize &&
+                selected.checkpoint.provider.id !== 'relay' &&
+                !options.depositSubsidyAccount)
+                return depositAddressNotAvailable(c);
             if (selected.type === 'provisioned') {
                 const stored = await RoutesIdempotency.checkpoint(db, {
                     apiKeyId: identity.apiKeyId,
@@ -766,6 +891,8 @@ export function depositAddresses(options = {}) {
             }
             const { candidate: selectedCandidate, provider, recipient, refundAddress, result, } = selected.checkpoint;
             const created = await db.transaction(async (tx) => {
+                // Capacity acceptance serialized the grant before provisioning. Recovery
+                // honors those issued terms even after suspension or policy edits.
                 const persist = selected.type === 'resume'
                     ? RoutesDepositAddress.recoverOrGet
                     : RoutesDepositAddress.createOrGet;
@@ -776,9 +903,32 @@ export function depositAddresses(options = {}) {
                     ...(owner.projectId === undefined ? {} : { projectId: owner.projectId }),
                     providerOutputToken: selectedCandidate.destinationToken,
                     providerRequestIds: [result.correlation.requestId],
-                    providerState: result.correlation.checkEndpoint === undefined
+                    providerState: result.correlation.checkEndpoint === undefined &&
+                        result.correlation.fixedRate === undefined &&
+                        selected.checkpoint.routePolicy === undefined
                         ? undefined
-                        : { checkEndpoint: result.correlation.checkEndpoint },
+                        : {
+                            ...(result.correlation.checkEndpoint === undefined
+                                ? {}
+                                : { checkEndpoint: result.correlation.checkEndpoint }),
+                            ...(result.correlation.fixedRate === undefined
+                                ? {}
+                                : { fixedRate: result.correlation.fixedRate }),
+                            ...(selected.checkpoint.routePolicy === undefined
+                                ? {}
+                                : {
+                                    routePolicy: selected.checkpoint.routePolicy,
+                                }),
+                            ...(result.correlation.fixedRate === undefined &&
+                                selected.checkpoint.routePolicy === undefined
+                                ? {}
+                                : {
+                                    routePolicyKey: RoutesPolicy.depositKey({
+                                        fixedRate: result.correlation.fixedRate,
+                                        routePolicy: selected.checkpoint.routePolicy,
+                                    }),
+                                }),
+                        },
                     snapshot: {
                         address: result.address,
                         destinationChain: selectedCandidate.destinationChain,
@@ -867,14 +1017,49 @@ export function depositAddresses(options = {}) {
             return c.json(created.response, 200);
         }
         catch (cause) {
-            if (!provisioning.succeeded)
+            // A definitive rejection creates no provider liability, even after marking a subsidized attempt.
+            if (cause instanceof RoutesProvider.ProviderUnavailableError)
+                await RoutesIdempotency.release(db, {
+                    apiKeyId: identity.apiKeyId,
+                    createdAt: claim.createdAt,
+                    keyHash: identity.keyHash,
+                });
+            else if (!provisioning.succeeded)
                 await release();
+            if (cause instanceof RoutesProvider.AmountTooLowError) {
+                c.set('routesProviderAttempts', attempts.map(RoutesProvider.formatAttempt));
+                return Response.error(c, {
+                    code: 'amount_too_low',
+                    message: 'This amount cannot cover the route fees. Increase the amount or enable subsidies if available.',
+                    status: 400,
+                });
+            }
+            if (cause instanceof RoutesProvider.ProviderUnavailableError) {
+                c.set('routesProviderAttempts', attempts.map(RoutesProvider.formatAttempt));
+                return Response.error(c, {
+                    code: 'quote_not_available',
+                    message: 'A quote is currently unavailable for this request. Adjust the amount or subsidy settings, or try again later.',
+                    status: 404,
+                });
+            }
             if (cause instanceof RoutesProvider.InvalidRefundAddressError)
                 return Response.error(c, {
                     code: 'body_invalid',
                     message: 'Invalid `refundAddress`.',
                     status: 400,
                 });
+            if (cause instanceof Access.PolicyError)
+                return Access.policyError(c, cause);
+            if (cause instanceof RoutesDepositAddresses.IdentityConflictError) {
+                c.get('metrics')?.count('routes_policy_denial_count', 1, {
+                    reason: 'route_policy_identity_conflict',
+                });
+                return Response.error(c, {
+                    code: 'route_policy_identity_conflict',
+                    message: 'An address for this route already exists with different terms or provider. Existing deposits retain their original terms.',
+                    status: 409,
+                });
+            }
             if (cause instanceof RoutesProvider.UnsupportedSourceChainError)
                 return depositAddressNotAvailable(c);
             if (cause instanceof RoutesDepositAddress.OwnerNotFoundError ||
@@ -1237,7 +1422,7 @@ export function depositAddresses(options = {}) {
 function depositAddressNotAvailable(c) {
     return Response.error(c, {
         code: 'deposit_address_not_available',
-        message: 'No provider can provision the requested reusable deposit address.',
+        message: 'A deposit address is unavailable for the requested route.',
         status: 404,
     });
 }