tapimo 0.15.0 → 0.18.0

package/src/apps/routes/routes/deposit-addresses.test.ts

@@ -8,6 +8,8 @@ import * as RoutesIdempotencyTable from '../../../db/tables/routesIdempotency.js
 
 import * as Organizations from '../../../db/tables/organizations.js'
 
+import * as RoutesPolicies from '../../../db/tables/routesPolicies.js'
+
 import * as RoutesSubsidies from '../../../db/tables/routesSubsidies.js'
 
 import * as StripeCustomers from '../../../db/tables/stripeCustomers.js'
@@ -20,6 +22,8 @@ import * as RoutesDeposit from '../../../internal/routes/Deposit.js'
 
 import * as RoutesDepositAddress from '../../../internal/routes/DepositAddress.js'
 
+import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
+
 import * as RoutesProvider from '../../../internal/routes/Provider.js'
 
 import * as Idempotency from '../../../internal/Idempotency.js'
@@ -40,6 +44,8 @@ import * as Metrics from '../../../Metrics.js'
 
 import * as TestApp from '../../../../test/App.js'
 
+import * as TestRelay from '../../../../test/Relay.js'
+
 import * as TestRoutes from '../../../../test/Routes.js'
 
 import * as Routes from './deposit-addresses.js'
@@ -178,19 +184,21 @@ test('publishes generator-ready route deposit contracts', async () => {
         spec.components.schemas.RoutesDepositAddressNotActiveError.properties.error.properties.code
           .enum,
       addressNotAvailable:
-        spec.components.schemas.DepositAddressNotAvailableError.properties.error.properties.code
-          .enum,
+        spec.components.schemas.DepositAddressNotAvailableOrQuoteNotAvailableError.properties.error
+          .properties.code.enum,
       addressNotFound:
         spec.components.schemas.RoutesDepositAddressNotFoundError.properties.error.properties.code
           .enum,
       createInvalid:
-        spec.components.schemas.ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError.properties
-          .error.properties.code.enum,
+        spec.components.schemas
+          .AmountTooLowOrApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError.properties.error
+          .properties.code.enum,
       depositNotFound:
         spec.components.schemas.RoutesDepositNotFoundError.properties.error.properties.code.enum,
       idempotencyConflict:
-        spec.components.schemas.IdempotencyConflictOrIdempotencyInProgressError.properties.error
-          .properties.code.enum,
+        spec.components.schemas
+          .IdempotencyConflictOrIdempotencyInProgressOrRoutePolicyChangedOrRoutePolicyIdentityConflictError
+          .properties.error.properties.code.enum,
       notImplemented:
         spec.components.schemas.NotImplemented501Error.properties.error.properties.code.enum,
       parametersInvalid:
@@ -287,7 +295,7 @@ test('publishes generator-ready route deposit contracts', async () => {
         "createAddress": {
           "errors": {
             "400": {
-              "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError",
+              "$ref": "#/components/schemas/AmountTooLowOrApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError",
             },
             "401": {
               "$ref": "#/components/schemas/AuthenticationError",
@@ -296,10 +304,10 @@ test('publishes generator-ready route deposit contracts', async () => {
               "$ref": "#/components/schemas/CreateRoutesDepositAddressForbiddenError",
             },
             "404": {
-              "$ref": "#/components/schemas/DepositAddressNotAvailableError",
+              "$ref": "#/components/schemas/DepositAddressNotAvailableOrQuoteNotAvailableError",
             },
             "409": {
-              "$ref": "#/components/schemas/IdempotencyConflictOrIdempotencyInProgressError",
+              "$ref": "#/components/schemas/IdempotencyConflictOrIdempotencyInProgressOrRoutePolicyChangedOrRoutePolicyIdentityConflictError",
             },
             "429": "#/components/responses/RateLimited",
             "500": "#/components/responses/InternalError",
@@ -456,11 +464,13 @@ test('publishes generator-ready route deposit contracts', async () => {
         ],
         "addressNotAvailable": [
           "deposit_address_not_available",
+          "quote_not_available",
         ],
         "addressNotFound": [
           "routes_deposit_address_not_found",
         ],
         "createInvalid": [
+          "amount_too_low",
           "api_key_malformed",
           "body_invalid",
           "idempotency_key_required",
@@ -471,6 +481,8 @@ test('publishes generator-ready route deposit contracts', async () => {
         "idempotencyConflict": [
           "idempotency_conflict",
           "idempotency_in_progress",
+          "route_policy_changed",
+          "route_policy_identity_conflict",
         ],
         "notImplemented": [
           "not_implemented",
@@ -490,7 +502,10 @@ test('publishes generator-ready route deposit contracts', async () => {
           "billing_required",
           "forbidden",
           "routes_deposit_address_limit_exceeded",
+          "routes_not_allowed",
+          "routes_subsidy_not_allowed",
           "routes_subsidy_not_enabled",
+          "routes_suspended",
         ],
       },
       "statusReasons": [
@@ -574,6 +589,356 @@ describe('POST /routes/deposit-addresses', () => {
     })
   })
 
+  test.skipIf(!relayApiKey)(
+    'creates a fresh Relay address after a cap change without changing wallets (live)',
+    async () => {
+      const key = {
+        id: 'key_relay_cap_replacement',
+        orgId: 'org_relay_cap_replacement',
+        scopes: ['routes:read', 'routes:write'],
+        token: 'secret_relay_cap_replacement',
+      }
+      await grantRoutes(key)
+      const scope = { environment: 'production', orgId: key.orgId } as const
+      // Leave room for live Relay fees while testing changes to pinned caps.
+      const policy = {
+        access: null,
+        maxAmount: '1',
+        subsidyEnabled: true,
+        subsidyPayer: 'tempo',
+      } as const
+      await RoutesPolicies.save(db, { policy, scope, version: 1 })
+      const app = create({
+        auth: { keys: [key] },
+        defaultChainId: tempoMainnet.id,
+        providers: [Relay.relay({ apiKey: relayApiKey, subsidies: { maxAmount: '100' } })],
+        routes: { depositSubsidyMaxAmount: '3' },
+      })
+      const body = {
+        ...depositAddressBody,
+        amount: '10000000',
+        refundAddress: `0x${'93'.repeat(20)}`,
+        sourceChain: 'base',
+        sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+        subsidize: true,
+      }
+      const firstKey = nextDepositAddressKey()
+      const first = await TestApp.json(
+        await postDepositAddress(app, { body, idempotencyKey: firstKey, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      const stored = await RoutesDepositAddresses.get(db, first.id)
+      expect(stored?.providerState).toMatchObject({
+        routePolicy: { maxAmount: '1', subsidyPayer: 'tempo' },
+      })
+      await RoutesPolicies.save(db, {
+        policy: { ...policy, maxAmount: '2' },
+        scope,
+        version: 2,
+      })
+      const replacement = await postDepositAddress(app, { body, key })
+      expect(replacement.status).toBe(200)
+      const second = await TestApp.json(
+        replacement,
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(second.address).not.toBe(first.address)
+      expect(second.recipient).toBe(first.recipient)
+      expect(second.refundAddress).toBe(first.refundAddress)
+      expect((await RoutesDepositAddresses.get(db, second.id))?.providerState).toMatchObject({
+        routePolicy: { maxAmount: '2', subsidyPayer: 'tempo' },
+      })
+      const reused = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(reused.id).toBe(second.id)
+      const replay = await TestApp.json(
+        await postDepositAddress(app, { body, idempotencyKey: firstKey, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(replay.id).toBe(first.id)
+      expect(await RoutesDepositAddresses.get(db, first.id)).toEqual(stored)
+      await RoutesPolicies.save(db, { policy, scope, version: 3 })
+      const restored = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(restored.id).toBe(first.id)
+      expect(await RoutesDepositAddresses.countByOrganization(db, key.orgId)).toBe(2)
+    },
+  )
+
+  test('keeps fixed-rate legacy Relay addresses separate from previous delivery terms', async () => {
+    const key = {
+      id: 'key_legacy_upgrade',
+      orgId: 'org_legacy_upgrade',
+      token: 'secret_legacy_upgrade',
+      scopes: ['routes:read', 'routes:write'],
+    }
+    const sibling = {
+      ...key,
+      id: 'key_legacy_upgrade_sibling',
+      token: 'secret_legacy_upgrade_sibling',
+    }
+    await enableRoutesSubsidy(key, 'active')
+    const scope = { orgId: key.orgId, environment: 'production' } as const
+    const inputs: RoutesProvider.createDepositAddress.Parameters[] = []
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const app = create({
+      auth: { keys: [key, sibling] },
+      defaultChainId: tempoMainnet.id,
+      metrics: Metrics.from({
+        count: (...args) => {
+          counts.push(args)
+        },
+        flush() {},
+        gauge() {},
+        histogram() {},
+      }),
+      providers: [
+        depositAddressProvider(`0x${'81'.repeat(20)}`, (input) => {
+          inputs.push(input)
+        }),
+      ],
+      routes: { depositSubsidyMaxAmount: '0.05' },
+    })
+    const body = {
+      ...depositAddressBody,
+      sourceChain: 'base',
+      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+      refundAddress: `0x${'82'.repeat(20)}`,
+      subsidize: true,
+    }
+    const idempotencyKey = nextDepositAddressKey()
+    const candidate = RoutesProvider.getDepositAddressCandidates({
+      catalog: TestRoutes.snapshot,
+      destinationChainId: tempoMainnet.id,
+      destinationToken: body.destinationToken,
+      providers,
+      sourceChain: body.sourceChain,
+      sourceToken: body.sourceToken,
+    })[0]?.candidate
+    if (!candidate) throw new Error('Expected a deposit-address candidate.')
+    const previous = await RoutesDepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: key.orgId,
+      providerOutputToken: candidate.destinationToken,
+      snapshot: {
+        address: `0x${'d4'.repeat(20)}`,
+        destinationChain: candidate.destinationChain,
+        destinationToken: candidate.destinationToken,
+        provider: { id: 'relay', name: 'Relay' },
+        recipient: body.recipient,
+        refundAddress: body.refundAddress,
+        sourceChain: candidate.sourceChain,
+        sourceToken: candidate.sourceToken,
+        subsidize: true,
+      },
+    })
+    const first = await TestApp.json(
+      await postDepositAddress(app, { body, key, idempotencyKey }),
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    const claim = await RoutesDepositAddresses.claim(db, {
+      id: first.id,
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      now: '2027-01-01T00:00:00.000Z',
+    })
+    if (!claim) throw new Error('Expected a claimed address.')
+    await RoutesDepositAddresses.completePoll(db, {
+      id: first.id,
+      lastPolledAt: '2027-01-01T00:00:10.000Z',
+      nextPollAt: '2027-01-01T00:01:10.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion,
+      providerRequestIds: claim.providerRequestIds,
+      providerState: claim.providerState,
+    })
+    const reused = await TestApp.json(
+      await postDepositAddress(app, { body, key: sibling }),
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    expect(reused.id).toBe(first.id)
+    expect(first.id).not.toBe(previous.id)
+    expect(await RoutesDepositAddresses.get(db, previous.id)).toEqual(previous)
+    expect(inputs.map((input) => input.subsidize)).toEqual([true])
+    expect(await RoutesPolicies.get(db, scope)).toBeUndefined()
+    const stored = await RoutesDepositAddresses.get(db, first.id)
+    expect(stored?.providerState).toMatchObject({
+      fixedRate: '1:1',
+      routePolicy: {
+        maxAmount: '0.05',
+        scope: { ...scope, apiKeyId: key.id },
+        subsidyPayer: 'enterprise',
+        versions: [0, 0],
+      },
+      routePolicyKey: '["[\\"enterprise\\",\\"0.050000\\"]","1:1"]',
+    })
+    const reservation = await db.kysely
+      .selectFrom('routes_idempotency_requests')
+      .select('matchHash')
+      .where('apiKeyId', '=', key.id)
+      .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
+      .executeTakeFirstOrThrow()
+    expect(reservation.matchHash).toBe(
+      Idempotency.inputHash({
+        destinationTokenKey: 'eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73',
+        environment: 'production',
+        orgId: key.orgId,
+        policyKey: '["[\\"enterprise\\",\\"0.050000\\"]","1:1"]',
+        providerId: 'relay',
+        recipient: body.recipient,
+        refundAddress: body.refundAddress,
+        sourceChainId: 'eip155:8453',
+        sourceTokenKey: 'eip155:8453/erc20:0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+        subsidize: true,
+      }),
+    )
+
+    // A new commitment may provision, but cannot adopt the same physical address returned by this provider.
+    await RoutesPolicies.save(db, {
+      scope,
+      version: 0,
+      policy: { access: null, subsidyEnabled: true, subsidyPayer: 'tempo', maxAmount: '0.05' },
+    })
+    const conflict = await postDepositAddress(app, { body, key })
+    expect(conflict.status).toBe(409)
+    await expect(conflict.json()).resolves.toMatchObject({
+      error: { code: 'route_policy_identity_conflict' },
+    })
+    expect(counts).toContainEqual([
+      'routes_policy_denial_count',
+      1,
+      { reason: 'route_policy_identity_conflict' },
+    ])
+    expect(inputs.map((input) => input.subsidize)).toEqual([true, true])
+
+    await RoutesPolicies.save(db, { scope, version: 1, policy: { access: [], suspended: true } })
+    const replay = await postDepositAddress(app, { body, key, idempotencyKey })
+    expect(replay.status).toBe(200)
+    await expect(replay.json()).resolves.toMatchObject({ id: first.id })
+    expect(
+      (
+        await app.request(`/v1/routes/deposit-addresses/${first.id}`, {
+          headers: { authorization: `Bearer ${key.token}` },
+        })
+      ).status,
+    ).toBe(200)
+    // The accepted provider checkpoint still conflicts; suspension blocks genuinely fresh instructions.
+    const retry = await postDepositAddress(app, { body, key })
+    expect(retry.status).toBe(409)
+    await expect(retry.json()).resolves.toMatchObject({
+      error: { code: 'route_policy_identity_conflict' },
+    })
+    expect(
+      (
+        await postDepositAddress(app, {
+          body: { ...body, refundAddress: `0x${'83'.repeat(20)}` },
+          key,
+        })
+      ).status,
+    ).toBe(403)
+    expect((await RoutesDepositAddresses.get(db, first.id))?.providerState).toEqual(
+      stored?.providerState,
+    )
+  })
+
+  test('selects a financially eligible deposit provider and reuses its pinned terms', async () => {
+    const key = {
+      id: 'key_deposit_financial_fallback',
+      orgId: 'org_deposit_financial_fallback',
+      scopes: ['routes:read', 'routes:write'],
+      token: 'secret_deposit_financial_fallback',
+    }
+    await Organizations.create(db, { id: key.orgId, name: 'Financial fallback' })
+    const route = {
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+      sourceChainId: 'eip155:8453',
+      sourceTokenId: 'usdc',
+    }
+    await RoutesCatalog.publish(db, {
+      ...TestRoutes.data,
+      routes: TestRoutes.data.routes.map((entry) =>
+        entry.providerId === 'rhino' &&
+        entry.sourceChainId === route.sourceChainId &&
+        entry.sourceTokenId === route.sourceTokenId &&
+        entry.destinationTokenId === route.destinationTokenId
+          ? { ...entry, capabilities: { depositAddress: true } }
+          : entry,
+      ),
+    })
+    try {
+      await RoutesPolicies.save(db, {
+        policy: {
+          access: null,
+          maxAmount: '0.04',
+          subsidyEnabled: true,
+          subsidyPayer: 'enterprise',
+          terms: [{ ...route, providerId: 'rhino', subsidyPayer: 'tempo' }],
+        },
+        scope: { environment: 'production', orgId: key.orgId },
+        version: 0,
+      })
+      const provisions: string[] = []
+      const app = create({
+        auth: { keys: [key] },
+        defaultChainId: tempoMainnet.id,
+        providers: ['relay', 'rhino'].map((id) =>
+          RoutesProvider.from({
+            ...depositAddressProvider(`0x${'86'.repeat(20)}`, () => {
+              provisions.push(id)
+            }),
+            id,
+            name: id,
+          }),
+        ),
+        routes: {
+          depositSubsidyAccount: `0x${'aa'.repeat(20)}`,
+          depositSubsidyMaxAmount: '0.05',
+        },
+      })
+      const body = {
+        ...depositAddressBody,
+        destinationToken: 'usdce',
+        refundAddress: `0x${'87'.repeat(20)}`,
+        sourceChain: 'base',
+        sourceToken: 'usdc',
+        subsidize: true,
+      }
+      const withoutSigner = create({
+        auth: { keys: [key] },
+        defaultChainId: tempoMainnet.id,
+        providers: ['relay', 'rhino'].map((id) =>
+          RoutesProvider.from({
+            ...depositAddressProvider(`0x${'86'.repeat(20)}`, () => {
+              provisions.push(id)
+            }),
+            id,
+            name: id,
+          }),
+        ),
+        routes: { depositSubsidyMaxAmount: '0.05' },
+      })
+      expect((await postDepositAddress(withoutSigner, { body, key })).status).toBe(403)
+      expect(provisions).toEqual([])
+      const response = await postDepositAddress(app, { body, key })
+      expect(response.status).toBe(200)
+      const first = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
+      expect(first.provider.id).toBe('rhino')
+      const repeated = await postDepositAddress(app, { body, key })
+      expect(repeated.status).toBe(200)
+      await expect(repeated.json()).resolves.toMatchObject({ id: first.id })
+      expect(provisions).toEqual(['rhino'])
+      expect((await RoutesDepositAddresses.get(db, first.id))?.providerState).toMatchObject({
+        routePolicy: { maxAmount: '0.04', subsidyPayer: 'tempo' },
+      })
+    } finally {
+      await TestRoutes.publish(db)
+    }
+  })
+
   test('rejects a missing policy, records its bounded reason, and releases the claim', async () => {
     await Organizations.upsert(db, {
       id: routesSubsidyDisabledWriter.orgId,
@@ -598,6 +963,7 @@ describe('POST /routes/deposit-addresses', () => {
       body,
       idempotencyKey,
       key: routesSubsidyDisabledWriter,
+      policy: false,
     })
 
     expect({ body: await rejected.json(), status: rejected.status }).toMatchInlineSnapshot(
@@ -609,7 +975,7 @@ describe('POST /routes/deposit-addresses', () => {
         "body": {
           "error": {
             "code": "routes_subsidy_not_enabled",
-            "message": "Routes subsidies are not enabled for this organization.",
+            "message": "Route subsidies are not enabled for this request. Contact Tempo to enable them, or use an API key from an organization with subsidies enabled.",
           },
           "requestId": Any<String>,
         },
@@ -620,10 +986,7 @@ describe('POST /routes/deposit-addresses', () => {
     expect(counts.find(([name]) => name === 'routes_subsidy_request_rejection_count')).toEqual([
       'routes_subsidy_request_rejection_count',
       1,
-      {
-        reason: 'routes_subsidy_not_enabled',
-        routes_environment: 'production',
-      },
+      { reason: 'routes_subsidy_not_enabled', routes_environment: 'production' },
     ])
 
     await enableRoutesSubsidy(routesSubsidyDisabledWriter, 'active')
@@ -663,7 +1026,7 @@ describe('POST /routes/deposit-addresses', () => {
           "body": {
             "error": {
               "code": "billing_required",
-              "message": "Billing required.",
+              "message": "Active billing is required for enterprise-paid route subsidies. Set up billing for this organization, then retry.",
             },
             "requestId": Any<String>,
           },
@@ -708,6 +1071,365 @@ describe('POST /routes/deposit-addresses', () => {
     expect({ body: await replay.json(), status: replay.status }).toEqual({ body: firstBody, status: 200 }) // prettier-ignore
   })
 
+  test.each(['99000000', '100000001'])(
+    'preserves the claim after Relay provisions invalid output %s',
+    async (amount) => {
+      const key = {
+        id: `key_rejected_relay_${amount}`,
+        orgId: `org_rejected_relay_${amount}`,
+        scopes: ['routes:write'],
+        token: `secret_rejected_relay_${amount}`,
+      }
+      await enableRoutesSubsidy(key, 'active')
+      let provisions = 0
+      const server = await TestRelay.createServer((_request, response) => {
+        provisions++
+        response.writeHead(200, { 'content-type': 'application/json' })
+        response.end(
+          JSON.stringify({
+            details: {
+              currencyIn: { amount: '100000000' },
+              currencyOut: { amount, minimumAmount: '98000000' },
+              isFixedRate: true,
+            },
+            steps: [
+              { depositAddress: depositAddressBody.refundAddress, requestId: 'rejected-rate' },
+            ],
+          }),
+        )
+      })
+      try {
+        const app = create({
+          auth: { keys: [key] },
+          defaultChainId: tempoMainnet.id,
+          providers: [Relay.relay({ baseUrl: server.url, subsidies: { maxAmount: '100' } })],
+          routes: { depositSubsidyMaxAmount: '5' },
+        })
+        const body = { ...depositAddressBody, subsidize: true }
+        const idempotencyKey = nextDepositAddressKey()
+        const first = await postDepositAddress(app, { body, idempotencyKey, key })
+        const retry = await postDepositAddress(app, { body, idempotencyKey, key })
+        const sibling = await postDepositAddress(app, { body, key })
+        expect({ provisions, statuses: [first.status, retry.status, sibling.status] })
+          .toMatchInlineSnapshot(`
+            {
+              "provisions": 1,
+              "statuses": [
+                502,
+                409,
+                409,
+              ],
+            }
+          `)
+        await expect(
+          db.kysely
+            .selectFrom('routes_idempotency_requests')
+            .select(['irrevocable', 'status'])
+            .where('apiKeyId', '=', key.id)
+            .where('keyHash', '=', Idempotency.inputHash(idempotencyKey))
+            .executeTakeFirstOrThrow(),
+        ).resolves.toEqual({ irrevocable: true, status: 'pending' })
+      } finally {
+        await server.closeAsync()
+      }
+    },
+  )
+
+  test('provisions subsidized Solana USDC to Tempo USDC.e at a fixed rate', async () => {
+    const key = {
+      id: 'key_solana_usdc_fixed_rate',
+      orgId: 'org_solana_usdc_fixed_rate',
+      scopes: ['routes:write'],
+      token: 'secret_solana_usdc_fixed_rate',
+    }
+    await grantRoutes(key)
+    await RoutesPolicies.save(db, {
+      policy: {
+        access: null,
+        maxAmount: '0.05',
+        subsidyEnabled: true,
+        subsidyPayer: 'tempo',
+      },
+      scope: { environment: 'production', orgId: key.orgId },
+      version: 1,
+    })
+    const requests: Record<string, unknown>[] = []
+    const server = await TestRelay.createServer(async (request, response) => {
+      request.setEncoding('utf8')
+      let payload = ''
+      for await (const chunk of request) payload += chunk
+      requests.push(JSON.parse(payload))
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          details: {
+            currencyIn: { amount: '100000000' },
+            currencyOut: { amount: '100000000', minimumAmount: '98000000' },
+            isFixedRate: false,
+          },
+          steps: [
+            {
+              depositAddress: 'So11111111111111111111111111111111111111112',
+              requestId: 'solana-usdc',
+            },
+          ],
+        }),
+      )
+    })
+    try {
+      const app = create({
+        auth: { keys: [key] },
+        defaultChainId: tempoMainnet.id,
+        providers: [Relay.relay({ baseUrl: server.url, subsidies: { maxAmount: '100' } })],
+        routes: { depositSubsidyMaxAmount: '5' },
+      })
+      const body = {
+        ...depositAddressBody,
+        destinationToken: 'USDC.e',
+        refundAddress: 'So11111111111111111111111111111111111111112',
+        sourceChain: 'solana',
+        sourceToken: 'USDC',
+        subsidize: true,
+      }
+      const first = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      const reused = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(reused.id).toBe(first.id)
+      expect(requests).toEqual([
+        expect.objectContaining({
+          amount: '100000000',
+          destinationChainId: 4217,
+          destinationCurrency: '0x20c000000000000000000000b9537d11c60e8b50',
+          fixedRate: '1:1',
+          maxSubsidizationAmount: '50000',
+          originChainId: 792703809,
+          originCurrency: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+          refundTo: body.refundAddress,
+          subsidizeFees: true,
+          tradeType: 'EXACT_INPUT',
+          useDepositAddress: true,
+          user: body.refundAddress,
+        }),
+      ])
+      expect(first).toMatchObject({
+        address: 'So11111111111111111111111111111111111111112',
+        destinationAmount: { baseUnits: '100000000' },
+        provider: { id: 'relay' },
+        sourceChain: { kind: 'solana' },
+        subsidize: true,
+      })
+      expect((await RoutesDepositAddresses.get(db, first.id))?.providerState).toMatchObject({
+        fixedRate: '1:1',
+        routePolicy: { maxAmount: '0.05', subsidyPayer: 'tempo' },
+      })
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test.each([
+    { name: 'organization', organization: '0.05', platform: '1' },
+    { name: 'platform', organization: '1', platform: '0.05' },
+    { name: 'missing_platform', organization: '1', platform: undefined },
+  ])('caps legacy Relay sponsorship by $name', async (scenario) => {
+    const key = {
+      id: `key_legacy_cap_${scenario.name}`,
+      orgId: `org_legacy_cap_${scenario.name}`,
+      scopes: ['routes:write'],
+      token: `secret_legacy_cap_${scenario.name}`,
+    }
+    await enableRoutesSubsidy(key, 'active')
+    await RoutesSubsidies.upsertOrganization(db, {
+      frequency: 'tx',
+      maxAmount: scenario.organization,
+      orgId: key.orgId,
+    })
+    const requests: Record<string, unknown>[] = []
+    const server = await TestRelay.createServer(async (request, response) => {
+      request.setEncoding('utf8')
+      let payload = ''
+      for await (const chunk of request) payload += chunk
+      requests.push(JSON.parse(payload))
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          details: {
+            currencyIn: { amount: '100000000' },
+            currencyOut: { amount: '100000000', minimumAmount: '98000000' },
+            isFixedRate: true,
+          },
+          steps: [
+            {
+              depositAddress: Hash.keccak256(Hex.fromString(`${key.id}_${requests.length}`)).slice(
+                0,
+                42,
+              ),
+              requestId: `capped-rate-${requests.length}`,
+            },
+          ],
+        }),
+      )
+    })
+    try {
+      const options = {
+        auth: { keys: [key] },
+        defaultChainId: tempoMainnet.id,
+        providers: [Relay.relay({ baseUrl: server.url, subsidies: { maxAmount: '100' } })],
+      }
+      const app = create({
+        ...options,
+        routes: { depositSubsidyMaxAmount: scenario.platform },
+      })
+      const body = {
+        ...depositAddressBody,
+        refundAddress: `0x${'93'.repeat(20)}`,
+        sourceChain: 'base',
+        sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+        subsidize: true,
+      }
+      const response = await postDepositAddress(app, { body, key })
+      if (scenario.platform === undefined) {
+        expect(response.status).toBe(404)
+        expect(requests).toEqual([])
+        return
+      }
+      expect(response.status).toBe(200)
+      const first = await TestApp.json(response, Routes.schema.createRoutesDepositAddress.Response)
+      const stored = await RoutesDepositAddresses.get(db, first.id)
+      const reused = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(reused.id).toBe(first.id)
+      expect(requests).toHaveLength(1)
+      expect(requests[0]).toMatchObject({
+        fixedRate: '1:1',
+        maxSubsidizationAmount: '50000',
+        subsidizeFees: true,
+      })
+
+      if (scenario.name === 'organization')
+        await RoutesSubsidies.upsertOrganization(db, {
+          frequency: 'tx',
+          maxAmount: '0.025',
+          orgId: key.orgId,
+        })
+      const capped = create({
+        ...options,
+        routes: {
+          depositSubsidyMaxAmount: scenario.name === 'platform' ? '0.025' : scenario.platform,
+        },
+      })
+      const replacement = await TestApp.json(
+        await postDepositAddress(capped, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(replacement.id).not.toBe(first.id)
+      expect(requests).toHaveLength(2)
+      expect(requests[1]).toMatchObject({
+        fixedRate: '1:1',
+        maxSubsidizationAmount: '25000',
+        subsidizeFees: true,
+      })
+      expect(await RoutesDepositAddresses.get(db, first.id)).toEqual(stored)
+      if (scenario.name === 'organization')
+        await RoutesSubsidies.upsertOrganization(db, {
+          frequency: 'tx',
+          maxAmount: scenario.organization,
+          orgId: key.orgId,
+        })
+      const restored = await TestApp.json(
+        await postDepositAddress(app, { body, key }),
+        Routes.schema.createRoutesDepositAddress.Response,
+      )
+      expect(restored.id).toBe(first.id)
+      expect(requests).toHaveLength(2)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test.each(['AMOUNT_TOO_LOW', 'NO_ROUTE'])(
+    'releases subsidized claims after a definitive Relay rejection %s',
+    async (errorCode) => {
+      const key = {
+        id: `key_relay_rejection_${errorCode}`,
+        orgId: `org_relay_rejection_${errorCode}`,
+        scopes: ['routes:write'],
+        token: `secret_relay_rejection_${errorCode}`,
+      }
+      await enableRoutesSubsidy(key, 'active')
+      let requests = 0
+      const server = await TestRelay.createServer((request, response) => {
+        request.resume()
+        requests += 1
+        response.writeHead(requests < 4 ? 400 : 200, { 'content-type': 'application/json' })
+        response.end(
+          JSON.stringify(
+            requests < 4
+              ? { errorCode }
+              : {
+                  details: {
+                    currencyIn: { amount: '100000000' },
+                    currencyOut: { amount: '100000000', minimumAmount: '98000000' },
+                    isFixedRate: true,
+                  },
+                  steps: [
+                    {
+                      depositAddress: Hash.keccak256(Hex.fromString(key.id)).slice(0, 42),
+                      requestId: `recovered-${errorCode}`,
+                    },
+                  ],
+                },
+          ),
+        )
+      })
+      try {
+        const app = create({
+          auth: { keys: [key] },
+          defaultChainId: tempoMainnet.id,
+          providers: [Relay.relay({ baseUrl: server.url, subsidies: { maxAmount: '5' } })],
+          routes: { depositSubsidyMaxAmount: '5' },
+        })
+        const body = {
+          ...depositAddressBody,
+          refundAddress: `0x${'95'.repeat(20)}`,
+          sourceChain: 'base',
+          sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+          subsidize: true,
+        }
+        const idempotencyKey = nextDepositAddressKey()
+        for (const requestKey of [idempotencyKey, idempotencyKey, nextDepositAddressKey()]) {
+          const response = await postDepositAddress(app, { body, idempotencyKey: requestKey, key })
+          expect(response.status).toBe(errorCode === 'AMOUNT_TOO_LOW' ? 400 : 404)
+          expect((await response.json()).error.code).toBe(
+            errorCode === 'AMOUNT_TOO_LOW' ? 'amount_too_low' : 'quote_not_available',
+          )
+          expect(
+            await db.kysely
+              .selectFrom('routes_idempotency_requests')
+              .select(['irrevocable', 'status'])
+              .where('apiKeyId', '=', key.id)
+              .execute(),
+          ).toMatchInlineSnapshot(`[]`)
+        }
+        const recovered = await postDepositAddress(app, { body, idempotencyKey, key })
+        expect(recovered.status).toMatchInlineSnapshot(`200`)
+        expect(requests).toMatchInlineSnapshot(`4`)
+        expect(
+          await TestApp.json(recovered, Routes.schema.createRoutesDepositAddress.Response),
+        ).toMatchObject({ provider: { id: 'relay' }, subsidize: true })
+      } finally {
+        await server.closeAsync()
+      }
+    },
+  )
+
   test('preserves a subsidized claim after an ambiguous provider failure', async () => {
     await enableRoutesSubsidy(routesSubsidyReplayWriter, 'active')
     const app = transfersApp({
@@ -745,7 +1467,7 @@ describe('POST /routes/deposit-addresses', () => {
     ).resolves.toEqual({ irrevocable: true, status: 'pending' })
   })
 
-  test('resumes an expired provisioned subsidy without replaying stale quote terms', async () => {
+  test('resumes a legacy provisioned subsidy after policy adoption without replaying stale quote terms', async () => {
     await Organizations.upsert(db, {
       id: routesSubsidyResumeWriter.orgId,
       name: 'Routes subsidy resume',
@@ -813,11 +1535,19 @@ describe('POST /routes/deposit-addresses', () => {
       .where('keyHash', '=', identity.keyHash)
       .execute()
 
-    const response = await postDepositAddress(transfersApp({ metrics, providers: [] }), {
-      body,
-      idempotencyKey,
-      key: routesSubsidyResumeWriter,
+    await RoutesPolicies.save(db, {
+      scope: { orgId: routesSubsidyResumeWriter.orgId, environment: 'production' },
+      version: 0,
+      policy: { access: [], suspended: true, subsidyEnabled: false },
     })
+    const response = await postDepositAddress(
+      transfersApp({ metrics, providers: [], routes: { depositSubsidyAccount: undefined } }),
+      {
+        body,
+        idempotencyKey,
+        key: routesSubsidyResumeWriter,
+      },
+    )
 
     expect(response.status).toBe(200)
     const responseBody = await TestApp.json(
@@ -826,6 +1556,9 @@ describe('POST /routes/deposit-addresses', () => {
     )
     expect(responseBody.subsidize).toBe(true)
     expect(responseBody).not.toHaveProperty('quote')
+    const recovered = await RoutesDepositAddresses.get(db, responseBody.id)
+    expect(recovered).toBeDefined()
+    expect(recovered!.providerState).toBeNull()
     expect(
       histograms.filter(
         ([name]) =>
@@ -836,6 +1569,95 @@ describe('POST /routes/deposit-addresses', () => {
     ).toEqual([])
   })
 
+  test('waits for a settler before persisting a resumed non-Relay subsidy', async () => {
+    await Organizations.upsert(db, {
+      id: routesSubsidyResumeWriter.orgId,
+      name: 'Routes subsidy resume',
+    })
+    const body = {
+      ...depositAddressBody,
+      recipient: `0x${'7b'.repeat(20)}`,
+      subsidize: true,
+    }
+    const idempotencyKey = nextDepositAddressKey()
+    const identity = {
+      apiKeyId: routesSubsidyResumeWriter.id,
+      keyHash: Idempotency.inputHash(idempotencyKey),
+      requestHash: Idempotency.inputHash({
+        body,
+        endpoint: 'POST /v1/routes/deposit-addresses',
+      }),
+    }
+    const claim = await RoutesIdempotencyTable.claim(db, {
+      ...identity,
+      irrevocable: true,
+      operation: RoutesIdempotencyTable.operations.depositAddress,
+      orgId: routesSubsidyResumeWriter.orgId,
+      ttlMs: 60_000,
+    })
+    if (claim.type !== 'claimed') throw new Error('Expected a fresh idempotency claim.')
+    const snapshot = TestRoutes.depositAddressSnapshot({
+      address: 'TG6rrQgTkf3e85cYzqtD2q8fYuJDdM99Rx',
+      provider: { id: 'rhino', name: 'Rhino' },
+      recipient: body.recipient,
+      subsidize: true,
+    })
+    await RoutesIdempotencyTable.checkpoint(db, {
+      apiKeyId: identity.apiKeyId,
+      createdAt: claim.createdAt,
+      keyHash: identity.keyHash,
+      replayTtlMs: 86_400_000,
+      response: JSON.stringify({
+        candidate: {
+          destinationChain: snapshot.destinationChain,
+          destinationToken: snapshot.destinationToken,
+          sourceChain: snapshot.sourceChain,
+          sourceToken: snapshot.sourceToken,
+        },
+        provider: snapshot.provider,
+        recipient: snapshot.recipient,
+        refundAddress: snapshot.refundAddress,
+        result: {
+          address: snapshot.address,
+          correlation: { requestId: 'rhino_resume_request' },
+          destinationAmount: '1000000',
+          destinationAmountMin: '1000000',
+          fees: [],
+          sampledAt: '2026-08-04T00:00:00.000Z',
+        },
+      }),
+    })
+
+    const count = await RoutesDepositAddresses.countByOrganization(
+      db,
+      routesSubsidyResumeWriter.orgId,
+    )
+    const unavailable = await postDepositAddress(
+      transfersApp({ providers: [], routes: { depositSubsidyAccount: undefined } }),
+      { body, idempotencyKey, key: routesSubsidyResumeWriter },
+    )
+    expect(await unavailable.json()).toMatchObject({
+      error: { code: 'deposit_address_not_available' },
+    })
+    expect(unavailable.status).toBe(404)
+    expect(
+      await RoutesDepositAddresses.countByOrganization(db, routesSubsidyResumeWriter.orgId),
+    ).toBe(count)
+
+    const resumed = await postDepositAddress(transfersApp({ providers: [] }), {
+      body,
+      idempotencyKey,
+      key: routesSubsidyResumeWriter,
+    })
+    expect(resumed.status).toBe(200)
+    expect(
+      await TestApp.json(resumed, Routes.schema.createRoutesDepositAddress.Response),
+    ).toMatchObject({
+      provider: { id: 'rhino' },
+      subsidize: true,
+    })
+  })
+
   test('creates a reusable address and persists private provider correlation', async () => {
     await Organizations.upsert(db, { id: routesWriter.orgId, name: 'Routes' })
     let seen: RoutesProvider.createDepositAddress.Parameters | undefined
@@ -1052,6 +1874,7 @@ describe('POST /routes/deposit-addresses', () => {
 
   test('stores subsidized addresses as a separate reusable identity', async () => {
     await enableRoutesSubsidy(routesSubsidyWriter, 'active')
+    await grantRoutes(routesSubsidyWriter)
     const inputs: RoutesProvider.createDepositAddress.Parameters[] = []
     const app = transfersApp({
       providers: [
@@ -1059,7 +1882,10 @@ describe('POST /routes/deposit-addresses', () => {
           inputs.push(input)
           return {
             address: inputs.length === 1 ? `0x${'31'.repeat(20)}` : `0x${'32'.repeat(20)}`,
-            correlation: { requestId: `relay_request_${inputs.length}` },
+            correlation: {
+              ...(input.subsidize ? { fixedRate: '1:1' as const } : {}),
+              requestId: `relay_request_${inputs.length}`,
+            },
             destinationAmount: '1000000',
             destinationAmountMin: '1000000',
             fees: [],
@@ -1085,26 +1911,45 @@ describe('POST /routes/deposit-addresses', () => {
       }),
       Routes.schema.createRoutesDepositAddress.Response,
     )
+    const subsidizedRecord = await RoutesDepositAddresses.get(db, subsidized.id)
 
     expect({
       distinct: standard.id !== subsidized.id,
-      inputs: inputs.map(({ subsidize }) => subsidize),
+      inputs: inputs.map(({ subsidize, subsidyMaxAmount }) => ({ subsidize, subsidyMaxAmount })),
       standard: standard.subsidize,
       subsidized: subsidized.subsidize,
     }).toMatchInlineSnapshot(`
       {
         "distinct": true,
         "inputs": [
-          false,
-          true,
+          {
+            "subsidize": false,
+            "subsidyMaxAmount": undefined,
+          },
+          {
+            "subsidize": true,
+            "subsidyMaxAmount": "5",
+          },
         ],
         "standard": false,
         "subsidized": true,
       }
     `)
+    expect(subsidizedRecord?.providerState).toHaveProperty('routePolicy')
+    expect(subsidizedRecord?.providerState).toHaveProperty('routePolicyKey')
+    expect(subsidizedRecord?.providerState).toHaveProperty('fixedRate', '1:1')
+    const reused = await TestApp.json(
+      await postDepositAddress(app, {
+        body: { ...body, subsidize: true },
+        key: routesSubsidyWriter,
+      }),
+      Routes.schema.createRoutesDepositAddress.Response,
+    )
+    expect(reused.id).toBe(subsidized.id)
+    expect(inputs).toHaveLength(2)
   })
 
-  test('reuses a subsidized address across API keys in one organization', async () => {
+  test('checks policy before reusing a subsidized address under a fresh API key', async () => {
     await enableRoutesSubsidy(routesSubsidyWriter, 'active')
     let calls = 0
     const app = transfersApp({
@@ -1125,12 +1970,15 @@ describe('POST /routes/deposit-addresses', () => {
       await postDepositAddress(app, { body, key: routesSubsidyWriter }),
       Routes.schema.createRoutesDepositAddress.Response,
     )
-    const second = await TestApp.json(
-      await postDepositAddress(app, { body, key: routesSubsidyWriterSecond }),
-      Routes.schema.createRoutesDepositAddress.Response,
-    )
-
-    expect({ calls, reused: first.id === second.id }).toEqual({ calls: 1, reused: true })
+    await RoutesSubsidies.removeOrganization(db, routesSubsidyWriter.orgId)
+    const second = await postDepositAddress(app, { body, key: routesSubsidyWriterSecond })
+
+    expect(first.id).toBeDefined()
+    expect({ body: await second.json(), calls, status: second.status }).toMatchObject({
+      body: { error: { code: 'routes_subsidy_not_enabled' } },
+      calls: 1,
+      status: 403,
+    })
   })
 
   test('normalizes EVM accounts before provisioning and matching', async () => {
@@ -1253,6 +2101,79 @@ describe('POST /routes/deposit-addresses', () => {
     expect(calls).toBe(0)
   })
 
+  test('returns 409 on initial completion and retry when different terms win during provisioning', async () => {
+    const key: TestApp.kvStore.Key = {
+      id: 'key_policy_insert_race',
+      orgId: 'org_policy_insert_race',
+      scopes: ['routes:read', 'routes:write'],
+      token: 'secret_policy_insert_race',
+    }
+    await grantRoutes(key)
+    const scope = { environment: 'production', orgId: key.orgId } as const
+    const policy = {
+      access: null,
+      maxAmount: '0.04',
+      subsidyEnabled: true,
+      subsidyPayer: 'tempo',
+    } as const
+    await RoutesPolicies.save(db, { policy, scope, version: 1 })
+    const entered = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    let provisions = 0
+    const app = create({
+      auth: { keys: [key] },
+      defaultChainId: tempoMainnet.id,
+      providers: [
+        depositAddressProvider(`0x${'84'.repeat(20)}`, async () => {
+          provisions++
+          if (provisions === 1) {
+            entered.resolve()
+            await release.promise
+          }
+        }),
+      ],
+      routes: { depositSubsidyMaxAmount: '0.05' },
+    })
+    const body = {
+      ...depositAddressBody,
+      refundAddress: `0x${'85'.repeat(20)}`,
+      sourceChain: 'base',
+      sourceToken: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+      subsidize: true,
+    }
+    const idempotencyKey = nextDepositAddressKey()
+    const pending = postDepositAddress(app, { body, idempotencyKey, key })
+    await entered.promise
+    try {
+      await RoutesPolicies.save(db, {
+        policy: { ...policy, maxAmount: '0.05' },
+        scope,
+        version: 2,
+      })
+      expect((await postDepositAddress(app, { body, key })).status).toBe(200)
+    } finally {
+      release.resolve()
+    }
+    for (const response of [
+      await pending,
+      await postDepositAddress(app, { body, idempotencyKey, key }),
+    ]) {
+      expect(response.status).toBe(409)
+      await expect(response.json()).resolves.toMatchObject({
+        error: { code: 'route_policy_identity_conflict' },
+      })
+    }
+    expect(provisions).toBe(2)
+    expect(await RoutesDepositAddresses.countByOrganization(db, key.orgId)).toBe(1)
+    expect(
+      await db.kysely
+        .selectFrom('routes_deposit_addresses')
+        .select('providerState')
+        .where('orgId', '=', key.orgId)
+        .executeTakeFirstOrThrow(),
+    ).toMatchObject({ providerState: { routePolicy: { maxAmount: '0.05' } } })
+  })
+
   test('retains the provider checkpoint when address persistence fails', async () => {
     const address = 'TKJebW6SdoJhgkKU13BeKCbrMzT6HeQhJ6'
     const body = { ...depositAddressBody, recipient: `0x${'66'.repeat(20)}` }
@@ -2829,19 +3750,22 @@ function nextDepositAddressKey() {
   return `routes_deposit_address_${depositAddressIdempotencySequence++}`
 }
 
-function postDepositAddress(
+async function postDepositAddress(
   app: ReturnType<typeof create>,
   options: {
     body?: unknown
     headers?: Record<string, string> | undefined
     idempotencyKey?: string | undefined
-    key?: { token: string } | undefined
+    key?: TestApp.kvStore.Key | undefined
+    policy?: boolean | undefined
   } = {},
 ) {
+  const key = options.key ?? routesWriter
+  if (options.policy === true && options.headers === undefined) await grantRoutes(key)
   return app.request('/v1/routes/deposit-addresses', {
     body: JSON.stringify(options.body ?? depositAddressBody),
     headers: options.headers ?? {
-      authorization: `Bearer ${(options.key ?? routesWriter).token}`,
+      authorization: `Bearer ${key.token}`,
       'content-type': 'application/json',
       'idempotency-key': options.idempotencyKey ?? nextDepositAddressKey(),
     },
@@ -2870,6 +3794,9 @@ function depositAddressProvider(
       address,
       correlation: {
         checkEndpoint: '/intents/status/v3?requestId=relay_request_1',
+        ...(input.subsidize && input.candidate.provider.id === 'relay'
+          ? { fixedRate: '1:1' as const }
+          : {}),
         requestId: 'relay_request_1',
       },
       destinationAmount: '1000000',
@@ -3078,6 +4005,11 @@ const routesSubsidyRaceWriter = {
 function transfersApp(options: TestApp.create.Options = {}) {
   return create({
     ...options,
+    routes: {
+      depositSubsidyAccount: `0x${'aa'.repeat(20)}`,
+      depositSubsidyMaxAmount: '5',
+      ...options.routes,
+    },
     auth: {
       keys: [
         TestApp.key,
@@ -3136,6 +4068,18 @@ function as(key: { token: string }) {
   return { headers: { authorization: `Bearer ${key.token}` } } as const
 }
 
+async function grantRoutes(key: TestApp.kvStore.Key) {
+  await Organizations.upsert(db, { id: key.orgId, name: key.orgId })
+  const scope = { environment: 'production' as const, orgId: key.orgId }
+  const current = await RoutesPolicies.get(db, scope)
+  if (current?.policy.access === null) return
+  await RoutesPolicies.save(db, {
+    policy: { ...current?.policy, access: null },
+    scope,
+    version: current?.version ?? 0,
+  })
+}
+
 let seedDepositAddressSecond = 0
 
 function seedDepositAddress(input: Partial<RoutesDepositAddress.create.Input> = {}) {