tapimo 0.2.0 → 0.4.0

package/src/apps/data/routes/funding.ts

@@ -0,0 +1,698 @@
+import { Hono } from 'hono'
+import * as z from 'zod/mini'
+
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as FundingRoutes from '../../../internal/FundingRoutes.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+
+/** Zod schemas owned by the funding routes resource. */
+export namespace schema {
+  /** Source or destination chain reference. */
+  export const Chain = Schema.describe(
+    z.object({
+      addressFormat: z
+        .enum(['evm', 'solana', 'tron'])
+        .check(
+          z.describe('Address family used by accounts and token identifiers on this chain.'),
+          z.meta({ examples: ['evm'] }),
+        ),
+      id: z
+        .string()
+        .check(
+          z.describe(
+            'Stable chain id, preferably CAIP-2 when one exists. Funding spans non-EVM chains, so ids are strings, unlike numeric `chainId` params elsewhere.',
+          ),
+          z.meta({ examples: ['eip155:8453'] }),
+        ),
+      kind: z
+        .enum(['evm', 'solana', 'tron'])
+        .check(
+          z.describe('Chain execution family used for provider routing.'),
+          z.meta({ examples: ['evm'] }),
+        ),
+      name: z
+        .string()
+        .check(z.describe('Human-readable chain name.'), z.meta({ examples: ['Base'] })),
+      providerIds: z
+        .optional(z.record(z.string(), z.string()))
+        .check(
+          z.describe('Provider-specific chain ids Tempo uses when querying route providers.'),
+          z.meta({ examples: [{ across: '8453', relay: '8453' }] }),
+        ),
+    }),
+    'A normalized chain reference for funding routes.',
+  )
+
+  /** Source or destination token reference. */
+  export const Token = Schema.describe(
+    z.object({
+      address: z
+        .string()
+        .check(
+          z.describe('Contract address, mint, or issuer address on the token chain.'),
+          z.meta({ examples: ['0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] }),
+        ),
+      decimals: z
+        .number()
+        .check(
+          z.int(),
+          z.gte(0),
+          z.describe('Number of decimal places this token uses.'),
+          z.meta({ examples: [6] }),
+        ),
+      metadata: z
+        .record(z.string(), z.string())
+        .check(
+          z.describe('Curated display or lookup metadata for this token.'),
+          z.meta({ examples: [{ coingeckoId: 'usd-coin' }] }),
+        ),
+      name: z
+        .string()
+        .check(z.describe('Human-readable token name.'), z.meta({ examples: ['USD Coin'] })),
+      standard: z
+        .string()
+        .check(z.describe('Token standard on the token chain.'), z.meta({ examples: ['ERC-20'] })),
+      symbol: z
+        .string()
+        .check(z.describe('Short token ticker symbol.'), z.meta({ examples: ['USDC'] })),
+      tokenKey: z.string().check(
+        z.describe('Stable Tempo token key scoped to the token chain.'),
+        z.meta({
+          examples: ['eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'],
+        }),
+      ),
+      verified: z
+        .boolean()
+        .check(
+          z.describe('Whether Tempo recognizes this token in its funding route inventory.'),
+          z.meta({ examples: [true] }),
+        ),
+    }),
+    'A normalized token reference for funding routes.',
+  )
+
+  /** Source amount echoed by a funding route response. */
+  export const TokenAmount = Schema.describe(
+    z.object({
+      amount: Schema.DecimalString.check(
+        z.describe("The requested source amount in the token's smallest unit."),
+      ),
+      formatted: z
+        .string()
+        .check(
+          z.describe(
+            'The same amount in human-readable decimal form, using the source token’s `decimals`.',
+          ),
+          z.meta({ examples: ['1'] }),
+        ),
+      usd: z
+        .nullable(z.string())
+        .check(
+          z.describe('USD estimate for the requested source amount, when available.'),
+          z.meta({ examples: ['1.00'] }),
+        ),
+    }),
+    'The requested source amount in provider-safe base units and display form.',
+  )
+
+  /** Provider summary embedded in a route candidate. */
+  export const ProviderRef = Schema.describe(
+    z.object({
+      id: z.string().check(z.describe('Stable provider id.'), z.meta({ examples: ['across'] })),
+      kind: z
+        .string()
+        .check(
+          z.describe('Provider category, such as an intent bridge, solver network, or aggregator.'),
+          z.meta({ examples: ['intentBridge'] }),
+        ),
+      name: z
+        .string()
+        .check(z.describe('Human-readable provider name.'), z.meta({ examples: ['Across'] })),
+      requiresApiKey: z
+        .boolean()
+        .check(
+          z.describe('Whether Tempo needs provider credentials to query or use this provider.'),
+          z.meta({ examples: [true] }),
+        ),
+    }),
+    'Provider metadata embedded in a route candidate.',
+  )
+
+  /** Route quality signals exposed directly instead of implied by list order. */
+  export const Quality = Schema.describe(
+    z.object({
+      availableVolumeUsd: z
+        .nullable(z.string())
+        .check(
+          z.describe('Available USD capacity, when available.'),
+          z.meta({ examples: ['1114274.43'] }),
+        ),
+      estimatedSeconds: z
+        .nullable(z.number().check(z.int(), z.nonnegative()))
+        .check(
+          z.describe('Estimated settlement time in seconds, when known.'),
+          z.meta({ examples: [2] }),
+        ),
+      feeBps: z
+        .nullable(z.number().check(z.int(), z.nonnegative()))
+        .check(
+          z.describe('Estimated fee in basis points, when known.'),
+          z.meta({ examples: [109] }),
+        ),
+      historicalVolumeUsd24h: z
+        .nullable(z.string())
+        .check(
+          z.describe('24h routed volume in USD, when available.'),
+          z.meta({ examples: ['250000.00'] }),
+        ),
+      instantVolumeUsd: z
+        .nullable(z.string())
+        .check(
+          z.describe('Instant USD capacity, when available.'),
+          z.meta({ examples: ['12453.94'] }),
+        ),
+      liquiditySource: z
+        .string()
+        .check(
+          z.describe('Where the liquidity or support signal came from.'),
+          z.meta({ examples: ['staticInventory'] }),
+        ),
+      score: z
+        .nullable(z.number().check(z.int(), z.gte(0), z.lte(100)))
+        .check(
+          z.describe('Explainable route score from 0 to 100, when enough signals are available.'),
+          z.meta({ examples: [91] }),
+        ),
+      sourceDetail: z
+        .nullable(z.string())
+        .check(
+          z.describe('Provider-specific source or endpoint detail for the quality signal.'),
+          z.meta({ examples: ['providerEndpoint'] }),
+        ),
+      tier: z
+        .enum(['liquid', 'thin', 'unknown', 'unavailable', 'error'])
+        .check(
+          z.describe('Machine-readable route quality tier.'),
+          z.meta({ examples: ['unknown'] }),
+        ),
+    }),
+    'Machine-readable liquidity, fee, and source signals for a route candidate.',
+  )
+
+  /** Provider-derived quote data for a route candidate. */
+  export const RouteQuote = Schema.describe(
+    z.object({
+      expiresAt: z
+        .nullable(z.iso.datetime())
+        .check(
+          z.describe('Provider quote expiry timestamp.'),
+          z.meta({ examples: ['2026-01-01T00:00:30Z'] }),
+        ),
+      inputAmount: Schema.DecimalString.check(
+        z.describe('Source amount sent to the provider in base units.'),
+        z.meta({ examples: ['1000000'] }),
+      ),
+      limits: z
+        .nullable(
+          z.object({
+            instantSourceAmount: z
+              .nullable(Schema.DecimalString)
+              .check(
+                z.describe('Provider-reported instant source amount capacity.'),
+                z.meta({ examples: ['12453940000'] }),
+              ),
+            maxSourceAmount: z
+              .nullable(Schema.DecimalString)
+              .check(
+                z.describe('Provider-reported maximum source amount.'),
+                z.meta({ examples: ['1114274433200'] }),
+              ),
+            minSourceAmount: z
+              .nullable(Schema.DecimalString)
+              .check(
+                z.describe('Provider-reported minimum source amount.'),
+                z.meta({ examples: ['500063'] }),
+              ),
+          }),
+        )
+        .check(z.describe('Provider limits expressed in source base units.')),
+      minimumOutputAmount: z
+        .nullable(Schema.DecimalString)
+        .check(
+          z.describe('Slippage-adjusted minimum destination amount in base units.'),
+          z.meta({ examples: ['988000'] }),
+        ),
+      outputAmount: z
+        .nullable(Schema.DecimalString)
+        .check(
+          z.describe('Expected destination amount in base units.'),
+          z.meta({ examples: ['989102'] }),
+        ),
+      outputAmountFormatted: z
+        .nullable(z.string())
+        .check(
+          z.describe('Expected destination amount rendered with destination token decimals.'),
+          z.meta({ examples: ['0.989102'] }),
+        ),
+      sampledAt: z.iso
+        .datetime()
+        .check(
+          z.describe('Timestamp for the live quote or route probe.'),
+          z.meta({ examples: ['2026-01-01T00:00:00Z'] }),
+        ),
+    }),
+    'Provider-derived quote, limit, and freshness data for a route candidate.',
+  )
+
+  /** Static or live funding route candidate. */
+  export const RouteCandidate = Schema.describe(
+    z.object({
+      destinationChain: Chain.check(z.describe('Destination chain, always Tempo mainnet in V1.')),
+      destinationToken: Token.check(z.describe('Tempo token expected from this route.')),
+      errorCode: z
+        .nullable(z.string())
+        .check(
+          z.describe('Stable route error code, when status is `error`.'),
+          z.meta({ examples: ['provider_timeout'] }),
+        ),
+      id: z
+        .string()
+        .check(
+          z.describe('Stable deterministic route candidate id.'),
+          z.meta({ examples: ['base-usdc-tempo-usdce-across'] }),
+        ),
+      provider: ProviderRef,
+      quality: Quality,
+      quote: z
+        .nullable(RouteQuote)
+        .check(z.describe('Provider-derived quote data, when a live route probe succeeds.')),
+      sourceAmount: TokenAmount,
+      sourceChain: Chain.check(z.describe('Chain where the caller currently holds funds.')),
+      sourceToken: Token.check(z.describe('Token the caller currently holds.')),
+      status: z
+        .enum(['available', 'thin', 'unknown', 'unavailable', 'error'])
+        .check(
+          z.describe('Provider-specific route status for the requested amount.'),
+          z.meta({ examples: ['unknown'] }),
+        ),
+    }),
+    'One provider-specific funding route candidate.',
+  )
+
+  /** Generic provider catalog entry. */
+  export const Provider = Schema.describe(
+    z.object({
+      capabilities: z
+        .array(z.enum(['fundingRoutes']))
+        .check(
+          z.describe('Provider capabilities Tempo exposes through public APIs.'),
+          z.meta({ examples: [['fundingRoutes']] }),
+        ),
+      id: z.string().check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
+      kind: z
+        .string()
+        .check(z.describe('Provider category.'), z.meta({ examples: ['solverNetwork'] })),
+      name: z
+        .string()
+        .check(z.describe('Human-readable provider name.'), z.meta({ examples: ['Relay'] })),
+      requiresApiKey: z
+        .boolean()
+        .check(
+          z.describe('Whether Tempo needs provider credentials to query or use this provider.'),
+          z.meta({ examples: [false] }),
+        ),
+      status: z
+        .enum(['configured', 'inventoryOnly', 'planned'])
+        .check(
+          z.describe(
+            '`inventoryOnly` means Tempo exposes static route support but does not query live quotes yet. `planned` means the provider is listed for future support and may not return route candidates.',
+          ),
+          z.meta({ examples: ['inventoryOnly'] }),
+        ),
+    }),
+    'One provider in the generic provider catalog.',
+  )
+
+  /** Chain inventory entry returned by the funding chains endpoint. */
+  export const ChainInventory = Schema.describe(
+    z.extend(Chain, {
+      tokens: z.array(Token).check(z.describe('Stablecoins known on this source chain.')),
+    }),
+    'One source chain and its known stablecoin inventory.',
+  )
+
+  /** Schemas for the listFundingRoutes operation. */
+  export namespace listFundingRoutes {
+    /** Query parameters for funding route discovery. */
+    export const Query = z
+      .strictObject({
+        destinationToken: z
+          .optional(z.string())
+          .check(
+            z.describe(
+              'Tempo destination token symbol, address, or token key. Defaults to USDC.e.',
+            ),
+            z.meta({ examples: ['USDC.e'] }),
+          ),
+        include: z
+          .optional(z.string())
+          .check(
+            z.describe('Comma-separated response expansions. V1 accepts `quotes`.'),
+            z.meta({ examples: ['quotes'] }),
+          ),
+        limit: Schema.Limit,
+        provider: z
+          .optional(z.string())
+          .check(
+            z.describe(
+              'Only return candidates from this provider id, such as `across`, `relay`, or `bridge`. Planned providers can return an empty list.',
+            ),
+            z.meta({ examples: ['across', 'bridge'] }),
+          ),
+        sourceAmount: z
+          .string()
+          .check(
+            z.minLength(1),
+            z.describe('Source token amount. Base units by default, so 1 USDC is `1000000`.'),
+            z.meta({ examples: ['1000000'] }),
+          ),
+        sourceAmountUnits: z
+          ._default(z.enum(['baseUnits', 'decimal']), 'baseUnits')
+          .check(
+            z.describe('Whether `sourceAmount` is base units or a human-readable decimal.'),
+            z.meta({ examples: ['baseUnits', 'decimal'] }),
+          ),
+        sourceChain: z
+          .string()
+          .check(
+            z.minLength(1),
+            z.describe(
+              'Source chain alias or CAIP-2 id, such as `base`, `solana`, `tron`, or `eip155:8453`.',
+            ),
+            z.meta({ examples: ['base', 'solana', 'tron'] }),
+          ),
+        sourceToken: z.string().check(
+          z.minLength(1),
+          z.describe(
+            'Source token symbol, contract address, mint, or Tempo token key. Symbol lookup is scoped to `sourceChain`; EVM identifiers are case-insensitive, while Solana and Tron identifiers must match exactly. An unknown token returns an empty list, not an error.',
+          ),
+          z.meta({
+            examples: [
+              'USDC',
+              'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+              'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+            ],
+          }),
+        ),
+      })
+      .check(z.describe('Query parameters for discovering funding routes into Tempo.'))
+
+    /** Non-paginated list of funding route candidates. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z
+          .array(RouteCandidate)
+          .check(z.describe('Funding route candidates matching the request.')),
+      }),
+      'A non-paginated list of funding route candidates.',
+    )
+  }
+
+  /** Schemas for the listFundingChains operation. */
+  export namespace listFundingChains {
+    /** Non-paginated source-chain inventory. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z
+          .array(ChainInventory)
+          .check(z.describe('Source chains and stablecoins known to the funding route API.')),
+      }),
+      'A non-paginated list of source chains and stablecoin inventory.',
+    )
+  }
+
+  /** Schemas for the listProviders operation. */
+  export namespace listProviders {
+    /** Query parameters for the generic provider catalog. */
+    export const Query = z
+      .strictObject({
+        capability: z
+          .optional(z.enum(['fundingRoutes']))
+          .check(
+            z.describe('Optional provider capability filter.'),
+            z.meta({ examples: ['fundingRoutes'] }),
+          ),
+      })
+      .check(z.describe('Query parameters for listing providers.'))
+
+    /** Non-paginated generic provider catalog. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z.array(Provider).check(z.describe("Providers in Tempo's generic provider catalog.")),
+      }),
+      'A non-paginated list of providers.',
+    )
+  }
+}
+
+// Examples derive from the static inventory so they never drift from real responses.
+const fundingRouteResponseExamples = {
+  baseUsdc: {
+    description:
+      '`GET /v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&provider=across`',
+    summary: 'Base USDC',
+    value: {
+      data: FundingRoutes.listStaticRoutes({
+        limit: 10,
+        provider: 'across',
+        sourceAmount: '1000000',
+        sourceAmountUnits: 'baseUnits',
+        sourceChain: 'base',
+        sourceToken: 'USDC',
+      }),
+    } satisfies z.output<typeof schema.listFundingRoutes.Response>,
+  },
+  solanaUsdc: {
+    description:
+      '`GET /v1/funding/routes?sourceChain=solana&sourceToken=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&sourceAmount=1000000&provider=bridge`',
+    summary: 'Solana USDC',
+    value: {
+      data: FundingRoutes.listStaticRoutes({
+        limit: 10,
+        provider: 'bridge',
+        sourceAmount: '1000000',
+        sourceAmountUnits: 'baseUnits',
+        sourceChain: 'solana',
+        sourceToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+      }),
+    } satisfies z.output<typeof schema.listFundingRoutes.Response>,
+  },
+  tronUsdt: {
+    description:
+      '`GET /v1/funding/routes?sourceChain=tron&sourceToken=TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t&sourceAmount=1000000&provider=bridge`',
+    summary: 'Tron USDT',
+    value: {
+      data: FundingRoutes.listStaticRoutes({
+        limit: 10,
+        provider: 'bridge',
+        sourceAmount: '1000000',
+        sourceAmountUnits: 'baseUnits',
+        sourceChain: 'tron',
+        sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+      }),
+    } satisfies z.output<typeof schema.listFundingRoutes.Response>,
+  },
+} satisfies OpenApi.responses.Options<
+  typeof schema.listFundingRoutes.Response
+>['success']['examples']
+
+const fundingChainsResponseExample = {
+  data: FundingRoutes.listChains(),
+} satisfies z.output<typeof schema.listFundingChains.Response>
+
+const providersResponseExample = {
+  data: FundingRoutes.listProviders(),
+} satisfies z.output<typeof schema.listProviders.Response>
+
+/** Mounts funding route discovery and generic provider inventory endpoints. */
+export function funding(options: funding.Options = {}) {
+  return new Hono<App.Environment>()
+    .get(
+      '/v1/funding/routes',
+      Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
+      OpenApi.validate('query', schema.listFundingRoutes.Query, {
+        code: 'query_invalid',
+        message: 'Invalid query parameters',
+      }),
+      OpenApi.describeRoute({
+        description:
+          'Lists provider-specific route candidates for moving a source stablecoin amount into Tempo. This endpoint is discovery-only: it does not execute a bridge, reserve liquidity, or guarantee settlement. Static inventory candidates use `status: unknown`; provider adapters may add best-effort live quote fields.',
+        operationId: 'listFundingRoutes',
+        responses: OpenApi.responses({
+          errors: { 400: { codes: ['query_invalid'] } },
+          success: {
+            description:
+              'Discovery-only funding route candidates for the requested source chain and token.',
+            examples: fundingRouteResponseExamples,
+            schema: schema.listFundingRoutes.Response,
+          },
+        }),
+        summary: 'List funding routes',
+        tags: ['Funding'],
+      }),
+      Cache.response<App.Environment>({
+        cacheControl: Cache.policies.noStore,
+        name: 'tempo-api:funding-routes:v1',
+        key: (c) => Cache.urlKey(c, schema.listFundingRoutes.Query),
+      }),
+      async (c) => {
+        if (Auth.narrowAccess) return Auth.paidAccessError(c)
+        if (OpenApi.narrowValidation)
+          return OpenApi.validationError(c, {
+            code: 'query_invalid',
+            message: 'Invalid query parameters',
+          })
+
+        const query = c.req.valid('query')
+        try {
+          const include = FundingRoutes.parseInclude(query.include)
+          return c.json(
+            Response.validated(schema.listFundingRoutes.Response, {
+              data: await FundingRoutes.listRoutes({
+                adapters: options.adapters,
+                adapterTimeoutMs: options.adapterTimeoutMs,
+                cache: { bypass: cacheBypass(c.req.raw) },
+                destinationToken: query.destinationToken,
+                include,
+                limit: query.limit,
+                provider: query.provider,
+                sourceAmount: query.sourceAmount,
+                sourceAmountUnits: query.sourceAmountUnits,
+                sourceChain: query.sourceChain,
+                sourceToken: query.sourceToken,
+              }),
+            }),
+            200,
+          )
+        } catch (cause) {
+          const message = requestErrorMessage(cause)
+          if (message) return Response.error(c, { code: 'query_invalid', message, status: 400 })
+          throw cause
+        }
+      },
+    )
+    .get(
+      '/v1/funding/chains',
+      Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
+      OpenApi.describeRoute({
+        description:
+          'Lists source chains and stablecoins understood by the funding route API, including provider-specific ids useful when comparing provider docs. This is static inventory metadata, not a live liquidity check.',
+        operationId: 'listFundingChains',
+        responses: OpenApi.responses({
+          success: {
+            description: 'Source-chain and stablecoin inventory for funding route discovery.',
+            example: fundingChainsResponseExample,
+            schema: schema.listFundingChains.Response,
+          },
+        }),
+        summary: 'List funding chains',
+        tags: ['Funding'],
+      }),
+      Cache.response<App.Environment>({
+        cacheControl: Cache.policies.stable,
+        name: 'tempo-api:funding-chains:v1',
+        key: (c) => c.req.url,
+      }),
+      (c) => {
+        if (Auth.narrowAccess) return Auth.paidAccessError(c)
+        return c.json(
+          Response.validated(schema.listFundingChains.Response, {
+            data: FundingRoutes.listChains(),
+          }),
+          200,
+        )
+      },
+    )
+    .get(
+      '/v1/providers',
+      Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
+      OpenApi.validate('query', schema.listProviders.Query, {
+        code: 'query_invalid',
+        message: 'Invalid query parameters',
+      }),
+      OpenApi.describeRoute({
+        description:
+          'Lists provider metadata, capability flags, auth requirements, and integration status across provider domains. `inventoryOnly` providers can appear in static route candidates; `planned` providers are visible for roadmap transparency and may not return candidates.',
+        operationId: 'listProviders',
+        responses: OpenApi.responses({
+          errors: { 400: { codes: ['query_invalid'] } },
+          success: {
+            description: 'Providers known to Tempo.',
+            example: providersResponseExample,
+            schema: schema.listProviders.Response,
+          },
+        }),
+        summary: 'List providers',
+        tags: ['Providers'],
+      }),
+      Cache.response<App.Environment>({
+        cacheControl: Cache.policies.stable,
+        name: 'tempo-api:providers:v1',
+        key: (c) => Cache.urlKey(c, schema.listProviders.Query),
+      }),
+      (c) => {
+        if (Auth.narrowAccess) return Auth.paidAccessError(c)
+        if (OpenApi.narrowValidation)
+          return OpenApi.validationError(c, {
+            code: 'query_invalid',
+            message: 'Invalid query parameters',
+          })
+
+        const query = c.req.valid('query')
+        return c.json(
+          Response.validated(schema.listProviders.Response, {
+            data: FundingRoutes.listProviders({
+              adapters: options.adapters,
+              capability: query.capability,
+            }),
+          }),
+          200,
+        )
+      },
+    )
+}
+
+export declare namespace funding {
+  /** Options for funding route discovery. */
+  type Options = {
+    /** Provider adapters used to enrich static inventory with live data. */
+    adapters?: FundingRoutes.ProviderAdapters | undefined
+    /** Per-provider quote timeout in milliseconds. */
+    adapterTimeoutMs?: number | undefined
+  }
+}
+
+// Maps caller-input errors to a specific 400 message; anything else rethrows.
+function requestErrorMessage(cause: unknown) {
+  if (cause instanceof FundingRoutes.InvalidAmountError) return 'Invalid `sourceAmount`.'
+  if (cause instanceof FundingRoutes.UnsupportedIncludeError) return 'Unsupported `include`.'
+  if (cause instanceof FundingRoutes.UnsupportedDestinationTokenError)
+    return 'Unsupported `destinationToken`.'
+  if (cause instanceof FundingRoutes.UnsupportedProviderError) return 'Unsupported `provider`.'
+  if (cause instanceof FundingRoutes.UnsupportedSourceChainError)
+    return 'Unsupported `sourceChain`.'
+  return undefined
+}
+
+function cacheBypass(request: Request) {
+  const directives = (
+    request.headers.get('Cache-Control') ??
+    request.headers.get('Pragma') ??
+    ''
+  ).toLowerCase()
+  return directives.includes('no-cache') || directives.includes('no-store')
+}