tapimo 0.4.3 → 0.5.0

package/src/apps/data/FundingRouteProviders.ts

@@ -1,744 +0,0 @@
-import * as z from 'zod/mini'
-
-import * as FundingRoutes from '../../internal/FundingRoutes.js'
-
-type Fetch = typeof globalThis.fetch
-
-const defaultFetch: Fetch = (input, init) => globalThis.fetch(input, init)
-
-const defaultAcrossBaseUrl = 'https://app.across.to/api'
-const defaultRelayBaseUrl = 'https://api.relay.link'
-
-namespace schema {
-  const DecimalString = z.string().check(z.regex(/^\d+(\.\d+)?$/))
-  const IntegerString = z.string().check(z.regex(/^\d+$/))
-
-  const AcrossToken = z.object({
-    address: z.string(),
-    chainId: z.number().check(z.int(), z.nonnegative()),
-    decimals: z.number().check(z.int(), z.nonnegative()),
-    symbol: z.string(),
-  })
-
-  const AcrossFee = z.object({
-    amount: IntegerString,
-    amountUsd: DecimalString,
-    pct: IntegerString,
-    token: AcrossToken,
-  })
-
-  export const AcrossQuote = z.object({
-    amountType: z.literal('exactInput'),
-    expectedFillTime: z.number().check(z.int(), z.nonnegative()),
-    expectedOutputAmount: IntegerString,
-    fees: z.object({
-      total: AcrossFee,
-      totalMax: AcrossFee,
-    }),
-    inputAmount: IntegerString,
-    inputToken: AcrossToken,
-    minOutputAmount: IntegerString,
-    outputToken: AcrossToken,
-    quoteExpiryTimestamp: z.number().check(z.int(), z.nonnegative()),
-  })
-}
-
-/** Creates the live funding route adapters configured for this deployment. */
-export function createAdapters(options: createAdapters.Options = {}) {
-  return {
-    ...(options.across ? { across: across(options.across) } : {}),
-    ...(options.relay ? { relay: relay(options.relay) } : {}),
-  } satisfies FundingRoutes.ProviderAdapters
-}
-
-export declare namespace createAdapters {
-  /** Provider adapter factory options. Omit a provider to keep its routes static. */
-  type Options = {
-    /** Across discovery adapter options. */
-    across?: across.Options | false | undefined
-    /** Relay quote adapter options. */
-    relay?: relay.Options | false | undefined
-  }
-}
-
-/** Creates an Across discovery adapter backed by `/suggested-fees`. */
-export function across(options: across.Options): FundingRoutes.ProviderAdapter {
-  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultAcrossBaseUrl)
-  const fetcher = options.fetch ?? defaultFetch
-  const now = options.now ?? (() => new Date())
-
-  return {
-    async probeQuote({ route }, signal) {
-      const sourceChainId = providerChainId(route.sourceChain, 'across')
-      const destinationChainId = eip155ChainId(route.destinationChain)
-      const url = new URL(`${baseUrl}/suggested-fees`)
-      url.search = new URLSearchParams({
-        allowUnmatchedDecimals: 'true',
-        amount: route.sourceAmount.amount,
-        destinationChainId,
-        inputToken: route.sourceToken.address,
-        integratorId: options.integratorId,
-        originChainId: sourceChainId,
-        outputToken: route.destinationToken.address,
-      }).toString()
-
-      try {
-        const body = await requestJson(url, {
-          fetcher,
-          headers: { Authorization: `Bearer ${options.apiKey}` },
-          signal,
-        })
-        return formatAcrossResult(route, body, now())
-      } catch (cause) {
-        const unavailable = providerUnavailable(cause, ['AMOUNT_TOO_HIGH', 'AMOUNT_TOO_LOW'])
-        if (!unavailable) throw cause
-        return unavailableResult({
-          detail: 'across:suggested-fees',
-          message: unavailable,
-          now: now(),
-          source: 'providerLimit',
-        })
-      }
-    },
-  }
-}
-
-/** Builds the authenticated Across `/swap/approval` request for an exact-input quote. */
-export function createAcrossQuoteRequest(options: createAcrossQuoteRequest.Options) {
-  assertAcrossIntegratorId(options.integratorId)
-  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultAcrossBaseUrl)
-  const sourceChainId = providerChainId(options.route.sourceChain, 'across')
-  const destinationChainId = eip155ChainId(options.route.destinationChain)
-  const url = new URL(`${baseUrl}/swap/approval`)
-  url.search = new URLSearchParams({
-    amount: options.route.sourceAmount.amount,
-    depositor: options.depositor,
-    destinationChainId,
-    inputToken: options.route.sourceToken.address,
-    integratorId: options.integratorId,
-    originChainId: sourceChainId,
-    outputToken: options.route.destinationToken.address,
-    skipOriginTxEstimation: 'true',
-    strictTradeType: 'true',
-    tradeType: 'exactInput',
-  }).toString()
-  if (options.recipient !== undefined) url.searchParams.set('recipient', options.recipient)
-  return { headers: { Authorization: `Bearer ${options.apiKey}` }, url }
-}
-
-export declare namespace createAcrossQuoteRequest {
-  /** Inputs required to construct an Across exact-input quote request. */
-  type Options = {
-    /** Across API key sent as a bearer token. */
-    apiKey: string
-    /** Optional Across API base URL. */
-    baseUrl?: string | undefined
-    /** Address that would submit the source transaction. */
-    depositor: string
-    /** Across integrator id sent as the required query parameter. */
-    integratorId: string
-    /** Optional destination recipient. */
-    recipient?: string | undefined
-    /** Curated route selected for the quote. */
-    route: FundingRoutes.RouteCandidate
-  }
-}
-
-/** Creates an explicit Across quote adapter backed by `/swap/approval`. */
-export function acrossQuote(options: acrossQuote.Options): FundingRoutes.ProviderQuote {
-  assertAcrossIntegratorId(options.integratorId)
-
-  return async ({ depositor, recipient, route }, signal) => {
-    const request = createAcrossQuoteRequest({
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl,
-      depositor,
-      integratorId: options.integratorId,
-      recipient,
-      route,
-    })
-
-    try {
-      const body = await requestJson(request.url, {
-        fetcher: defaultFetch,
-        headers: request.headers,
-        signal,
-      })
-      return parseAcrossQuote({ body, now: new Date(), route })
-    } catch (cause) {
-      if (!(cause instanceof ProviderResponseError)) throw cause
-      throw mapAcrossQuoteError({ body: cause.body, status: cause.status })
-    }
-  }
-}
-
-export declare namespace acrossQuote {
-  /** Across Swap API adapter options. */
-  type Options = {
-    /** Across API key sent as a bearer token. */
-    apiKey: string
-    /** Optional Across API base URL. */
-    baseUrl?: string | undefined
-    /** Across integrator id sent as the required query parameter. */
-    integratorId: string
-  }
-}
-
-/** Returns bounded Across quote failure details suitable for structured request logs. */
-export function acrossQuoteFailure(options: acrossQuoteFailure.Options): acrossQuoteFailure.Result {
-  const { cause } = options
-  const base = { id: 'across', operation: 'swap/approval' } as const
-  if (cause instanceof ProviderResponseError) {
-    const code = providerErrorCode(cause.body)
-    return {
-      ...(code === undefined ? {} : { code }),
-      failure: 'http' as const,
-      ...base,
-      status: cause.status,
-    }
-  }
-  if (cause instanceof ProviderPayloadError) return { failure: 'payload', ...base }
-  if (cause instanceof TypeError) return { failure: 'network', ...base }
-  if (cause instanceof Error) return { failure: 'unknown', ...base }
-  return undefined
-}
-
-export declare namespace acrossQuoteFailure {
-  /** Inputs used to classify an Across quote failure. */
-  type Options = {
-    /** Error thrown by the Across quote boundary. */
-    cause: unknown
-  }
-
-  /** Bounded diagnostic fields, or undefined when the thrown value is not an error. */
-  type Result =
-    | {
-        /** Stable provider error code, when one is safe to retain. */
-        code?: string | undefined
-        /** Failure boundary that rejected the provider request. */
-        failure: 'http' | 'network' | 'payload' | 'unknown'
-        /** Provider identifier. */
-        id: 'across'
-        /** Across operation identifier. */
-        operation: 'swap/approval'
-        /** Upstream HTTP status, when a response was received. */
-        status?: number | undefined
-      }
-    | undefined
-}
-
-export declare namespace across {
-  /** Across API adapter options. */
-  type Options = {
-    /** Override for tests or non-production Across environments. */
-    baseUrl?: string | undefined
-    /** Fetch implementation override for tests. */
-    fetch?: Fetch | undefined
-    /** Across API key sent as a bearer token. */
-    apiKey: string
-    /** Across integrator id sent as the required query parameter. */
-    integratorId: string
-    /** Clock override for deterministic tests. */
-    now?: (() => Date) | undefined
-  }
-}
-
-/** Creates a Relay quote adapter backed by `/chains/liquidity` and `/quote/v2`. */
-export function relay(options: relay.Options): FundingRoutes.ProviderAdapter {
-  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRelayBaseUrl)
-  const fetcher = options.fetch ?? defaultFetch
-  const now = options.now ?? (() => new Date())
-
-  return {
-    async probeQuote({ route }, signal) {
-      const originChainId = providerChainId(route.sourceChain, 'relay')
-      const destinationChainId = eip155ChainId(route.destinationChain)
-      const headers = relayHeaders(options.apiKey)
-
-      try {
-        const quote = await requestJson(new URL(`${baseUrl}/quote/v2`), {
-          body: {
-            amount: route.sourceAmount.amount,
-            destinationChainId: Number(destinationChainId),
-            destinationCurrency: route.destinationToken.address,
-            originChainId: Number(originChainId),
-            originCurrency: route.sourceToken.address,
-            recipient: options.recipientAddress ?? options.userAddress,
-            tradeType: 'EXACT_INPUT',
-            user: options.userAddress,
-          },
-          fetcher,
-          headers,
-          method: 'POST',
-          signal,
-        })
-        const liquidityUrl = new URL(`${baseUrl}/chains/liquidity`)
-        liquidityUrl.searchParams.set('chainId', destinationChainId)
-        const liquidity = await requestJson(liquidityUrl, { fetcher, headers, signal }).catch(
-          () => undefined,
-        )
-        return formatRelayResult(route, quote, liquidity, now())
-      } catch (cause) {
-        const unavailable = providerUnavailable(cause, [
-          'NO_QUOTES',
-          'NO_ROUTE',
-          'UNSUPPORTED_ROUTE',
-        ])
-        if (!unavailable) throw cause
-        return unavailableResult({
-          detail: 'relay:quote-v2',
-          message: unavailable,
-          now: now(),
-          source: 'providerQuote',
-        })
-      }
-    },
-  }
-}
-
-export declare namespace relay {
-  /** Relay quote adapter options. */
-  type Options = {
-    /** Probe wallet address required by Relay's quote API. */
-    userAddress: string
-    /** Optional recipient override; defaults to `userAddress`. */
-    recipientAddress?: string | undefined
-    /** Optional Relay API key for higher rate limits. */
-    apiKey?: string | undefined
-    /** Override for tests or Relay testnet environments. */
-    baseUrl?: string | undefined
-    /** Fetch implementation override for tests. */
-    fetch?: Fetch | undefined
-    /** Clock override for deterministic tests. */
-    now?: (() => Date) | undefined
-  }
-}
-
-/** Maps an Across HTTP error into the stable funding-provider error contract. */
-export function mapAcrossQuoteError(options: mapAcrossQuoteError.Options) {
-  if (options.status === 429) return new FundingRoutes.ProviderRateLimitError()
-  const cause = new ProviderResponseError(options.status, options.body)
-  const unavailable = providerUnavailable(cause, [
-    'AMOUNT_TOO_HIGH',
-    'AMOUNT_TOO_LOW',
-    'INSUFFICIENT_LIQUIDITY',
-    'NO_QUOTES',
-    'NO_ROUTE',
-    'UNSUPPORTED_ROUTE',
-  ])
-  if (unavailable) return new FundingRoutes.ProviderQuoteUnavailableError()
-  return cause
-}
-
-export declare namespace mapAcrossQuoteError {
-  /** Across HTTP error response to classify. */
-  type Options = {
-    /** Parsed response body returned by Across. */
-    body: unknown
-    /** Across HTTP response status. */
-    status: number
-  }
-}
-
-/** Validates and normalizes an Across quote payload against its curated route. */
-export function parseAcrossQuote(
-  options: parseAcrossQuote.Options,
-): FundingRoutes.ProviderQuoteResult {
-  const parsed = schema.AcrossQuote.safeParse(options.body)
-  if (!parsed.success) throw new ProviderPayloadError()
-  const response = parsed.data
-  const total = response.fees.total
-  const totalMax = response.fees.totalMax
-  if (
-    response.inputAmount !== options.route.sourceAmount.amount ||
-    response.inputToken.address.toLowerCase() !== options.route.sourceToken.address.toLowerCase() ||
-    response.inputToken.chainId !== Number(eip155ChainId(options.route.sourceChain)) ||
-    response.inputToken.decimals !== options.route.sourceToken.decimals ||
-    response.outputToken.address.toLowerCase() !==
-      options.route.destinationToken.address.toLowerCase() ||
-    response.outputToken.chainId !== Number(eip155ChainId(options.route.destinationChain)) ||
-    response.outputToken.decimals !== options.route.destinationToken.decimals ||
-    BigInt(response.expectedOutputAmount) <= 0n ||
-    BigInt(response.minOutputAmount) <= 0n ||
-    BigInt(response.minOutputAmount) > BigInt(response.expectedOutputAmount) ||
-    response.quoteExpiryTimestamp * 1_000 <= options.now.getTime() ||
-    !matchesFeeToken(total.token, options.route) ||
-    !matchesFeeToken(totalMax.token, options.route) ||
-    BigInt(totalMax.amount) < BigInt(total.amount) ||
-    BigInt(totalMax.pct) < BigInt(total.pct)
-  )
-    throw new ProviderPayloadError()
-  return {
-    estimatedSeconds: response.expectedFillTime,
-    expiresAt: isoFromUnixSeconds(String(response.quoteExpiryTimestamp)),
-    fees: {
-      total: formatAcrossFee(response.fees.total),
-      totalMax: formatAcrossFee(response.fees.totalMax),
-    },
-    minimumOutputAmount: response.minOutputAmount,
-    outputAmount: response.expectedOutputAmount,
-    sampledAt: options.now.toISOString(),
-  }
-}
-
-export declare namespace parseAcrossQuote {
-  /** Inputs required to validate and normalize an Across quote payload. */
-  type Options = {
-    /** Untrusted JSON body returned by Across. */
-    body: unknown
-    /** Timestamp when Tempo sampled the response. */
-    now: Date
-    /** Curated route the response must match. */
-    route: FundingRoutes.RouteCandidate
-  }
-}
-
-function formatAcrossResult(
-  route: FundingRoutes.RouteCandidate,
-  body: unknown,
-  now: Date,
-): FundingRoutes.QuoteProbeResult {
-  const response = record(body)
-  const timestamp = integerString(response['timestamp'])
-  const sampledAt = timestamp ? isoFromUnixSeconds(timestamp) : now.toISOString()
-  const limits = acrossLimits(response['limits'])
-  const amountStatus = statusFromLimits(route.sourceAmount.amount, limits)
-  const status = response['isAmountTooLow'] === true ? 'unavailable' : amountStatus.status
-  const tier = response['isAmountTooLow'] === true ? 'unavailable' : amountStatus.tier
-  const outputAmount = decimalString(response['outputAmount'])
-
-  return {
-    expiresAt: timestamp ? isoFromUnixSeconds((BigInt(timestamp) + 600n).toString()) : null,
-    limits,
-    outputAmount,
-    outputAmountFormatted: outputAmount
-      ? decimalFromBaseUnits(outputAmount, route.destinationToken.decimals)
-      : null,
-    quality: {
-      availableVolumeUsd: stablecoinUsdCapacity(route, limits?.maxSourceAmount),
-      estimatedSeconds: nonnegativeInteger(response['estimatedFillTimeSec']),
-      feeBps: scaledPctToBps(
-        nestedString(response['totalRelayFee'], 'pct') ?? decimalString(response['relayFeePct']),
-      ),
-      historicalVolumeUsd24h: null,
-      instantVolumeUsd: stablecoinUsdCapacity(route, limits?.instantSourceAmount),
-      liquiditySource: 'providerLimit',
-      score: scoreFor(tier),
-      sourceDetail: 'across:suggested-fees',
-      tier,
-    },
-    sampledAt,
-    status,
-  }
-}
-
-function formatAcrossFee(
-  fee: z.output<typeof schema.AcrossQuote>['fees']['total'],
-): FundingRoutes.ProviderQuoteFee {
-  return {
-    amount: fee.amount,
-    amountUsd: fee.amountUsd,
-    bps: scaledPctToBps(fee.pct),
-    token: {
-      address: fee.token.address,
-      chainId: `eip155:${fee.token.chainId}`,
-      decimals: fee.token.decimals,
-      symbol: fee.token.symbol,
-    },
-  }
-}
-
-function formatRelayResult(
-  route: FundingRoutes.RouteCandidate,
-  quote: unknown,
-  liquidity: unknown,
-  now: Date,
-): FundingRoutes.QuoteProbeResult {
-  const details = record(record(quote)['details'])
-  const currencyOut = record(details['currencyOut'])
-  const outputAmount = decimalString(currencyOut['amount'])
-  const liquidityRow = relayLiquidity(liquidity, route)
-  const destinationLiquidity = decimalString(liquidityRow?.['balance'])
-  const availableVolumeUsd = decimalString(liquidityRow?.['amountUsd']) ?? null
-  const liquidityStatus = relayLiquidityStatus({ destinationLiquidity, outputAmount })
-
-  return {
-    limits: null,
-    minimumOutputAmount: decimalString(currencyOut['minimumAmount']),
-    outputAmount,
-    outputAmountFormatted: outputAmount
-      ? decimalFromBaseUnits(outputAmount, route.destinationToken.decimals)
-      : null,
-    quality: {
-      availableVolumeUsd: availableVolumeUsd,
-      estimatedSeconds: nonnegativeInteger(details['timeEstimate']),
-      feeBps: null,
-      historicalVolumeUsd24h: null,
-      instantVolumeUsd: availableVolumeUsd,
-      liquiditySource: 'providerQuote',
-      score: scoreFor(liquidityStatus.tier),
-      sourceDetail: 'relay:quote-v2',
-      tier: liquidityStatus.tier,
-    },
-    sampledAt: now.toISOString(),
-    status: liquidityStatus.status,
-  }
-}
-
-function relayLiquidityStatus(options: {
-  destinationLiquidity: string | undefined
-  outputAmount: string | undefined
-}): { status: FundingRoutes.RouteStatus; tier: FundingRoutes.QualityTier } {
-  if (!options.outputAmount) return { status: 'unknown', tier: 'unknown' }
-  if (!options.destinationLiquidity) return { status: 'unknown', tier: 'unknown' }
-  if (compareIntegerStrings(options.destinationLiquidity, options.outputAmount) < 0)
-    return { status: 'thin', tier: 'thin' }
-  return { status: 'available', tier: 'liquid' }
-}
-
-function unavailableResult(options: {
-  detail: string
-  message: string
-  now: Date
-  source: string
-}): FundingRoutes.QuoteProbeResult {
-  return {
-    quality: {
-      availableVolumeUsd: null,
-      estimatedSeconds: null,
-      feeBps: null,
-      historicalVolumeUsd24h: null,
-      instantVolumeUsd: null,
-      liquiditySource: options.source,
-      score: 0,
-      sourceDetail: `${options.detail}:${options.message}`,
-      tier: 'unavailable',
-    },
-    sampledAt: options.now.toISOString(),
-    status: 'unavailable',
-  }
-}
-
-function acrossLimits(input: unknown): FundingRoutes.QuoteProbeLimits | null {
-  const limits = record(input)
-  const minSourceAmount = decimalString(limits['minDeposit'])
-  const maxSourceAmount = decimalString(limits['maxDeposit'])
-  const instantSourceAmount =
-    decimalString(limits['maxDepositInstant']) ?? decimalString(limits['recommendedDepositInstant'])
-  return minSourceAmount || maxSourceAmount || instantSourceAmount
-    ? { instantSourceAmount, maxSourceAmount, minSourceAmount }
-    : null
-}
-
-function statusFromLimits(
-  amount: string,
-  limits: FundingRoutes.QuoteProbeLimits | null,
-): { status: FundingRoutes.RouteStatus; tier: FundingRoutes.QualityTier } {
-  if (!limits) return { status: 'available', tier: 'liquid' }
-  if (limits.minSourceAmount && compareIntegerStrings(amount, limits.minSourceAmount) < 0)
-    return { status: 'unavailable', tier: 'unavailable' }
-  if (limits.maxSourceAmount && compareIntegerStrings(amount, limits.maxSourceAmount) > 0)
-    return { status: 'unavailable', tier: 'unavailable' }
-  if (limits.instantSourceAmount && compareIntegerStrings(amount, limits.instantSourceAmount) > 0)
-    return { status: 'thin', tier: 'thin' }
-  return { status: 'available', tier: 'liquid' }
-}
-
-function relayLiquidity(input: unknown, route: FundingRoutes.RouteCandidate) {
-  const response = record(input)
-  const rows = Array.isArray(response['liquidity']) ? response['liquidity'] : []
-  const destinationChainId = eip155ChainId(route.destinationChain)
-  return rows.map(record).find((row) => {
-    const rowChainId = integerString(row['chainId'])
-    const rowAddress = typeof row['address'] === 'string' ? row['address'].toLowerCase() : undefined
-    return (
-      rowChainId === destinationChainId &&
-      rowAddress === route.destinationToken.address.toLowerCase()
-    )
-  })
-}
-
-async function requestJson(
-  url: URL,
-  options: {
-    body?: unknown
-    fetcher: Fetch
-    headers?: Record<string, string> | undefined
-    method?: string | undefined
-    signal: AbortSignal
-  },
-) {
-  const headers = { accept: 'application/json', ...options.headers }
-  const init: RequestInit = {
-    headers:
-      options.body === undefined ? headers : { ...headers, 'content-type': 'application/json' },
-    method: options.method ?? 'GET',
-    signal: options.signal,
-  }
-  if (options.body !== undefined) init.body = JSON.stringify(options.body)
-  const response = await options.fetcher(url, init)
-  const text = await response.text()
-  const body = parseJson(text)
-  if (!response.ok) throw new ProviderResponseError(response.status, body)
-  return body
-}
-
-function relayHeaders(apiKey: string | undefined): Record<string, string> | undefined {
-  return apiKey ? { 'x-api-key': apiKey } : undefined
-}
-
-function providerUnavailable(cause: unknown, codes: readonly string[]) {
-  if (!(cause instanceof ProviderResponseError) || cause.status < 400 || cause.status >= 500)
-    return undefined
-  const code = providerErrorCode(cause.body)
-  if (code && codes.includes(code)) return code
-  return undefined
-}
-
-function providerErrorCode(input: unknown) {
-  const body = record(input)
-  const code = stringValue(body['code']) ?? stringValue(body['errorCode'])
-  return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined
-}
-
-class ProviderResponseError extends Error {
-  override name = 'FundingRouteProviders.ProviderResponseError'
-
-  constructor(
-    readonly status: number,
-    readonly body: unknown,
-  ) {
-    super(`Provider request failed with status ${status}`)
-  }
-}
-
-class ProviderPayloadError extends Error {
-  override name = 'FundingRouteProviders.ProviderPayloadError'
-}
-
-class ProviderConfigurationError extends Error {
-  override name = 'FundingRouteProviders.ProviderConfigurationError'
-}
-
-function providerChainId(
-  routeChain: FundingRoutes.RouteCandidate['sourceChain'],
-  provider: string,
-) {
-  const providerIds = routeChain.providerIds as Record<string, string> | undefined
-  const id = providerIds?.[provider]
-  if (id && /^\d+$/.test(id)) return id
-  return eip155ChainId(routeChain)
-}
-
-function eip155ChainId(chain: { id: string; kind: string }) {
-  if (chain.kind !== 'evm') throw new UnsupportedProviderRouteError()
-  const match = /^eip155:(\d+)$/.exec(chain.id)
-  if (!match?.[1]) throw new UnsupportedProviderRouteError()
-  return match[1]
-}
-
-class UnsupportedProviderRouteError extends Error {
-  override name = 'FundingRouteProviders.UnsupportedProviderRouteError'
-}
-
-function assertAcrossIntegratorId(integratorId: string) {
-  if (!/^0x[\da-fA-F]{4}$/.test(integratorId)) throw new ProviderConfigurationError()
-}
-
-function matchesFeeToken(
-  token: z.output<typeof schema.AcrossQuote>['fees']['total']['token'],
-  route: FundingRoutes.RouteCandidate,
-) {
-  return (
-    token.address.toLowerCase() === route.sourceToken.address.toLowerCase() &&
-    token.chainId === Number(eip155ChainId(route.sourceChain)) &&
-    token.decimals === route.sourceToken.decimals
-  )
-}
-
-function normalizeBaseUrl(input: string) {
-  return input.replace(/\/+$/, '')
-}
-
-function parseJson(input: string) {
-  if (!input) return null
-  try {
-    return JSON.parse(input) as unknown
-  } catch {
-    return input
-  }
-}
-
-function record(input: unknown): Record<string, unknown> {
-  return input && typeof input === 'object' && !Array.isArray(input)
-    ? (input as Record<string, unknown>)
-    : {}
-}
-
-function stringValue(input: unknown) {
-  return typeof input === 'string' && input.length > 0 ? input : undefined
-}
-
-function decimalString(input: unknown) {
-  if (typeof input === 'string' && /^\d+(\.\d+)?$/.test(input)) return input
-  if (typeof input === 'number' && Number.isFinite(input) && input >= 0) return String(input)
-  return undefined
-}
-
-function integerString(input: unknown) {
-  if (typeof input === 'string' && /^\d+$/.test(input)) return input
-  if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0) return String(input)
-  return undefined
-}
-
-function nestedString(input: unknown, key: string) {
-  return decimalString(record(input)[key])
-}
-
-function nonnegativeInteger(input: unknown) {
-  if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0) return input
-  if (typeof input === 'string' && /^\d+$/.test(input)) return Number(input)
-  return null
-}
-
-function decimalFromBaseUnits(baseUnits: string, decimals: number) {
-  const padded = baseUnits.padStart(decimals + 1, '0')
-  const whole = decimals === 0 ? padded : padded.slice(0, -decimals)
-  const fraction = decimals === 0 ? '' : padded.slice(-decimals).replace(/0+$/, '')
-  return fraction ? `${whole}.${fraction}` : whole
-}
-
-function compareIntegerStrings(left: string, right: string) {
-  return BigInt(left) === BigInt(right) ? 0 : BigInt(left) > BigInt(right) ? 1 : -1
-}
-
-function isoFromUnixSeconds(input: string) {
-  return new Date(Number(input) * 1_000).toISOString()
-}
-
-function stablecoinUsdCapacity(
-  route: FundingRoutes.RouteCandidate,
-  baseUnits: string | null | undefined,
-) {
-  if (!baseUnits || !isDollarStablecoin(route.sourceToken.symbol)) return null
-  return decimalFromBaseUnits(baseUnits, route.sourceToken.decimals)
-}
-
-function isDollarStablecoin(symbol: string) {
-  return ['DAI', 'FRXUSD', 'PYUSD', 'USDC', 'USDC.E', 'USDT', 'USDT0'].includes(
-    symbol.toUpperCase(),
-  )
-}
-
-function scaledPctToBps(input: string | undefined) {
-  if (!input || !/^\d+$/.test(input)) return null
-  const denominator = 1_000_000_000_000_000_000n
-  return Number((BigInt(input) * 10_000n + denominator / 2n) / denominator)
-}
-
-function scoreFor(tier: FundingRoutes.QualityTier) {
-  if (tier === 'liquid') return 90
-  if (tier === 'thin') return 65
-  if (tier === 'unavailable') return 0
-  return null
-}