tapimo 0.4.3 → 0.5.0

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

@@ -4,19 +4,18 @@ 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 FundingQuotes from '../../../internal/FundingQuotes.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
-import * as FundingRouteProviders from '../FundingRouteProviders.js'
 
-/** Zod schemas owned by the funding routes resource. */
+/** Zod schemas owned by funding quote resources. */
 export namespace schema {
   /** Source or destination chain reference. */
   export const Chain = Schema.describe(
     z.object({
       addressFormat: z
-        .enum(['evm', 'solana', 'tron'])
+        .literal('evm')
         .check(
           z.describe('Address family used by accounts and token identifiers on this chain.'),
           z.meta({ examples: ['evm'] }),
@@ -25,12 +24,12 @@ export namespace schema {
         .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.',
+            'Stable CAIP-2 chain id, represented as a string instead of the numeric `chainId` used elsewhere.',
           ),
           z.meta({ examples: ['eip155:8453'] }),
         ),
       kind: z
-        .enum(['evm', 'solana', 'tron'])
+        .literal('evm')
         .check(
           z.describe('Chain execution family used for provider routing.'),
           z.meta({ examples: ['evm'] }),
@@ -41,11 +40,11 @@ export namespace schema {
       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' }] }),
+          z.describe('Provider-specific chain ids Tempo uses when requesting quotes.'),
+          z.meta({ examples: [{ relay: '8453' }] }),
         ),
     }),
-    'A normalized chain reference for funding routes.',
+    'A normalized chain reference for funding quotes.',
   )
 
   /** Source or destination token reference. */
@@ -89,14 +88,14 @@ export namespace schema {
       verified: z
         .boolean()
         .check(
-          z.describe('Whether Tempo recognizes this token in its funding route inventory.'),
+          z.describe('Whether Tempo recognizes this token in its funding quote inventory.'),
           z.meta({ examples: [true] }),
         ),
     }),
-    'A normalized token reference for funding routes.',
+    'A normalized token reference for funding quotes.',
   )
 
-  /** Source amount echoed by a funding route response. */
+  /** Source amount echoed by a funding quote response. */
   export const TokenAmount = Schema.describe(
     z.object({
       amount: Schema.DecimalString.check(
@@ -110,151 +109,88 @@ export namespace schema {
           ),
           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. */
+  /** Provider summary embedded in a funding quote. */
   export const ProviderRef = Schema.describe(
     z.object({
-      id: z.string().check(z.describe('Stable provider id.'), z.meta({ examples: ['across'] })),
+      id: z
+        .literal('relay')
+        .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
       kind: z
         .string()
         .check(
-          z.describe('Provider category, such as an intent bridge, solver network, or aggregator.'),
-          z.meta({ examples: ['intentBridge'] }),
+          z.describe('Provider category, such as a solver network or aggregator.'),
+          z.meta({ examples: ['solverNetwork'] }),
         ),
       name: z
         .string()
-        .check(z.describe('Human-readable provider name.'), z.meta({ examples: ['Across'] })),
+        .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: [true] }),
+          z.meta({ examples: [false] }),
         ),
     }),
-    'Provider metadata embedded in a route candidate.',
+    'Provider metadata embedded in a funding quote.',
   )
 
-  /** Route quality signals exposed directly instead of implied by list order. */
+  /** Quote 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()))
+        .optional(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] }),
+          z.describe('Provider source for the live quote quality signal.'),
+          z.meta({ examples: ['providerQuote'] }),
         ),
       sourceDetail: z
-        .nullable(z.string())
+        .optional(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'])
+        .enum(['liquid', 'thin'])
         .check(
-          z.describe('Machine-readable route quality tier.'),
-          z.meta({ examples: ['unknown'] }),
+          z.describe('Machine-readable quality tier for a successful quote.'),
+          z.meta({ examples: ['liquid'] }),
         ),
     }),
-    'Machine-readable liquidity, fee, and source signals for a route candidate.',
+    'Machine-readable liquidity, fee, and source signals for a successful quote.',
   )
 
-  /** Provider-derived quote data for a route candidate. */
-  export const RouteQuote = Schema.describe(
+  /** Provider-derived output, limits, and freshness data. */
+  export const QuoteDetails = 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)
+        .optional(Schema.DecimalString)
         .check(
           z.describe('Slippage-adjusted minimum destination amount in base units.'),
           z.meta({ examples: ['988000'] }),
         ),
       outputAmount: z
-        .nullable(Schema.DecimalString)
+        .string()
+        .check(z.regex(/^\d+$/))
         .check(
           z.describe('Expected destination amount in base units.'),
           z.meta({ examples: ['989102'] }),
         ),
       outputAmountFormatted: z
-        .nullable(z.string())
+        .string()
         .check(
           z.describe('Expected destination amount rendered with destination token decimals.'),
           z.meta({ examples: ['0.989102'] }),
@@ -262,163 +198,40 @@ export namespace schema {
       sampledAt: z.iso
         .datetime()
         .check(
-          z.describe('Timestamp for the live quote or route probe.'),
+          z.describe('Timestamp for the live quote probe.'),
           z.meta({ examples: ['2026-01-01T00:00:00Z'] }),
         ),
     }),
-    'Provider-derived quote, limit, and freshness data for a route candidate.',
-  )
-
-  /** Token reference attached to a normalized quote fee. */
-  export const QuoteFeeToken = Schema.describe(
-    z.object({
-      address: z
-        .string()
-        .check(
-          z.describe('Contract address of the fee token.'),
-          z.meta({ examples: ['0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] }),
-        ),
-      chainId: z
-        .string()
-        .check(z.describe('CAIP-2 chain id of the fee token.'), z.meta({ examples: ['eip155:8453'] })), // prettier-ignore
-      decimals: z
-        .number()
-        .check(
-          z.int(),
-          z.nonnegative(),
-          z.describe('Number of decimal places used by the fee token.'),
-          z.meta({ examples: [6] }),
-        ),
-      symbol: z
-        .string()
-        .check(z.describe('Ticker symbol of the fee token.'), z.meta({ examples: ['USDC'] })),
-    }),
-    'Token in which a normalized quote fee is denominated.',
-  )
-
-  /** Normalized fee summary for an explicit funding quote. */
-  export const QuoteFee = Schema.describe(
-    z.object({
-      amount: Schema.DecimalString.check(
-        z.describe("Fee amount in the fee token's smallest unit."),
-        z.meta({ examples: ['1200'] }),
-      ),
-      amountUsd: z
-        .nullable(z.string().check(z.regex(/^\d+(\.\d+)?$/)))
-        .check(
-          z.describe('Provider-estimated USD value of the fee.'),
-          z.meta({ examples: ['0.0012'] }),
-        ),
-      bps: z
-        .nullable(z.number().check(z.int(), z.nonnegative()))
-        .check(z.describe('Fee as basis points of the quoted input.'), z.meta({ examples: [12] })),
-      token: QuoteFeeToken,
-    }),
-    'Provider-neutral fee amount and denomination.',
+    'Provider-derived output, limits, and freshness data for a funding quote.',
   )
 
-  /** Explicit depositor-specific quote for one curated funding route. */
+  /** Successful live funding quote. */
   export const FundingQuote = Schema.describe(
-    z.object({
-      destinationChain: Chain.check(z.describe('Destination chain for the quoted route.')),
-      destinationToken: Token.check(z.describe('Token received on the destination chain.')),
-      estimatedSeconds: z
-        .nullable(z.number().check(z.int(), z.nonnegative()))
-        .check(z.describe('Estimated settlement time in seconds.'), z.meta({ examples: [2] })),
-      expiresAt: z.iso
-        .datetime()
-        .check(
-          z.describe('Timestamp after which the quote must not be used.'),
-          z.meta({ examples: ['2026-01-01T00:01:00Z'] }),
-        ),
-      fees: z
-        .object({
-          total: QuoteFee.check(z.describe('Current estimated total fee.')),
-          totalMax: QuoteFee.check(z.describe('Maximum total fee allowed by the quote.')),
-        })
-        .check(z.describe('Current and maximum provider fee summaries.')),
-      inputAmount: Schema.DecimalString.check(
-        z.describe('Exact source amount quoted in base units.'),
-        z.meta({ examples: ['1000000'] }),
-      ),
-      minimumOutputAmount: Schema.DecimalString.check(
-        z.describe('Slippage-adjusted minimum destination amount in base units.'),
-        z.meta({ examples: ['988000'] }),
-      ),
-      outputAmount: Schema.DecimalString.check(
-        z.describe('Expected destination amount in base units.'),
-        z.meta({ examples: ['990000'] }),
-      ),
-      outputAmountFormatted: z
-        .string()
-        .check(
-          z.describe('Expected destination amount rendered with token decimals.'),
-          z.meta({ examples: ['0.99'] }),
-        ),
-      provider: ProviderRef.check(z.describe('Provider that produced the quote.')),
-      routeId: z
-        .string()
-        .check(
-          z.describe('Stable id of the curated route that was quoted.'),
-          z.meta({ examples: ['base-usdc-tempo-usdce-across'] }),
-        ),
-      sampledAt: z.iso
-        .datetime()
-        .check(
-          z.describe('Timestamp when Tempo sampled the provider quote.'),
-          z.meta({ examples: ['2026-01-01T00:00:00Z'] }),
-        ),
-      sourceChain: Chain.check(z.describe('Source chain for the quoted route.')),
-      sourceToken: Token.check(z.describe('Token spent on the source chain.')),
-    }),
-    'Normalized quote information without provider execution payloads.',
-  )
-
-  /** 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'] }),
-        ),
+      destinationToken: Token.check(z.describe('Tempo token expected from this quote.')),
       id: z
         .string()
         .check(
-          z.describe('Stable deterministic route candidate id.'),
-          z.meta({ examples: ['base-usdc-tempo-usdce-across'] }),
+          z.describe('Stable deterministic funding quote id.'),
+          z.meta({ examples: ['base-usdc-tempo-usdce-relay'] }),
         ),
       provider: ProviderRef,
       quality: Quality,
-      quote: z
-        .nullable(RouteQuote)
-        .check(z.describe('Provider-derived quote data, when a live route probe succeeds.')),
+      quote: QuoteDetails,
       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.',
+    'One successful provider-specific funding quote.',
   )
 
-  /** Generic provider catalog entry. */
+  /** Funding quote 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'] })),
+      id: z
+        .literal('relay')
+        .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
       kind: z
         .string()
         .check(z.describe('Provider category.'), z.meta({ examples: ['solverNetwork'] })),
@@ -432,15 +245,15 @@ export namespace schema {
           z.meta({ examples: [false] }),
         ),
       status: z
-        .enum(['configured', 'inventoryOnly', 'planned'])
+        .enum(['configured', 'unconfigured'])
         .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.',
+            '`configured` means live quotes are enabled for this deployment. `unconfigured` means the provider is supported but unavailable here.',
           ),
-          z.meta({ examples: ['inventoryOnly'] }),
+          z.meta({ examples: ['configured', 'unconfigured'] }),
         ),
     }),
-    'One provider in the generic provider catalog.',
+    'One funding quote provider.',
   )
 
   /** Chain inventory entry returned by the funding chains endpoint. */
@@ -451,9 +264,9 @@ export namespace schema {
     'One source chain and its known stablecoin inventory.',
   )
 
-  /** Schemas for the listFundingRoutes operation. */
-  export namespace listFundingRoutes {
-    /** Query parameters for funding route discovery. */
+  /** Schemas for the quoteFunding operation. */
+  export namespace quoteFunding {
+    /** Query parameters for live funding quotes. */
     export const Query = z
       .strictObject({
         destinationToken: z
@@ -464,26 +277,21 @@ export namespace schema {
             ),
             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())
+          .optional(z.literal('relay'))
           .check(
             z.describe(
-              'Only return candidates from this provider id, such as `across`, `relay`, or `bridge`. Planned providers can return an empty list.',
+              'Only request a quote from this provider. The supported id is `relay`; omit it to query every configured provider.',
             ),
-            z.meta({ examples: ['across', 'bridge'] }),
+            z.meta({ examples: ['relay'] }),
           ),
         sourceAmount: z
           .string()
           .check(
-            z.minLength(1),
-            z.describe('Source token amount. Base units by default, so 1 USDC is `1000000`.'),
+            z.regex(/^(?=.*[1-9])\d+(\.\d+)?$/),
+            z.describe(
+              'Positive source token amount. Base units by default, so 1 USDC is `1000000`.',
+            ),
             z.meta({ examples: ['1000000'] }),
           ),
         sourceAmountUnits: z
@@ -493,98 +301,33 @@ export namespace schema {
             z.meta({ examples: ['baseUnits', 'decimal'] }),
           ),
         sourceChain: z
+          .string()
+          .check(
+            z.minLength(1),
+            z.describe('Source chain alias or CAIP-2 id, such as `base` or `eip155:8453`.'),
+            z.meta({ examples: ['base', 'eip155:8453'] }),
+          ),
+        sourceToken: z
           .string()
           .check(
             z.minLength(1),
             z.describe(
-              'Source chain alias or CAIP-2 id, such as `base`, `solana`, `tron`, or `eip155:8453`.',
+              'Source token symbol, contract address, or Tempo token key. Symbol and address lookup is scoped to `sourceChain` and case-insensitive. An unknown token returns an empty list.',
             ),
-            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', '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] }),
           ),
-          z.meta({
-            examples: [
-              'USDC',
-              'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-              'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-            ],
-          }),
-        ),
       })
-      .check(z.describe('Query parameters for discovering funding routes into Tempo.'))
+      .check(z.describe('Query parameters for live funding quotes into Tempo.'))
 
-    /** Non-paginated list of funding route candidates. */
+    /** Non-paginated list of successful funding quotes. */
     export const Response = Schema.describe(
       z.object({
-        data: z
-          .array(RouteCandidate)
-          .check(z.describe('Funding route candidates matching the request.')),
+        data: z.array(FundingQuote).check(z.describe('Successful live funding quotes.')),
       }),
-      'A non-paginated list of funding route candidates.',
+      'A non-paginated list of successful live funding quotes.',
     )
   }
 
-  /** Schemas for the quoteFundingRoute operation. */
-  export namespace quoteFundingRoute {
-    /** JSON body for an explicit funding route quote. */
-    export const Body = z
-      .strictObject({
-        depositor: Schema.Address.check(
-          z.describe('Address that would submit the funding transaction.'),
-        ),
-        destinationToken: z
-          .optional(z.string())
-          .check(
-            z.describe('Tempo destination token symbol, address, or token key.'),
-            z.meta({ examples: ['USDC.e'] }),
-          ),
-        provider: z
-          .literal('across')
-          .check(
-            z.describe('Provider id selected from funding route discovery.'),
-            z.meta({ examples: ['across'] }),
-          ),
-        recipient: z
-          .optional(Schema.Address)
-          .check(z.describe('Optional destination recipient; defaults to the depositor.')),
-        sourceAmount: z
-          .string()
-          .check(
-            z.minLength(1),
-            z.describe('Exact source amount to quote.'),
-            z.meta({ examples: ['1000000'] }),
-          ),
-        sourceAmountUnits: z
-          ._default(z.enum(['baseUnits', 'decimal']), 'baseUnits')
-          .check(
-            z.describe('Whether `sourceAmount` uses base units or decimal notation.'),
-            z.meta({ examples: ['baseUnits'] }),
-          ),
-        sourceChain: z
-          .string()
-          .check(
-            z.minLength(1),
-            z.describe('Source chain alias or CAIP-2 id.'),
-            z.meta({ examples: ['base'] }),
-          ),
-        sourceToken: z
-          .string()
-          .check(
-            z.minLength(1),
-            z.describe('Source token symbol, address, mint, or token key.'),
-            z.meta({ examples: ['USDC'] }),
-          ),
-      })
-      .check(z.describe('Parameters for a depositor-specific exact-input funding quote.'))
-
-    /** Normalized funding quote without provider execution payloads. */
-    export const Response = FundingQuote
-  }
-
   /** Schemas for the listFundingChains operation. */
   export namespace listFundingChains {
     /** Non-paginated source-chain inventory. */
@@ -592,7 +335,7 @@ export namespace schema {
       z.object({
         data: z
           .array(ChainInventory)
-          .check(z.describe('Source chains and stablecoins known to the funding route API.')),
+          .check(z.describe('Source chains and stablecoins supported by funding quotes.')),
       }),
       'A non-paginated list of source chains and stablecoin inventory.',
     )
@@ -600,168 +343,89 @@ export namespace schema {
 
   /** 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. */
+    /** Non-paginated funding quote provider catalog. */
     export const Response = Schema.describe(
       z.object({
-        data: z.array(Provider).check(z.describe("Providers in Tempo's generic provider catalog.")),
+        data: z.array(Provider).check(z.describe("Providers in Tempo's funding quote catalog.")),
       }),
-      'A non-paginated list of providers.',
+      'A non-paginated list of funding quote 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 fundingQuoteResponseExample = (() => {
+  const [candidate] = FundingQuotes.listQuoteCandidates({
+    provider: 'relay',
+    sourceAmount: '1000000',
+    sourceAmountUnits: 'baseUnits',
+    sourceChain: 'base',
+    sourceToken: 'USDC',
+  })
+  if (!candidate) throw new Error('Missing Relay funding quote example candidate')
+  return {
+    data: [
+      {
+        ...candidate,
+        quality: {
+          estimatedSeconds: 1,
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'relay:quote-v2',
+          tier: 'liquid',
+        },
+        quote: {
+          inputAmount: '1000000',
+          minimumOutputAmount: '939242',
+          outputAmount: '979295',
+          outputAmountFormatted: '0.979295',
+          sampledAt: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    ],
+  }
+})() satisfies z.output<typeof schema.quoteFunding.Response>
 
 const fundingChainsResponseExample = {
-  data: FundingRoutes.listChains(),
+  data: FundingQuotes.listChains(),
 } satisfies z.output<typeof schema.listFundingChains.Response>
 
 const providersResponseExample = {
-  data: FundingRoutes.listProviders(),
+  data: FundingQuotes.listProviders().map((provider) => ({
+    ...provider,
+    status: 'configured' as const,
+  })),
 } satisfies z.output<typeof schema.listProviders.Response>
 
-const [fundingQuoteRouteExample] = FundingRoutes.listStaticRoutes({
-  destinationToken: 'USDC.e',
-  limit: 1,
-  provider: 'across',
-  sourceAmount: '1000000',
-  sourceAmountUnits: 'baseUnits',
-  sourceChain: 'base',
-  sourceToken: 'USDC',
-})
-
-const fundingQuoteResponseExample = {
-  destinationChain: fundingQuoteRouteExample!.destinationChain,
-  destinationToken: fundingQuoteRouteExample!.destinationToken,
-  estimatedSeconds: 2,
-  expiresAt: '2026-01-01T00:01:00Z',
-  fees: {
-    total: {
-      amount: '1200',
-      amountUsd: '0.0012',
-      bps: 12,
-      token: {
-        address: fundingQuoteRouteExample!.sourceToken.address,
-        chainId: fundingQuoteRouteExample!.sourceChain.id,
-        decimals: fundingQuoteRouteExample!.sourceToken.decimals,
-        symbol: fundingQuoteRouteExample!.sourceToken.symbol,
-      },
-    },
-    totalMax: {
-      amount: '1800',
-      amountUsd: '0.0018',
-      bps: 18,
-      token: {
-        address: fundingQuoteRouteExample!.sourceToken.address,
-        chainId: fundingQuoteRouteExample!.sourceChain.id,
-        decimals: fundingQuoteRouteExample!.sourceToken.decimals,
-        symbol: fundingQuoteRouteExample!.sourceToken.symbol,
-      },
-    },
-  },
-  inputAmount: '1000000',
-  minimumOutputAmount: '988000',
-  outputAmount: '990000',
-  outputAmountFormatted: '0.99',
-  provider: fundingQuoteRouteExample!.provider,
-  routeId: fundingQuoteRouteExample!.id,
-  sampledAt: '2026-01-01T00:00:00Z',
-  sourceChain: fundingQuoteRouteExample!.sourceChain,
-  sourceToken: fundingQuoteRouteExample!.sourceToken,
-} satisfies z.output<typeof schema.quoteFundingRoute.Response>
-
-/** Mounts funding route discovery and generic provider inventory endpoints. */
+/** Mounts live funding quotes and their supporting inventory endpoints. */
 export function funding(options: funding.Options = {}) {
   return new Hono<App.Environment>()
     .get(
-      '/v1/funding/routes',
+      '/v1/funding/quotes',
       Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
-      OpenApi.validate('query', schema.listFundingRoutes.Query, {
+      OpenApi.validate('query', schema.quoteFunding.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',
+          'Returns live quotes for funding Tempo with a stablecoin. Omit `provider` to query all configured providers. This endpoint does not execute a transfer.',
+        operationId: 'quoteFunding',
         responses: OpenApi.responses({
-          errors: { 400: { codes: ['query_invalid'] } },
+          errors: {
+            400: { codes: ['query_invalid'] },
+            502: {
+              codes: ['upstream_error'],
+              description: 'Every matching quote provider failed unexpectedly.',
+            },
+          },
           success: {
-            description:
-              'Discovery-only funding route candidates for the requested source chain and token.',
-            examples: fundingRouteResponseExamples,
-            schema: schema.listFundingRoutes.Response,
+            description: 'Live funding quotes. An empty list means no provider returned a quote.',
+            example: fundingQuoteResponseExample,
+            schema: schema.quoteFunding.Response,
           },
         }),
-        summary: 'List funding routes',
+        summary: 'Get funding quotes',
         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)
@@ -772,16 +436,14 @@ export function funding(options: funding.Options = {}) {
 
         const query = c.req.valid('query')
         try {
-          const include = FundingRoutes.parseInclude(query.include)
+          c.header('Cache-Control', 'no-store')
           return c.json(
-            Response.validated(schema.listFundingRoutes.Response, {
-              data: await FundingRoutes.listRoutes({
+            Response.validated(schema.quoteFunding.Response, {
+              data: await FundingQuotes.listQuotes({
                 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,
@@ -794,103 +456,12 @@ export function funding(options: funding.Options = {}) {
         } catch (cause) {
           const message = requestErrorMessage(cause)
           if (message) return Response.error(c, { code: 'query_invalid', message, status: 400 })
-          throw cause
-        }
-      },
-    )
-    .post(
-      '/v1/funding/routes/quote',
-      Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
-      OpenApi.validate('json', schema.quoteFundingRoute.Body, {
-        code: 'body_invalid',
-        message: 'Invalid quote parameters',
-      }),
-      OpenApi.describeRoute({
-        description:
-          'Gets a depositor-specific exact-input quote for one curated funding route. The response excludes provider transaction calldata, approvals, and wallet balance details.',
-        operationId: 'quoteFundingRoute',
-        responses: OpenApi.responses({
-          errors: {
-            400: { codes: ['body_invalid'] },
-            404: { codes: ['route_not_found', 'quote_unavailable'] },
-            501: { codes: ['provider_unconfigured'] },
-            502: { codes: ['provider_error', 'provider_rate_limited', 'provider_timeout'] },
-          },
-          success: {
-            description: 'Normalized route quote without provider execution payloads.',
-            example: fundingQuoteResponseExample,
-            schema: schema.quoteFundingRoute.Response,
-          },
-        }),
-        summary: 'Quote funding route',
-        tags: ['Funding'],
-      }),
-      async (c) => {
-        if (Auth.narrowAccess) return Auth.paidAccessError(c)
-        if (OpenApi.narrowValidation)
-          return OpenApi.validationError(c, {
-            code: 'body_invalid',
-            message: 'Invalid quote parameters',
-          })
-
-        const body = c.req.valid('json')
-        try {
-          const quote = await FundingRoutes.quoteRoute({
-            depositor: body.depositor,
-            destinationToken: body.destinationToken,
-            provider: body.provider,
-            quote: options.acrossQuote,
-            quoteTimeoutMs: options.quoteTimeoutMs,
-            recipient: body.recipient,
-            sourceAmount: body.sourceAmount,
-            sourceAmountUnits: body.sourceAmountUnits,
-            sourceChain: body.sourceChain,
-            sourceToken: body.sourceToken,
-          })
-          c.header('Cache-Control', 'no-store')
-          return c.json(Response.validated(schema.quoteFundingRoute.Response, quote), 200)
-        } catch (cause) {
-          const message = requestErrorMessage(cause)
-          if (message) return Response.error(c, { code: 'body_invalid', message, status: 400 })
-          if (cause instanceof FundingRoutes.FundingRouteNotFoundError)
+          if (cause instanceof FundingQuotes.ProviderQuoteError)
             return Response.error(c, {
-              code: 'route_not_found',
-              message: 'No curated funding route matches the request.',
-              status: 404,
-            })
-          if (cause instanceof FundingRoutes.ProviderQuoteUnavailableError)
-            return Response.error(c, {
-              code: 'quote_unavailable',
-              message: 'The provider cannot quote this route.',
-              status: 404,
-            })
-          if (cause instanceof FundingRoutes.ProviderNotConfiguredError)
-            return Response.error(c, {
-              code: 'provider_unconfigured',
-              message: 'The provider quote integration is not configured.',
-              status: 501,
-            })
-          if (cause instanceof FundingRoutes.ProviderRateLimitError)
-            return Response.error(c, {
-              code: 'provider_rate_limited',
-              message: 'The provider temporarily rate-limited this quote.',
+              code: 'upstream_error',
+              message: 'Quote providers could not complete the request.',
               status: 502,
             })
-          if (cause instanceof FundingRoutes.ProviderAdapterTimeoutError)
-            return Response.error(c, {
-              code: 'provider_timeout',
-              message: 'The provider quote timed out.',
-              status: 502,
-            })
-          if (cause instanceof Error) {
-            const providerFailure = FundingRouteProviders.acrossQuoteFailure({ cause })
-            if (providerFailure) c.set('providerFailure', providerFailure)
-            return Response.error(c, {
-              code: 'provider_error',
-              message: 'The provider could not complete the quote.',
-              status: 502,
-            })
-          }
           throw cause
         }
       },
@@ -900,11 +471,11 @@ export function funding(options: funding.Options = {}) {
       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.',
+          'Lists the source chains and stablecoins you can use when requesting a funding quote.',
         operationId: 'listFundingChains',
         responses: OpenApi.responses({
           success: {
-            description: 'Source-chain and stablecoin inventory for funding route discovery.',
+            description: 'Supported source chains and stablecoins.',
             example: fundingChainsResponseExample,
             schema: schema.listFundingChains.Response,
           },
@@ -921,55 +492,39 @@ export function funding(options: funding.Options = {}) {
         if (Auth.narrowAccess) return Auth.paidAccessError(c)
         return c.json(
           Response.validated(schema.listFundingChains.Response, {
-            data: FundingRoutes.listChains(),
+            data: FundingQuotes.listChains(),
           }),
           200,
         )
       },
     )
     .get(
-      '/v1/providers',
+      '/v1/funding/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',
+          'Lists funding quote providers and whether live quoting is configured for this deployment.',
+        operationId: 'listFundingProviders',
         responses: OpenApi.responses({
-          errors: { 400: { codes: ['query_invalid'] } },
           success: {
-            description: 'Providers known to Tempo.',
+            description: 'Funding quote providers supported by Tempo.',
             example: providersResponseExample,
             schema: schema.listProviders.Response,
           },
         }),
-        summary: 'List providers',
-        tags: ['Providers'],
+        summary: 'List funding providers',
+        tags: ['Funding'],
       }),
       Cache.response<App.Environment>({
         cacheControl: Cache.policies.stable,
-        name: 'tempo-api:providers:v1',
-        key: (c) => Cache.urlKey(c, schema.listProviders.Query),
+        name: 'tempo-api:funding-providers:v1',
+        key: (c) => c.req.url,
       }),
       (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,
-              configuredProviders: options.acrossQuote ? ['across'] : [],
-            }),
+            data: FundingQuotes.listProviders({ adapters: options.adapters }),
           }),
           200,
         )
@@ -978,27 +533,22 @@ export function funding(options: funding.Options = {}) {
 }
 
 export declare namespace funding {
-  /** Options for funding route discovery. */
+  /** Options for live funding quotes. */
   type Options = {
-    /** Across explicit quote capability. */
-    acrossQuote?: FundingRoutes.ProviderQuote | undefined
-    /** Provider adapters used to enrich static inventory with live data. */
-    adapters?: FundingRoutes.ProviderAdapters | undefined
+    /** Provider adapters used to request live quotes. */
+    adapters?: FundingQuotes.ProviderAdapters | undefined
     /** Per-provider quote timeout in milliseconds. */
     adapterTimeoutMs?: number | undefined
-    /** Timeout for depositor-specific provider quotes. */
-    quoteTimeoutMs?: 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)
+  if (cause instanceof FundingQuotes.InvalidAmountError) return 'Invalid `sourceAmount`.'
+  if (cause instanceof FundingQuotes.UnsupportedDestinationTokenError)
     return 'Unsupported `destinationToken`.'
-  if (cause instanceof FundingRoutes.UnsupportedProviderError) return 'Unsupported `provider`.'
-  if (cause instanceof FundingRoutes.UnsupportedSourceChainError)
+  if (cause instanceof FundingQuotes.UnsupportedProviderError) return 'Unsupported `provider`.'
+  if (cause instanceof FundingQuotes.UnsupportedSourceChainError)
     return 'Unsupported `sourceChain`.'
   return undefined
 }