tapimo 0.4.4 → 0.5.0

package/src/internal/{FundingRoutes.ts → FundingQuotes.ts}

@@ -9,7 +9,7 @@ const destinationChain = {
 /** Tempo token used when the caller omits `destinationToken`. */
 const defaultDestinationToken = 'usdce'
 
-/** Source chains accepted by the funding route inventory. */
+/** Source chains considered by funding quote providers. */
 const sourceChains = [
   {
     addressFormat: 'evm',
@@ -18,9 +18,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'Ethereum',
     providerIds: {
-      bridge: 'ethereum',
-      bungee: '1',
-      lifi: '1',
       relay: '1',
     },
     slug: 'ethereum',
@@ -74,9 +71,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'Base',
     providerIds: {
-      bridge: 'base',
-      bungee: '8453',
-      lifi: '8453',
       relay: '8453',
     },
     slug: 'base',
@@ -114,8 +108,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'BNB Smart Chain',
     providerIds: {
-      bungee: '56',
-      lifi: '56',
       relay: '56',
     },
     slug: 'bnb',
@@ -138,61 +130,9 @@ const sourceChains = [
       },
     ],
   },
-  {
-    addressFormat: 'solana',
-    aliases: ['solana', 'solana:mainnet'],
-    id: 'solana:mainnet',
-    kind: 'solana',
-    name: 'Solana',
-    providerIds: {
-      bridge: 'solana',
-      relay: 'solana',
-    },
-    slug: 'solana',
-    tokens: [
-      {
-        address: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-        coingeckoId: 'usd-coin',
-        decimals: 6,
-        name: 'USD Coin',
-        standard: 'SPL',
-        symbol: 'USDC',
-      },
-      {
-        address: 'Es9vMFrzaCERmJfrF4H2FYD4KCo3LwC1uix9YEaQ8t1v',
-        coingeckoId: 'tether',
-        decimals: 6,
-        name: 'Tether USD',
-        standard: 'SPL',
-        symbol: 'USDT',
-      },
-    ],
-  },
-  {
-    addressFormat: 'tron',
-    aliases: ['tron', 'tron:mainnet'],
-    id: 'tron:mainnet',
-    kind: 'tron',
-    name: 'Tron',
-    providerIds: {
-      bridge: 'tron',
-      relay: 'tron',
-    },
-    slug: 'tron',
-    tokens: [
-      {
-        address: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-        coingeckoId: 'tether',
-        decimals: 6,
-        name: 'Tether USD',
-        standard: 'TRC-20',
-        symbol: 'USDT',
-      },
-    ],
-  },
 ] as const
 
-/** Tempo destination tokens supported by the initial funding route inventory. */
+/** Tempo destination tokens supported by funding quote providers. */
 const destinationTokens = [
   {
     address: '0x20c0000000000000000000000000000000000000',
@@ -236,39 +176,14 @@ const destinationTokens = [
   },
 ] as const
 
-/** Providers exposed by the generic provider catalog. */
+/** Providers supported by live funding quotes. */
 const providers = [
   {
-    capabilities: ['fundingRoutes'],
     id: 'relay',
     kind: 'solverNetwork',
     name: 'Relay',
     requiresApiKey: false,
-    status: 'inventoryOnly',
-  },
-  {
-    capabilities: ['fundingRoutes'],
-    id: 'bridge',
-    kind: 'enterpriseTransfer',
-    name: 'Bridge.xyz',
-    requiresApiKey: true,
-    status: 'inventoryOnly',
-  },
-  {
-    capabilities: ['fundingRoutes'],
-    id: 'bungee',
-    kind: 'aggregator',
-    name: 'Bungee',
-    requiresApiKey: false,
-    status: 'inventoryOnly',
-  },
-  {
-    capabilities: ['fundingRoutes'],
-    id: 'lifi',
-    kind: 'aggregator',
-    name: 'LI.FI',
-    requiresApiKey: true,
-    status: 'planned',
+    status: 'unconfigured',
   },
 ] as const
 
@@ -277,17 +192,14 @@ type DestinationTokenInput = (typeof destinationTokens)[number]
 type ProviderInput = (typeof providers)[number]
 type SourceChainInput = (typeof sourceChains)[number]
 
-/** Provider ids accepted by the funding route inventory. */
+/** Provider ids accepted by funding quote requests. */
 export type ProviderId = ProviderInput['id']
 
-/** Provider-specific route status for the requested amount. */
-export type RouteStatus = 'available' | 'thin' | 'unknown' | 'unavailable' | 'error'
-
-/** Machine-readable route quality tier. */
-export type QualityTier = 'liquid' | 'thin' | 'unknown' | 'unavailable' | 'error'
+/** Provider-specific quote status for the requested amount. */
+export type QuoteStatus = 'available' | 'thin' | 'unknown' | 'unavailable'
 
-/** Response expansions accepted by funding route discovery. */
-export type Include = 'quotes'
+/** Machine-readable quote quality tier. */
+export type QualityTier = 'liquid' | 'thin' | 'unknown' | 'unavailable'
 
 /** Normalized chain reference passed to provider adapters. */
 export type ChainRef = ReturnType<typeof formatChain> | typeof destinationChain
@@ -300,10 +212,13 @@ export type TokenRef =
   | ReturnType<typeof formatDestinationToken>
   | ReturnType<typeof formatSourceToken>
 
-/** A normalized funding route candidate returned by route discovery. */
-export type RouteCandidate = ReturnType<typeof formatRouteCandidate>
+/** A normalized internal candidate passed to funding quote providers. */
+export type QuoteCandidate = ReturnType<typeof formatQuoteCandidate>
+
+/** A successful normalized funding quote returned to callers. */
+export type FundingQuote = ReturnType<typeof formatFundingQuote>
 
-/** Cache policy for a single funding route discovery request. */
+/** Cache policy for a single funding quote request. */
 export type CachePolicy = {
   /** Whether provider adapters should bypass their own quote or inventory caches. */
   bypass: boolean
@@ -313,10 +228,6 @@ export type CachePolicy = {
 export type QuoteRequest = {
   /** Optional Tempo destination token symbol, address, or token key. */
   destinationToken?: string | undefined
-  /** Response expansions requested by the caller. */
-  include: readonly Include[]
-  /** Maximum number of route candidates requested by the caller. */
-  limit: number
   /** Optional provider id filter. */
   provider?: string | undefined
   /** Source amount as supplied by the caller. */
@@ -329,20 +240,18 @@ export type QuoteRequest = {
   sourceToken: string
 }
 
-/** Input passed to a provider adapter for one static route candidate probe. */
+/** Input passed to a provider adapter for one curated quote candidate. */
 export type QuoteProbeInput = {
-  /** Cache policy for provider-side inventory, quote, and liquidity lookups. */
+  /** Cache policy for provider-side discovery and quote lookups. */
   cache: CachePolicy
   /** Destination chain, always Tempo mainnet in V1. */
   destinationChain: ChainRef
-  /** Tempo token expected from this route. */
+  /** Tempo token expected from this quote. */
   destinationToken: TokenRef
-  /** Response expansions requested by the caller. */
-  include: readonly Include[]
-  /** Normalized caller request that produced this route candidate. */
+  /** Normalized caller request that produced this quote candidate. */
   request: QuoteRequest
-  /** Static candidate being enriched with live provider information. */
-  route: RouteCandidate
+  /** Curated candidate selected for live provider quoting. */
+  candidate: QuoteCandidate
   /** Source amount in base units and display form. */
   sourceAmount: TokenAmount
   /** Chain where the caller currently holds funds. */
@@ -351,72 +260,43 @@ export type QuoteProbeInput = {
   sourceToken: TokenRef
 }
 
-/** Provider-specific source amount limits, expressed in source base units. */
-export type QuoteProbeLimits = {
-  /** Provider-reported instant source amount capacity. */
-  instantSourceAmount?: string | null | undefined
-  /** Provider-reported maximum source amount. */
-  maxSourceAmount?: string | null | undefined
-  /** Provider-reported minimum source amount. */
-  minSourceAmount?: string | null | undefined
-}
-
 /** Quote probe data returned by a provider adapter. */
 export type QuoteProbeResult = {
-  /** Stable route error code when status is `error`. */
-  errorCode?: string | null | undefined
-  /** Provider quote expiry timestamp. */
-  expiresAt?: string | null | undefined
-  /** Provider-reported source amount limits. */
-  limits?: QuoteProbeLimits | null | undefined
   /** Slippage-adjusted minimum destination amount in base units. */
-  minimumOutputAmount?: string | null | undefined
+  minimumOutputAmount?: string | undefined
   /** Expected destination amount in base units. */
-  outputAmount?: string | null | undefined
+  outputAmount?: string | undefined
   /** Expected destination amount rendered with destination token decimals. */
-  outputAmountFormatted?: string | null | undefined
-  /** Timestamp for the live quote or route probe. */
+  outputAmountFormatted?: string | undefined
+  /** Timestamp for the live quote probe. */
   sampledAt: string
-  /** Provider-specific route status for the requested amount. */
-  status: RouteStatus
-  /** Provider-backed route quality metadata. */
+  /** Provider-specific quote status for the requested amount. */
+  status: QuoteStatus
+  /** Provider-backed quote quality metadata. */
   quality?: {
-    /** Available USD capacity, when available. */
-    availableVolumeUsd?: string | null | undefined
     /** Estimated settlement time in seconds, when known. */
-    estimatedSeconds?: number | null | undefined
-    /** Estimated fee in basis points, when known. */
-    feeBps?: number | null | undefined
-    /** 24h routed volume in USD, when available. */
-    historicalVolumeUsd24h?: string | null | undefined
-    /** Instant USD capacity, when available. */
-    instantVolumeUsd?: string | null | undefined
+    estimatedSeconds?: number | undefined
     /** Where the live liquidity or support signal came from. */
     liquiditySource: string
-    /** Explainable route score from 0 to 100, when enough signals are available. */
-    score?: number | null | undefined
     /** Provider-specific quote source or endpoint detail. */
-    sourceDetail?: string | null | undefined
-    /** Machine-readable route quality tier. */
+    sourceDetail?: string | undefined
+    /** Machine-readable quote quality tier. */
     tier?: QualityTier | undefined
   }
 }
 
-/** Adapter used to enrich a static route candidate with live provider information. */
+/** Adapter used to request a live provider quote. */
 export type ProviderAdapter = {
   /** Probes provider-backed quote information for one static candidate. */
   probeQuote(input: QuoteProbeInput, signal: AbortSignal): Promise<QuoteProbeResult>
 }
 
-/** Provider adapter registry, keyed by provider id. Missing adapters leave routes static. */
+/** Provider adapter registry, keyed by provider id. */
 export type ProviderAdapters = Partial<Record<ProviderId, ProviderAdapter>>
 
-/** Static provider support rows used until live quote adapters are configured. */
+/** Curated provider support rows used to select live quote probes. */
 const inventory: readonly InventoryEntry[] = [
   { destinationToken: 'usdce', provider: 'relay', sourceChains: ['ethereum', 'base', 'bnb'], sourceTokens: ['USDC', 'USDT'] }, // prettier-ignore
-  { destinationToken: 'usdce', provider: 'bridge', sourceChains: ['ethereum', 'base', 'solana'], sourceTokens: ['USDC'] }, // prettier-ignore
-  { destinationToken: 'usdce', provider: 'bridge', sourceChains: ['ethereum', 'solana', 'tron'], sourceTokens: ['USDT'] }, // prettier-ignore
-  { destinationToken: 'usdce', provider: 'bungee', sourceChains: ['ethereum', 'base', 'bnb'], sourceTokens: ['USDC'] }, // prettier-ignore
 ]
 
 type InventoryEntry = {
@@ -426,27 +306,34 @@ type InventoryEntry = {
   sourceTokens: readonly string[]
 }
 
-const defaultAdapterTimeoutMs = 750
-const includes = ['quotes'] as const
+const defaultAdapterTimeoutMs = 2_000
 
-/** Lists normalized chains and source tokens that can fund Tempo. */
+/** Lists normalized chains and source tokens supported by quote providers. */
 export function listChains() {
-  return sourceChains.map((chain) => ({
-    ...formatChain(chain),
-    tokens: chain.tokens.map((token) => formatSourceToken(chain, token)),
-  }))
+  return sourceChains.flatMap((chain) => {
+    const symbols = new Set(
+      inventory
+        .filter((entry) => entry.sourceChains.includes(chain.slug))
+        .flatMap((entry) => entry.sourceTokens),
+    )
+    if (symbols.size === 0) return []
+    return [
+      {
+        ...formatChain(chain),
+        tokens: chain.tokens
+          .filter((token) => symbols.has(token.symbol))
+          .map((token) => formatSourceToken(chain, token)),
+      },
+    ]
+  })
 }
 
-/** Lists providers, optionally filtered by one provider capability. */
+/** Lists funding quote providers and their deployment status. */
 export function listProviders(options: listProviders.Options = {}) {
-  return providers
-    .filter((provider) =>
-      options.capability === undefined ? true : provider.capabilities.includes(options.capability),
-    )
-    .map((provider) => ({
-      ...formatProvider(provider),
-      status: options.adapters?.[provider.id] ? ('configured' as const) : provider.status,
-    }))
+  return providers.map((provider) => ({
+    ...formatProvider(provider),
+    status: options.adapters?.[provider.id] ? ('configured' as const) : provider.status,
+  }))
 }
 
 export declare namespace listProviders {
@@ -454,39 +341,19 @@ export declare namespace listProviders {
   type Options = {
     /** Provider adapters configured for this deployment. */
     adapters?: ProviderAdapters | undefined
-    /** Provider capability to require. */
-    capability?: Capability | undefined
   }
 }
 
-/** Parses the comma-separated `include` query parameter. */
-export function parseInclude(input: string | undefined) {
-  if (input === undefined || input.trim() === '') return []
-  const parsed = input
-    .split(',')
-    .map((part) => part.trim())
-    .filter(Boolean)
-  for (const include of parsed)
-    if (!(includes as readonly string[]).includes(include)) throw new UnsupportedIncludeError()
-  return [...new Set(parsed)] as readonly Include[]
-}
-
-/** Lists funding route candidates, enriching static inventory when adapters are configured. */
-export async function listRoutes(options: listRoutes.Options) {
-  const routes = listStaticRoutes(options)
-  const adapterEntries = Object.entries(options.adapters ?? {})
-  if (adapterEntries.length === 0) return routes
-
-  return Promise.all(
-    routes.map((route) =>
-      enrichRoute(route, {
+/** Returns successful live funding quotes from configured providers. */
+export async function listQuotes(options: listQuotes.Options) {
+  const candidates = listQuoteCandidates(options)
+  const results = await Promise.allSettled(
+    candidates.map((candidate) =>
+      quoteCandidate(candidate, {
         adapters: options.adapters ?? {},
         cache: options.cache ?? { bypass: false },
-        include: options.include ?? [],
         request: {
           destinationToken: options.destinationToken,
-          include: options.include ?? [],
-          limit: options.limit,
           provider: options.provider,
           sourceAmount: options.sourceAmount,
           sourceAmountUnits: options.sourceAmountUnits,
@@ -497,10 +364,16 @@ export async function listRoutes(options: listRoutes.Options) {
       }),
     ),
   )
+  const quotes = results.flatMap((result) =>
+    result.status === 'fulfilled' && result.value ? [result.value] : [],
+  )
+  if (quotes.length === 0 && results.some((result) => result.status === 'rejected'))
+    throw new ProviderQuoteError()
+  return quotes
 }
 
-/** Lists static funding route candidates for a normalized caller request. */
-export function listStaticRoutes(options: listStaticRoutes.Options) {
+/** Lists internal quote candidates for a normalized caller request. */
+export function listQuoteCandidates(options: listQuoteCandidates.Options) {
   const sourceChain = resolveSourceChain(options.sourceChain)
   const sourceToken = resolveSourceToken(sourceChain, options.sourceToken)
   const destinationToken = resolveDestinationToken(options.destinationToken)
@@ -522,9 +395,8 @@ export function listStaticRoutes(options: listStaticRoutes.Options) {
     .filter((entry) => entry.sourceTokens.includes(sourceToken.symbol))
     .filter((entry) => entry.destinationToken === destinationToken.slug)
     .filter((entry) => provider === undefined || entry.provider === provider.id)
-    .slice(0, options.limit)
     .map((entry) =>
-      formatRouteCandidate({
+      formatQuoteCandidate({
         destinationToken,
         provider: providers.find((candidate) => candidate.id === entry.provider)!,
         sourceAmount,
@@ -534,13 +406,11 @@ export function listStaticRoutes(options: listStaticRoutes.Options) {
     )
 }
 
-export declare namespace listStaticRoutes {
-  /** Options for listing static funding routes. */
+export declare namespace listQuoteCandidates {
+  /** Options for selecting funding quote candidates. */
   type Options = {
     /** Optional Tempo destination token symbol, address, or token key. */
     destinationToken?: string | undefined
-    /** Maximum number of route candidates to return. */
-    limit: number
     /** Optional provider id filter. */
     provider?: string | undefined
     /** Source amount as supplied by the caller. */
@@ -554,30 +424,23 @@ export declare namespace listStaticRoutes {
   }
 }
 
-export declare namespace listRoutes {
-  /** Options for listing funding routes. */
-  type Options = listStaticRoutes.Options & {
-    /** Provider adapters used to enrich static inventory with live data. */
+export declare namespace listQuotes {
+  /** Options for requesting live funding quotes. */
+  type Options = listQuoteCandidates.Options & {
+    /** Provider adapters used to request live quotes. */
     adapters?: ProviderAdapters | undefined
     /** Per-provider quote timeout in milliseconds. */
     adapterTimeoutMs?: number | undefined
-    /** Cache policy for provider-side inventory, quote, and liquidity lookups. */
+    /** Cache policy for provider-side discovery and quote lookups. */
     cache?: CachePolicy | undefined
-    /** Response expansions requested by the caller. */
-    include?: readonly Include[] | undefined
   }
 }
 
-/** Provider capability identifiers accepted by the generic provider catalog. */
-export type Capability = 'fundingRoutes'
-
-/** Source amount unit accepted by the funding route request. */
+/** Source amount unit accepted by the funding quote request. */
 export type SourceAmountUnits = 'baseUnits' | 'decimal'
 
 function tokenKey(chain: { id: string }, token: TokenInput | DestinationTokenInput) {
-  const standard =
-    token.standard === 'SPL' ? 'spl' : token.standard === 'TRC-20' ? 'trc20' : 'erc20'
-  return `${chain.id}/${standard}:${token.address}`
+  return `${chain.id}/erc20:${token.address}`
 }
 
 function decimalFromBaseUnits(baseUnits: string, decimals: number) {
@@ -587,52 +450,47 @@ function decimalFromBaseUnits(baseUnits: string, decimals: number) {
   return fraction ? `${whole}.${fraction}` : whole
 }
 
-async function enrichRoute(
-  route: RouteCandidate,
+async function quoteCandidate(
+  candidate: QuoteCandidate,
   options: {
     adapters: ProviderAdapters
     cache: CachePolicy
-    include: readonly Include[]
     request: QuoteRequest
     timeoutMs: number
   },
 ) {
-  const adapter = options.adapters[route.provider.id as ProviderId]
-  if (!adapter) return route
-
-  try {
-    const quote = await runWithTimeout(
-      (signal) =>
-        adapter.probeQuote(
-          {
-            cache: options.cache,
-            destinationChain: route.destinationChain,
-            destinationToken: route.destinationToken,
-            include: options.include,
-            request: options.request,
-            route,
-            sourceAmount: route.sourceAmount,
-            sourceChain: route.sourceChain,
-            sourceToken: route.sourceToken,
-          },
-          signal,
-        ),
-      options.timeoutMs,
-    )
-    return {
-      ...route,
-      errorCode: quote.errorCode ?? null,
-      quality: {
-        ...route.quality,
-        ...(quote.status === 'error' ? { tier: 'error' as const } : {}),
-        ...quote.quality,
-      },
-      quote: quote.status === 'error' ? null : formatRouteQuote(route, quote),
-      status: quote.status,
-    }
-  } catch (cause) {
-    return markRouteError(route, cause instanceof ProviderAdapterTimeoutError ? 'provider_timeout' : 'provider_error') // prettier-ignore
-  }
+  const adapter = options.adapters[candidate.provider.id as ProviderId]
+  if (!adapter) return undefined
+
+  const quote = await runWithTimeout(
+    (signal) =>
+      adapter.probeQuote(
+        {
+          cache: options.cache,
+          destinationChain: candidate.destinationChain,
+          destinationToken: candidate.destinationToken,
+          request: options.request,
+          candidate,
+          sourceAmount: candidate.sourceAmount,
+          sourceChain: candidate.sourceChain,
+          sourceToken: candidate.sourceToken,
+        },
+        signal,
+      ),
+    options.timeoutMs,
+  )
+  if (quote.status === 'unavailable') return undefined
+  if (
+    (quote.status !== 'available' && quote.status !== 'thin') ||
+    quote.outputAmount === undefined ||
+    quote.outputAmount === null
+  )
+    throw new ProviderQuoteError()
+  return formatFundingQuote(candidate, {
+    ...quote,
+    outputAmount: quote.outputAmount,
+    status: quote.status,
+  })
 }
 
 function formatChain(chain: SourceChainInput) {
@@ -655,7 +513,7 @@ function formatDestinationToken(token: DestinationTokenInput) {
 
 function formatProvider(provider: ProviderInput) {
   const { id, kind, name, requiresApiKey, status } = provider
-  return { capabilities: [...provider.capabilities], id, kind, name, requiresApiKey, status }
+  return { id, kind, name, requiresApiKey, status }
 }
 
 function formatProviderRef(provider: ProviderInput) {
@@ -663,7 +521,7 @@ function formatProviderRef(provider: ProviderInput) {
   return { id, kind, name, requiresApiKey }
 }
 
-function formatRouteCandidate(options: {
+function formatQuoteCandidate(options: {
   destinationToken: DestinationTokenInput
   provider: ProviderInput
   sourceAmount: ReturnType<typeof resolveSourceAmount>
@@ -673,7 +531,6 @@ function formatRouteCandidate(options: {
   return {
     destinationChain,
     destinationToken: formatDestinationToken(options.destinationToken),
-    errorCode: null,
     id: [
       options.sourceChain.slug,
       options.sourceToken.symbol.toLowerCase(),
@@ -682,22 +539,9 @@ function formatRouteCandidate(options: {
       options.provider.id,
     ].join('-'),
     provider: formatProviderRef(options.provider),
-    quality: {
-      availableVolumeUsd: null,
-      estimatedSeconds: null,
-      feeBps: null,
-      historicalVolumeUsd24h: null,
-      instantVolumeUsd: null,
-      liquiditySource: 'staticInventory',
-      score: null,
-      sourceDetail: null,
-      tier: 'unknown',
-    },
-    quote: null,
     sourceAmount: options.sourceAmount,
     sourceChain: formatChain(options.sourceChain),
     sourceToken: formatSourceToken(options.sourceChain, options.sourceToken),
-    status: 'unknown',
   } as const
 }
 
@@ -732,38 +576,36 @@ function parseDecimalUnits(value: string, decimals: number) {
   return baseUnits.toString()
 }
 
-function formatRouteQuote(route: RouteCandidate, quote: QuoteProbeResult) {
-  return {
-    expiresAt: quote.expiresAt ?? null,
-    inputAmount: route.sourceAmount.amount,
-    limits: quote.limits
-      ? {
-          instantSourceAmount: quote.limits.instantSourceAmount ?? null,
-          maxSourceAmount: quote.limits.maxSourceAmount ?? null,
-          minSourceAmount: quote.limits.minSourceAmount ?? null,
-        }
-      : null,
-    minimumOutputAmount: quote.minimumOutputAmount ?? null,
-    outputAmount: quote.outputAmount ?? null,
-    outputAmountFormatted: quote.outputAmountFormatted ?? null,
-    sampledAt: quote.sampledAt,
-  } as const
+type SuccessfulQuoteProbe = QuoteProbeResult & {
+  outputAmount: string
+  status: 'available' | 'thin'
 }
 
-function markRouteError(route: RouteCandidate, errorCode: string) {
+function formatFundingQuote(candidate: QuoteCandidate, quote: SuccessfulQuoteProbe) {
   return {
-    ...route,
-    errorCode,
+    ...candidate,
     quality: {
-      ...route.quality,
-      liquiditySource: 'providerError',
-      score: null,
-      sourceDetail: null,
-      tier: 'error' as const,
+      ...(quote.quality?.estimatedSeconds !== undefined
+        ? { estimatedSeconds: quote.quality.estimatedSeconds }
+        : {}),
+      liquiditySource: quote.quality?.liquiditySource ?? 'providerQuote',
+      ...(quote.quality?.sourceDetail !== undefined
+        ? { sourceDetail: quote.quality.sourceDetail }
+        : {}),
+      tier: quote.status === 'thin' ? ('thin' as const) : ('liquid' as const),
     },
-    quote: null,
-    status: 'error' as const,
-  }
+    quote: {
+      inputAmount: candidate.sourceAmount.amount,
+      ...(quote.minimumOutputAmount !== undefined
+        ? { minimumOutputAmount: quote.minimumOutputAmount }
+        : {}),
+      outputAmount: quote.outputAmount,
+      outputAmountFormatted:
+        quote.outputAmountFormatted ??
+        decimalFromBaseUnits(quote.outputAmount, candidate.destinationToken.decimals),
+      sampledAt: quote.sampledAt,
+    },
+  } as const
 }
 
 function runWithTimeout<result>(fn: (signal: AbortSignal) => Promise<result>, timeoutMs: number) {
@@ -811,7 +653,6 @@ function resolveSourceAmount(options: resolveSourceAmount.Options) {
   return {
     amount,
     formatted: decimalFromBaseUnits(amount, options.token.decimals),
-    usd: null,
   }
 }
 
@@ -865,30 +706,30 @@ function validateSourceAmountSyntax(value: string, units: SourceAmountUnits) {
 
 /** Error thrown when the caller supplies an unsupported destination token. */
 export class UnsupportedDestinationTokenError extends Error {
-  override name = 'FundingRoutes.UnsupportedDestinationTokenError'
+  override name = 'FundingQuotes.UnsupportedDestinationTokenError'
 }
 
 /** Error thrown when the caller supplies an invalid source amount. */
 export class InvalidAmountError extends Error {
-  override name = 'FundingRoutes.InvalidAmountError'
+  override name = 'FundingQuotes.InvalidAmountError'
 }
 
-/** Error thrown internally when a provider adapter exceeds its route quote timeout. */
+/** Error thrown internally when a provider adapter exceeds its quote timeout. */
 export class ProviderAdapterTimeoutError extends Error {
-  override name = 'FundingRoutes.ProviderAdapterTimeoutError'
+  override name = 'FundingQuotes.ProviderAdapterTimeoutError'
 }
 
-/** Error thrown when the caller filters to an unknown provider. */
-export class UnsupportedProviderError extends Error {
-  override name = 'FundingRoutes.UnsupportedProviderError'
+/** Error thrown when every matching provider fails to produce a quote. */
+export class ProviderQuoteError extends Error {
+  override name = 'FundingQuotes.ProviderQuoteError'
 }
 
-/** Error thrown when the caller requests an unsupported include expansion. */
-export class UnsupportedIncludeError extends Error {
-  override name = 'FundingRoutes.UnsupportedIncludeError'
+/** Error thrown when the caller filters to an unknown provider. */
+export class UnsupportedProviderError extends Error {
+  override name = 'FundingQuotes.UnsupportedProviderError'
 }
 
 /** Error thrown when the caller supplies an unsupported source chain. */
 export class UnsupportedSourceChainError extends Error {
-  override name = 'FundingRoutes.UnsupportedSourceChainError'
+  override name = 'FundingQuotes.UnsupportedSourceChainError'
 }