tapimo 0.4.3 → 0.5.0

package/dist/apps/data/routes/funding.js

@@ -2,32 +2,31 @@ import { Hono } from 'hono';
 import * as z from 'zod/mini';
 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 var schema;
 (function (schema) {
     /** Source or destination chain reference. */
     schema.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'] })),
         id: z
             .string()
-            .check(z.describe('Stable chain id, preferably CAIP-2 when one exists. Funding spans non-EVM chains, so ids are strings, unlike numeric `chainId` params elsewhere.'), z.meta({ examples: ['eip155:8453'] })),
+            .check(z.describe('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'] })),
         name: z
             .string()
             .check(z.describe('Human-readable chain name.'), z.meta({ examples: ['Base'] })),
         providerIds: z
             .optional(z.record(z.string(), z.string()))
-            .check(z.describe('Provider-specific chain ids Tempo uses when querying route providers.'), z.meta({ examples: [{ across: '8453', relay: '8453' }] })),
-    }), 'A normalized chain reference for funding routes.');
+            .check(z.describe('Provider-specific chain ids Tempo uses when requesting quotes.'), z.meta({ examples: [{ relay: '8453' }] })),
+    }), 'A normalized chain reference for funding quotes.');
     /** Source or destination token reference. */
     schema.Token = Schema.describe(z.object({
         address: z
@@ -53,179 +52,81 @@ export var schema;
         })),
         verified: z
             .boolean()
-            .check(z.describe('Whether Tempo recognizes this token in its funding route inventory.'), z.meta({ examples: [true] })),
-    }), 'A normalized token reference for funding routes.');
-    /** Source amount echoed by a funding route response. */
+            .check(z.describe('Whether Tempo recognizes this token in its funding quote inventory.'), z.meta({ examples: [true] })),
+    }), 'A normalized token reference for funding quotes.');
+    /** Source amount echoed by a funding quote response. */
     schema.TokenAmount = Schema.describe(z.object({
         amount: Schema.DecimalString.check(z.describe("The requested source amount in the token's smallest unit.")),
         formatted: z
             .string()
             .check(z.describe('The same amount in human-readable decimal form, using the source token’s `decimals`.'), z.meta({ examples: ['1'] })),
-        usd: z
-            .nullable(z.string())
-            .check(z.describe('USD estimate for the requested source amount, when available.'), z.meta({ examples: ['1.00'] })),
     }), 'The requested source amount in provider-safe base units and display form.');
-    /** Provider summary embedded in a route candidate. */
+    /** Provider summary embedded in a funding quote. */
     schema.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'] })),
+            .check(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] })),
-    }), 'Provider metadata embedded in a route candidate.');
-    /** Route quality signals exposed directly instead of implied by list order. */
+            .check(z.describe('Whether Tempo needs provider credentials to query or use this provider.'), z.meta({ examples: [false] })),
+    }), 'Provider metadata embedded in a funding quote.');
+    /** Quote quality signals exposed directly instead of implied by list order. */
     schema.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] })),
+            .check(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'])
-            .check(z.describe('Machine-readable route quality tier.'), z.meta({ examples: ['unknown'] })),
-    }), 'Machine-readable liquidity, fee, and source signals for a route candidate.');
-    /** Provider-derived quote data for a route candidate. */
-    schema.RouteQuote = Schema.describe(z.object({
-        expiresAt: z
-            .nullable(z.iso.datetime())
-            .check(z.describe('Provider quote expiry timestamp.'), z.meta({ examples: ['2026-01-01T00:00:30Z'] })),
+            .enum(['liquid', 'thin'])
+            .check(z.describe('Machine-readable quality tier for a successful quote.'), z.meta({ examples: ['liquid'] })),
+    }), 'Machine-readable liquidity, fee, and source signals for a successful quote.');
+    /** Provider-derived output, limits, and freshness data. */
+    schema.QuoteDetails = Schema.describe(z.object({
         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'] })),
         sampledAt: z.iso
             .datetime()
-            .check(z.describe('Timestamp for the live quote or route probe.'), z.meta({ examples: ['2026-01-01T00:00:00Z'] })),
-    }), 'Provider-derived quote, limit, and freshness data for a route candidate.');
-    /** Token reference attached to a normalized quote fee. */
-    schema.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. */
-    schema.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: schema.QuoteFeeToken,
-    }), 'Provider-neutral fee amount and denomination.');
-    /** Explicit depositor-specific quote for one curated funding route. */
+            .check(z.describe('Timestamp for the live quote probe.'), z.meta({ examples: ['2026-01-01T00:00:00Z'] })),
+    }), 'Provider-derived output, limits, and freshness data for a funding quote.');
+    /** Successful live funding quote. */
     schema.FundingQuote = Schema.describe(z.object({
-        destinationChain: schema.Chain.check(z.describe('Destination chain for the quoted route.')),
-        destinationToken: schema.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: schema.QuoteFee.check(z.describe('Current estimated total fee.')),
-            totalMax: schema.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: schema.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: schema.Chain.check(z.describe('Source chain for the quoted route.')),
-        sourceToken: schema.Token.check(z.describe('Token spent on the source chain.')),
-    }), 'Normalized quote information without provider execution payloads.');
-    /** Static or live funding route candidate. */
-    schema.RouteCandidate = Schema.describe(z.object({
         destinationChain: schema.Chain.check(z.describe('Destination chain, always Tempo mainnet in V1.')),
-        destinationToken: schema.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: schema.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'] })),
+            .check(z.describe('Stable deterministic funding quote id.'), z.meta({ examples: ['base-usdc-tempo-usdce-relay'] })),
         provider: schema.ProviderRef,
         quality: schema.Quality,
-        quote: z
-            .nullable(schema.RouteQuote)
-            .check(z.describe('Provider-derived quote data, when a live route probe succeeds.')),
+        quote: schema.QuoteDetails,
         sourceAmount: schema.TokenAmount,
         sourceChain: schema.Chain.check(z.describe('Chain where the caller currently holds funds.')),
         sourceToken: schema.Token.check(z.describe('Token the caller currently holds.')),
-        status: z
-            .enum(['available', 'thin', 'unknown', 'unavailable', 'error'])
-            .check(z.describe('Provider-specific route status for the requested amount.'), z.meta({ examples: ['unknown'] })),
-    }), 'One provider-specific funding route candidate.');
-    /** Generic provider catalog entry. */
+    }), 'One successful provider-specific funding quote.');
+    /** Funding quote provider catalog entry. */
     schema.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'] })),
@@ -236,87 +137,44 @@ export var schema;
             .boolean()
             .check(z.describe('Whether Tempo needs provider credentials to query or use this provider.'), z.meta({ examples: [false] })),
         status: z
-            .enum(['configured', 'inventoryOnly', 'planned'])
-            .check(z.describe('`inventoryOnly` means Tempo exposes static route support but does not query live quotes yet. `planned` means the provider is listed for future support and may not return route candidates.'), z.meta({ examples: ['inventoryOnly'] })),
-    }), 'One provider in the generic provider catalog.');
+            .enum(['configured', 'unconfigured'])
+            .check(z.describe('`configured` means live quotes are enabled for this deployment. `unconfigured` means the provider is supported but unavailable here.'), z.meta({ examples: ['configured', 'unconfigured'] })),
+    }), 'One funding quote provider.');
     /** Chain inventory entry returned by the funding chains endpoint. */
     schema.ChainInventory = Schema.describe(z.extend(schema.Chain, {
         tokens: z.array(schema.Token).check(z.describe('Stablecoins known on this source chain.')),
     }), 'One source chain and its known stablecoin inventory.');
-    /** Schemas for the listFundingRoutes operation. */
-    let listFundingRoutes;
-    (function (listFundingRoutes) {
-        /** Query parameters for funding route discovery. */
-        listFundingRoutes.Query = z
+    /** Schemas for the quoteFunding operation. */
+    let quoteFunding;
+    (function (quoteFunding) {
+        /** Query parameters for live funding quotes. */
+        quoteFunding.Query = z
             .strictObject({
             destinationToken: z
                 .optional(z.string())
                 .check(z.describe('Tempo destination token symbol, address, or token key. Defaults to USDC.e.'), z.meta({ examples: ['USDC.e'] })),
-            include: z
-                .optional(z.string())
-                .check(z.describe('Comma-separated response expansions. V1 accepts `quotes`.'), z.meta({ examples: ['quotes'] })),
-            limit: Schema.Limit,
             provider: z
-                .optional(z.string())
-                .check(z.describe('Only return candidates from this provider id, such as `across`, `relay`, or `bridge`. Planned providers can return an empty list.'), z.meta({ examples: ['across', 'bridge'] })),
+                .optional(z.literal('relay'))
+                .check(z.describe('Only request a quote from this provider. The supported id is `relay`; omit it to query every configured provider.'), 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.meta({ examples: ['1000000'] })),
+                .check(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
                 ._default(z.enum(['baseUnits', 'decimal']), 'baseUnits')
                 .check(z.describe('Whether `sourceAmount` is base units or a human-readable decimal.'), z.meta({ examples: ['baseUnits', 'decimal'] })),
             sourceChain: z
                 .string()
-                .check(z.minLength(1), z.describe('Source chain alias or CAIP-2 id, such as `base`, `solana`, `tron`, or `eip155:8453`.'), z.meta({ examples: ['base', 'solana', 'tron'] })),
-            sourceToken: z.string().check(z.minLength(1), z.describe('Source token symbol, contract address, mint, or Tempo token key. Symbol lookup is scoped to `sourceChain`; EVM identifiers are case-insensitive, while Solana and Tron identifiers must match exactly. An unknown token returns an empty list, not an error.'), z.meta({
-                examples: [
-                    'USDC',
-                    'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-                    'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-                ],
-            })),
-        })
-            .check(z.describe('Query parameters for discovering funding routes into Tempo.'));
-        /** Non-paginated list of funding route candidates. */
-        listFundingRoutes.Response = Schema.describe(z.object({
-            data: z
-                .array(schema.RouteCandidate)
-                .check(z.describe('Funding route candidates matching the request.')),
-        }), 'A non-paginated list of funding route candidates.');
-    })(listFundingRoutes = schema.listFundingRoutes || (schema.listFundingRoutes = {}));
-    /** Schemas for the quoteFundingRoute operation. */
-    let quoteFundingRoute;
-    (function (quoteFundingRoute) {
-        /** JSON body for an explicit funding route quote. */
-        quoteFundingRoute.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'] })),
+                .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 token symbol, address, mint, or token key.'), z.meta({ examples: ['USDC'] })),
+                .check(z.minLength(1), z.describe('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: ['USDC', '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] })),
         })
-            .check(z.describe('Parameters for a depositor-specific exact-input funding quote.'));
-        /** Normalized funding quote without provider execution payloads. */
-        quoteFundingRoute.Response = schema.FundingQuote;
-    })(quoteFundingRoute = schema.quoteFundingRoute || (schema.quoteFundingRoute = {}));
+            .check(z.describe('Query parameters for live funding quotes into Tempo.'));
+        /** Non-paginated list of successful funding quotes. */
+        quoteFunding.Response = Schema.describe(z.object({
+            data: z.array(schema.FundingQuote).check(z.describe('Successful live funding quotes.')),
+        }), 'A non-paginated list of successful live funding quotes.');
+    })(quoteFunding = schema.quoteFunding || (schema.quoteFunding = {}));
     /** Schemas for the listFundingChains operation. */
     let listFundingChains;
     (function (listFundingChains) {
@@ -324,148 +182,83 @@ export var schema;
         listFundingChains.Response = Schema.describe(z.object({
             data: z
                 .array(schema.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.');
     })(listFundingChains = schema.listFundingChains || (schema.listFundingChains = {}));
     /** Schemas for the listProviders operation. */
     let listProviders;
     (function (listProviders) {
-        /** Query parameters for the generic provider catalog. */
-        listProviders.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. */
         listProviders.Response = Schema.describe(z.object({
-            data: z.array(schema.Provider).check(z.describe("Providers in Tempo's generic provider catalog.")),
-        }), 'A non-paginated list of providers.');
+            data: z.array(schema.Provider).check(z.describe("Providers in Tempo's funding quote catalog.")),
+        }), 'A non-paginated list of funding quote providers.');
     })(listProviders = schema.listProviders || (schema.listProviders = {}));
 })(schema || (schema = {}));
-// 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',
-            }),
-        },
-    },
-    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',
-            }),
-        },
-    },
-    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',
-            }),
-        },
-    },
-};
+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',
+                },
+            },
+        ],
+    };
+})();
 const fundingChainsResponseExample = {
-    data: FundingRoutes.listChains(),
+    data: FundingQuotes.listChains(),
 };
 const providersResponseExample = {
-    data: FundingRoutes.listProviders(),
-};
-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,
+    data: FundingQuotes.listProviders().map((provider) => ({
+        ...provider,
+        status: 'configured',
+    })),
 };
-/** Mounts funding route discovery and generic provider inventory endpoints. */
+/** Mounts live funding quotes and their supporting inventory endpoints. */
 export function funding(options = {}) {
     return new Hono()
-        .get('/v1/funding/routes', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), OpenApi.validate('query', schema.listFundingRoutes.Query, {
+        .get('/v1/funding/quotes', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), 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',
+        description: '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({
-        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);
@@ -476,15 +269,13 @@ export function funding(options = {}) {
             });
         const query = c.req.valid('query');
         try {
-            const include = FundingRoutes.parseInclude(query.include);
-            return c.json(Response.validated(schema.listFundingRoutes.Response, {
-                data: await FundingRoutes.listRoutes({
+            c.header('Cache-Control', 'no-store');
+            return c.json(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,
@@ -497,108 +288,21 @@ export function funding(options = {}) {
             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)
-                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.',
-                    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);
+            if (cause instanceof FundingQuotes.ProviderQuoteError)
                 return Response.error(c, {
-                    code: 'provider_error',
-                    message: 'The provider could not complete the quote.',
+                    code: 'upstream_error',
+                    message: 'Quote providers could not complete the request.',
                     status: 502,
                 });
-            }
             throw cause;
         }
     })
         .get('/v1/funding/chains', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), OpenApi.describeRoute({
-        description: 'Lists source chains and stablecoins understood by the funding route API, including provider-specific ids useful when comparing provider docs. This is static inventory metadata, not a live liquidity check.',
+        description: '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,
             },
@@ -613,58 +317,42 @@ export function 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', 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',
+        .get('/v1/funding/providers', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), OpenApi.describeRoute({
+        description: '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({
         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);
     });
 }
 // Maps caller-input errors to a specific 400 message; anything else rethrows.
 function requestErrorMessage(cause) {
-    if (cause instanceof FundingRoutes.InvalidAmountError)
+    if (cause instanceof FundingQuotes.InvalidAmountError)
         return 'Invalid `sourceAmount`.';
-    if (cause instanceof FundingRoutes.UnsupportedIncludeError)
-        return 'Unsupported `include`.';
-    if (cause instanceof FundingRoutes.UnsupportedDestinationTokenError)
+    if (cause instanceof FundingQuotes.UnsupportedDestinationTokenError)
         return 'Unsupported `destinationToken`.';
-    if (cause instanceof FundingRoutes.UnsupportedProviderError)
+    if (cause instanceof FundingQuotes.UnsupportedProviderError)
         return 'Unsupported `provider`.';
-    if (cause instanceof FundingRoutes.UnsupportedSourceChainError)
+    if (cause instanceof FundingQuotes.UnsupportedSourceChainError)
         return 'Unsupported `sourceChain`.';
     return undefined;
 }