@fun-xyz/fiat-contract 0.22.1 → 0.23.0

package/README.md

@@ -13,7 +13,7 @@ Four things, zero runtime logic beyond validation:
 | `src/table.ts` | the transition table **as data**: per state, its legal transition set, the states any call from it may return, and `terminal: boolean` |
 | `src/assert.ts` + `src/fixtures/` | `assertFiatStepResponse` · `assertLegalEmission` · `assertLegalReturn` · `walkTable` · fixture loader + 18 recorded step responses (inlined as data — no filesystem, so React Native can bundle it) |
 
-## Five entry points — production vs test-time
+## Six entry points — production vs test-time
 
 | Import | Weight | Contains | Used by |
 | --- | --- | --- | --- |
@@ -21,7 +21,8 @@ Four things, zero runtime logic beyond validation:
 | `@fun-xyz/fiat-contract/table` | **13.8 KB**, zero deps | `TRANSITION_TABLE`, `stateKey`, `tableEntry`, `isTerminal`, `walkTable`, `TABLE_VERSION`, `TERMINAL_ORDER_STATUSES`, `DOCUMENTED_ENDPOINTS`, `UNOFFERED_ENDPOINTS`, `UNREACHABLE_STATES`, `unofferedEndpoints`, `unreachableStates` | **production frontend** + backend |
 | `@fun-xyz/fiat-contract/moonpay` | zero deps | the MoonPay provider-owned flow: `intent` request kinds, response statuses and fault types, and `MOONPAY_ENDPOINTS` | **production frontend** (MoonPay adapter) + backend |
 | `@fun-xyz/fiat-contract/terms` | zero deps | the platform terms route: `TermsDocument`, `FiatTermsRequest`, `FiatTermsResponse`, fault types, and `FIAT_TERMS_ENDPOINT` | **production frontend** + backend |
-| `@fun-xyz/fiat-contract` | 47.6 KB, needs zod | the above + 46 zod schemas + assertions + 18 fixtures | tests, and backend dev/test guards |
+| `@fun-xyz/fiat-contract/routing` | zero deps | the routing table and routing quote: `FiatRoutingTableQuery`, `FiatRoutingTableResponse`, `FiatRoutingQuoteRequest`, both routes' error bodies, and `ROUTING_ENDPOINTS` | **production frontend** + backend |
+| `@fun-xyz/fiat-contract` | 47.6 KB, needs zod | the above + 77 zod schemas + assertions + 18 fixtures | tests, and backend dev/test guards |
 
 `./table` is not a micro-optimisation. Terminality is table data a **shipped** client must read
 (litmus rule 3 — clients never infer it), and Metro has no cross-module tree-shaking on by default,
@@ -120,6 +121,44 @@ text. `PROVIDER_CHECKOUT_DOCUMENTS` maps each provider to its current `CHECKOUT`
 stays valid: the backend refuses only an unknown version, a wrong digest, or an `acceptedAt` older
 than 5 minutes. A repeat of a version the login already holds writes nothing and returns the ids.
 
+**Routing table (`./routing`).** `ROUTING_ENDPOINTS.table` (`GET /fiat/routing/table`) answers,
+for each requested method, every amount interval and its providers best first, each with `next`
+(`READY`, `AUTH`, `DECLARATIVE_KYC`, `DOCUMENTARY_KYC`, `PENDING_REVIEW`) and `visibility`. The
+client shows min, max, provider and the Continue label for an amount with no call. A method with no
+interval may carry `unavailableReason`, which is not the step response's `BlockedReason`:
+`USER_LIMIT`, `KYC_REJECTED`, `PROVIDER_OUTAGE`, or `NOT_SERVED` when every provider was ruled out
+for reasons that depend on neither the buyer nor provider health (it does not offer the corridor,
+currency, method or asset, or config has not enabled it). An empty method carries no reason when the
+cause is unknown. Refetch the table at `expiresAt`, on `refreshLimits: true`, and after auth, KYC or
+a `REQUOTE`. The schemas hold the table's invariants: each method once, sorted, non-overlapping
+intervals, at least one provider each and none twice, and a reason only on an empty method.
+
+`ROUTING_ENDPOINTS.quote` (`POST /fiat/routing/quote`) takes the `POST /fiat/quote` body plus the
+interval's first `provider`, never `routingOverrides`, and answers the same `FiatStepResponse`. A
+refusal is a `FiatRoutingQuoteErrorBody`, and it decides whether to quote the interval's next
+provider:
+
+| Status | `errorCode` | Then |
+| --- | --- | --- |
+| 404 | `FiatNoRouteError`, `reason` `NO_CANDIDATE`, `PROVIDER_DECLINED`, `PROVIDER_OUTAGE` or `KYC_REJECTED` | quote the next provider |
+| 400 | `FiatNoRouteError`, `reason: USER_LIMIT`, `code: LIMITS_EXCEEDED`, `recovery: REQUOTE` | quote the next provider |
+| 400 | `FiatAmountBelowMinimumError` (`minFiatAmount`) or `FiatAmountAboveMaximumError` (`maxFiatAmount`) | quote the next provider |
+| 400 | `InvalidParameterError`: a bad request, an asset Fun cannot deliver, or no verified email | stop |
+| 401, 5xx | any other: a missing or invalid identity assertion, or a server error | stop |
+
+Every fall-through refusal is the named provider's alone, because the route prices only that
+provider: `KYC_REJECTED` there means that provider refused the buyer's identity, not every provider.
+With no provider left in the interval, refetch the table. The table route refuses with a
+`FiatRoutingTableErrorBody`: a 429 `TooManyRequestsError` with `retryAfterSeconds` when the
+per-login budget is spent, or a 400 or 5xx as above. The quote route has no rate limit of its own.
+
+Both routes take geo under the `POST /fiat/quote` rules: a known `CountryCode`, a `UsStateCode`
+region for a US buyer, and an empty `region` or `ip` read as absent. The quote route's `geo` is the
+Fun geo endpoint's response forwarded as is. The request schemas are strict like every schema here,
+so a client sends only the declared keys and no blank strings. `provider` is one of the five
+providers the backend routes (`RoutingProvider`). The quote route is temporary: each provider's
+`intent` route replaces it.
+
 **MoonPay (`./moonpay`).** One route, `MOONPAY_ENDPOINTS.intent`. A `MoonPayIntentRequest` is one of
 three kinds:
 
@@ -134,8 +173,8 @@ three kinds:
 | `status` | Carries | The client then |
 | --- | --- | --- |
 | `TERMS` | `stage`, `documents` (at least one, all at `stage`) | sends `POST /fiat/terms`, then `observe` |
-| `SDK_AUTH` | `sessionToken`, `quoteInput` | runs the MoonPay connection check, then `observe` with credentials |
-| `KYC` | `fields`, `fieldErrors?` (each naming a field in `fields`) | shows the shared form, then sends `kyc` |
+| `SDK_AUTH` | `sessionToken`, `quoteInput`, `resetConnection?` (`true` when the device's MoonPay connection is another buyer's) | resets the connection when asked, runs the MoonPay connection check, then `observe` with credentials |
+| `KYC` | `fields`, `fieldErrors?` (each naming a field in `fields`, with `code?` `PHONE_IN_USE` on `PHONE_NUMBER` or `TAX_ID_IN_USE` on `TAX_IDENTIFIER` when another MoonPay customer holds the value) | shows the shared form, then sends `kyc` |
 | `PENDING` | `retryAfterMs` (at most 60 s) | sends `observe` after the delay, never `kyc` again |
 | `READY` | `orderId`, `quoteInput` | mounts Apple Pay, then sends `order` after the charge |
 | `REFUSED` | `reason` (`NOT_ELIGIBLE`, `DOCUMENTS_REQUIRED`, `FINAL_REJECTION`, `CUSTOMER_MISMATCH`), `recovery: REQUOTE \| NONE` | exits the provider flow |
@@ -420,7 +459,7 @@ loadFixture('screen-10-kyc-on-hold'); // raw JSON, fresh deep copy, `unknown`
 
 ### Use a schema directly
 
-All 46 schemas are exported when you need to validate a fragment rather than a whole step response.
+All 77 schemas are exported when you need to validate a fragment rather than a whole step response.
 They are typed `z.ZodType<T>`, so you get `.parse` / `.safeParse` / `.optional()` — not `.shape` or
 `.extend`, deliberately.
 
@@ -513,8 +552,8 @@ Dual CJS + ESM, same shape as `@funkit/fun-relay`, because the two consumers loa
 | --- | --- | --- |
 | `require()` must work | `fun-backend/apps/api-server` compiles `module: commonjs` and runs plain node — no bundler | esbuild emits `dist/index.js` (CJS) + `dist/index.mjs` (ESM); `exports` maps `require`/`import`; no `"type": "module"` |
 | Zero Node builtins | `connect-core` is React Native — Metro cannot resolve `node:fs` | fixtures are inlined as generated TS data (`src/fixtures/data.ts`), so nothing touches the filesystem; `platform: browser`, every bare import external |
-| Subpath imports must resolve without `exports` support | Metro only reads `package.json#exports` from RN 0.79 on, and `@funkit/connect-rn` accepts `react-native: >=0.74` | root compat stubs `table.js` / `types.js` / `moonpay.js` / `terms.js` (+ `.d.ts`) that re-export `dist/`. Without them Metro fails with *"Unable to resolve module"* — verified, not theorised. Resolvers that do read `exports` never see the stubs |
-| Production code must not pull zod or fixtures | `connect-core` ships to React Native, where Metro does not tree-shake unused exports by default | five entry points: `./types` (erased), `./table` (13.8 KB, zero deps), `./moonpay` and `./terms` (zero deps), root (schemas + fixtures, test-time). CI asserts `require('.../table')`, `require('.../moonpay')` and `require('.../terms')` never load zod |
+| Subpath imports must resolve without `exports` support | Metro only reads `package.json#exports` from RN 0.79 on, and `@funkit/connect-rn` accepts `react-native: >=0.74` | root compat stubs `table.js` / `types.js` / `moonpay.js` / `terms.js` / `routing.js` (+ `.d.ts`) that re-export `dist/`. Without them Metro fails with *"Unable to resolve module"* — verified, not theorised. Resolvers that do read `exports` never see the stubs |
+| Production code must not pull zod or fixtures | `connect-core` ships to React Native, where Metro does not tree-shake unused exports by default | six entry points: `./types` (erased), `./table` (13.8 KB, zero deps), `./moonpay`, `./terms` and `./routing` (zero deps), root (schemas + fixtures, test-time). CI asserts `require('.../table')`, `require('.../moonpay')`, `require('.../terms')` and `require('.../routing')` never load zod |
 | `.d.ts` must not lock a zod major | Both repos run `skipLibCheck: true`, which turns a broken declaration into a silent `any` | every exported schema is annotated `z.ZodType<T>`, so declarations name only `z.ZodType`; the structural drift checks stay module-private |
 
 Declarations come from `tsc --emitDeclarationOnly`; esbuild only emits JS. The fixture `.json` files

package/dist/{chunk-I63WALQK.mjs → chunk-3HCZ6JBJ.mjs}

@@ -6,4 +6,4 @@ var MOONPAY_ENDPOINTS = {
 export {
   MOONPAY_ENDPOINTS
 };
-//# sourceMappingURL=chunk-I63WALQK.mjs.map
+//# sourceMappingURL=chunk-3HCZ6JBJ.mjs.map

package/dist/{chunk-PP6S7FSJ.mjs → chunk-EI56NQ7K.mjs}

@@ -1,5 +1,5 @@
 // package.json
-var version = "0.22.1";
+var version = "0.23.0";
 
 // src/table.ts
 var TABLE_VERSION = version;
@@ -514,4 +514,4 @@ export {
   tableEntry,
   isTerminal
 };
-//# sourceMappingURL=chunk-PP6S7FSJ.mjs.map
+//# sourceMappingURL=chunk-EI56NQ7K.mjs.map

package/dist/chunk-KYE2HYV5.mjs

@@ -0,0 +1,11 @@
+// src/routing.ts
+var ROUTING_ENDPOINTS = {
+  table: "GET /fiat/routing/table",
+  /** Temporary: each provider's `intent` route replaces it. */
+  quote: "POST /fiat/routing/quote"
+};
+
+export {
+  ROUTING_ENDPOINTS
+};
+//# sourceMappingURL=chunk-KYE2HYV5.mjs.map

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export * from './schemas';
 export * from './table';
 export * from './assert';
 export * from './terms';
+export * from './routing';
 export * from './providers/moonpay';
 export * from './providers/moonpay.schemas';
 export { FIXTURES, FIXTURE_COVERAGE_GAPS, fixtureMeta, loadFixture, loadFixtures, type FixtureMeta, type FixtureSource, type LoadedFixture, } from './fixtures/index';

package/dist/index.js

@@ -43,6 +43,11 @@ __export(index_exports, {
   FiatCurrencyCode: () => FiatCurrencyCode,
   FiatEndpointSchema: () => FiatEndpointSchema,
   FiatProviderSchema: () => FiatProviderSchema,
+  FiatRoutingQuoteErrorBodySchema: () => FiatRoutingQuoteErrorBodySchema,
+  FiatRoutingQuoteRequestSchema: () => FiatRoutingQuoteRequestSchema,
+  FiatRoutingTableErrorBodySchema: () => FiatRoutingTableErrorBodySchema,
+  FiatRoutingTableQuerySchema: () => FiatRoutingTableQuerySchema,
+  FiatRoutingTableResponseSchema: () => FiatRoutingTableResponseSchema,
   FiatStepResponseSchema: () => FiatStepResponseSchema,
   FiatTermsErrorBodySchema: () => FiatTermsErrorBodySchema,
   FiatTermsRequestSchema: () => FiatTermsRequestSchema,
@@ -94,6 +99,7 @@ __export(index_exports, {
   QuoteLimitsSchema: () => QuoteLimitsSchema,
   QuoteSchema: () => QuoteSchema,
   QuoteStateSchema: () => QuoteStateSchema,
+  ROUTING_ENDPOINTS: () => ROUTING_ENDPOINTS,
   RecoverySchema: () => RecoverySchema,
   RefundSchema: () => RefundSchema,
   ReportSpecSchema: () => ReportSpecSchema,
@@ -975,6 +981,8 @@ var $providerBoundFlowState = import_zod.z.union([
 var $flowState = import_zod.z.union([$providerBoundFlowState, $blockedState]);
 var FlowStateSchema = $flowState;
 var $nonBlank = import_zod.z.string().refine((value) => value.trim().length > 0, "must not be blank");
+var $isoInstant = import_zod.z.string().datetime({ offset: true });
+var $errorBodyFields = { errorMsg: import_zod.z.string(), reqId: import_zod.z.string().optional() };
 var $termsStage = import_zod.z.enum(["CHECKOUT", "KYC"]);
 var $termsDocument = obj({
   id: $nonBlank,
@@ -990,7 +998,7 @@ var $termsAcceptance = obj({
   documentId: $nonBlank,
   version: $nonBlank,
   contentDigest: $nonBlank,
-  acceptedAt: import_zod.z.string().datetime({ offset: true })
+  acceptedAt: $isoInstant
 });
 var TermsDocumentAcceptanceSchema = $termsAcceptance;
 var $termsRequest = obj({
@@ -1002,12 +1010,117 @@ var $termsResponse = obj({ recorded: import_zod.z.array($nonBlank) });
 var FiatTermsResponseSchema = $termsResponse;
 var $termsErrorBody = obj({
   errorCode: $nonBlank,
-  errorMsg: import_zod.z.string(),
-  reqId: import_zod.z.string().optional(),
+  ...$errorBodyFields,
   reason: import_zod.z.enum(["STALE_TERMS", "INVALID_REQUEST", "RATE_LIMITED", "PROVIDER_UNAVAILABLE"]),
   recovery: import_zod.z.enum(["RETRY", "REQUOTE", "NONE"])
 });
 var FiatTermsErrorBodySchema = $termsErrorBody;
+var $decimalAmount = import_zod.z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/, "must be a decimal string");
+var compareDecimals = (left, right) => {
+  const [leftWhole = "", leftFraction = ""] = left.split(".");
+  const [rightWhole = "", rightFraction = ""] = right.split(".");
+  if (leftWhole.length !== rightWhole.length) return leftWhole.length - rightWhole.length;
+  const width = Math.max(leftFraction.length, rightFraction.length);
+  const leftDigits = leftWhole + leftFraction.padEnd(width, "0");
+  const rightDigits = rightWhole + rightFraction.padEnd(width, "0");
+  return leftDigits < rightDigits ? -1 : leftDigits > rightDigits ? 1 : 0;
+};
+var $countryCode = import_zod.z.enum(Object.keys(CountryCode));
+var $routingProvider = $provider.extract(["TRANSAK", "BANXA", "MOONPAY", "STRIPE", "COINBASE"]);
+var $optionalGeoField = import_zod.z.union([$nonBlank, import_zod.z.literal("")]).optional();
+var US_REGION_REQUIRED = "a US buyer needs a US state code as region";
+var hasUsRegion = (country, region) => country !== "US" || UsStateCodeSchema.safeParse(region).success;
+var $routingTableQuery = obj({
+  fiatCurrencyCode: import_zod.z.enum(FIAT_CURRENCY_CODES).optional(),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  country: $countryCode,
+  region: $optionalGeoField,
+  methods: import_zod.z.string().refine(
+    (methods) => methods.split(",").every((method) => PAYMENT_METHOD_CATEGORIES.includes(method.trim())),
+    "must be comma-separated payment method categories"
+  )
+}).refine((query) => hasUsRegion(query.country, query.region), { message: US_REGION_REQUIRED, path: ["region"] });
+var FiatRoutingTableQuerySchema = $routingTableQuery;
+var $routingTableProvider = obj({
+  provider: $routingProvider,
+  next: import_zod.z.enum(["READY", "AUTH", "DECLARATIVE_KYC", "DOCUMENTARY_KYC", "PENDING_REVIEW"]),
+  visibility: import_zod.z.enum(["COMPLETE", "PARTIAL", "AUTH_GATED"])
+});
+var $routingTableInterval = obj({
+  min: $decimalAmount,
+  max: $decimalAmount,
+  providers: import_zod.z.array($routingTableProvider).min(1).refine((providers) => hasUniqueIds(providers.map((entry) => entry.provider)), "each provider is listed once")
+}).refine((interval) => compareDecimals(interval.min, interval.max) <= 0, { message: "min must not exceed max", path: ["max"] });
+var $routingTableMethod = obj({
+  method: import_zod.z.enum(PAYMENT_METHOD_CATEGORIES),
+  unavailableReason: import_zod.z.enum(["USER_LIMIT", "KYC_REJECTED", "PROVIDER_OUTAGE", "NOT_SERVED"]).optional(),
+  intervals: import_zod.z.array($routingTableInterval).superRefine((intervals, context) => {
+    intervals.forEach((interval, index) => {
+      const previous = intervals[index - 1];
+      if (previous !== void 0 && compareDecimals(interval.min, previous.max) <= 0) {
+        context.addIssue({ code: "custom", path: [index, "min"], message: "intervals are sorted and do not overlap" });
+      }
+    });
+  })
+}).refine((method) => method.unavailableReason === void 0 || method.intervals.length === 0, {
+  message: "unavailableReason only with no interval",
+  path: ["unavailableReason"]
+});
+var $routingTableResponse = obj({
+  expiresAt: $isoInstant,
+  methods: import_zod.z.array($routingTableMethod).refine((methods) => hasUniqueIds(methods.map((entry) => entry.method)), "each method is listed once")
+});
+var FiatRoutingTableResponseSchema = $routingTableResponse;
+var $routingQuoteRequest = obj({
+  provider: $routingProvider,
+  fiatCurrency: import_zod.z.enum(FIAT_CURRENCY_CODES),
+  fiatAmount: $decimalAmount.refine((amount) => Number(amount) > 0, "must be positive"),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  paymentMethodId: import_zod.z.enum(PAYMENT_METHOD_CATEGORIES),
+  geo: obj({ alpha2: $countryCode, region: $optionalGeoField, ip: $optionalGeoField, city: import_zod.z.string().optional() }).refine(
+    (geo) => hasUsRegion(geo.alpha2, geo.region),
+    { message: US_REGION_REQUIRED, path: ["region"] }
+  ),
+  prepareSessionAuth: import_zod.z.boolean().optional()
+});
+var FiatRoutingQuoteRequestSchema = $routingQuoteRequest;
+var $routingServiceableRange = obj({ min: $money, max: $money, userMax: $money.nullable().optional() });
+var $noRouteFields = {
+  ...$errorBodyFields,
+  errorCode: import_zod.z.literal("FiatNoRouteError"),
+  serviceableRanges: import_zod.z.array($routingServiceableRange),
+  retryable: import_zod.z.boolean()
+};
+var $routingNoRouteErrorBody = import_zod.z.union([
+  obj({ ...$noRouteFields, reason: import_zod.z.enum(["NO_CANDIDATE", "PROVIDER_DECLINED", "PROVIDER_OUTAGE", "KYC_REJECTED"]) }),
+  obj({ ...$noRouteFields, reason: import_zod.z.literal("USER_LIMIT"), code: import_zod.z.literal("LIMITS_EXCEEDED"), recovery: import_zod.z.literal("REQUOTE") })
+]);
+var $amountErrorFields = { ...$errorBodyFields, fiatCurrencyCode: import_zod.z.enum(FIAT_CURRENCY_CODES) };
+var $routingAmountErrorBody = import_zod.z.union([
+  obj({ ...$amountErrorFields, errorCode: import_zod.z.literal("FiatAmountBelowMinimumError"), minFiatAmount: $decimalAmount }),
+  obj({ ...$amountErrorFields, errorCode: import_zod.z.literal("FiatAmountAboveMaximumError"), maxFiatAmount: $decimalAmount })
+]);
+var $routingRateLimitedErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: import_zod.z.literal("TooManyRequestsError"),
+  retryAfterSeconds: import_zod.z.number().int().positive().optional()
+});
+var ROUTING_ERROR_CODES = [
+  "FiatNoRouteError",
+  "FiatAmountBelowMinimumError",
+  "FiatAmountAboveMaximumError",
+  "TooManyRequestsError"
+];
+var $routingFaultErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: $nonBlank.refine((code) => !ROUTING_ERROR_CODES.includes(code), "this errorCode carries its own fields")
+});
+var $routingTableErrorBody = import_zod.z.union([$routingRateLimitedErrorBody, $routingFaultErrorBody]);
+var FiatRoutingTableErrorBodySchema = $routingTableErrorBody;
+var $routingQuoteErrorBody = import_zod.z.union([$routingNoRouteErrorBody, $routingAmountErrorBody, $routingFaultErrorBody]);
+var FiatRoutingQuoteErrorBodySchema = $routingQuoteErrorBody;
 var $providerBoundStepResponse = obj({
   state: $providerBoundFlowState,
   provider: $provider,
@@ -1067,7 +1180,7 @@ var $stepResponse = import_zod.z.union([$providerBoundStepResponse, $blockedStep
 var FiatStepResponseSchema = $stepResponse;
 
 // package.json
-var version = "0.22.1";
+var version = "0.23.0";
 
 // src/table.ts
 var TABLE_VERSION = version;
@@ -2670,6 +2783,13 @@ var FUN_KYC_CONSENT_DOCUMENTS = {
 };
 var PUBLISHED_TERMS_DOCUMENTS = [MOONPAY_TERMS, ...Object.values(FUN_KYC_CONSENT_DOCUMENTS)];
 
+// src/routing.ts
+var ROUTING_ENDPOINTS = {
+  table: "GET /fiat/routing/table",
+  /** Temporary: each provider's `intent` route replaces it. */
+  quote: "POST /fiat/routing/quote"
+};
+
 // src/providers/moonpay.ts
 var MOONPAY_ENDPOINTS = {
   intent: "POST /fiat/providers/moonpay/intent"
@@ -2718,11 +2838,12 @@ var $quoteInput = obj2({
 var MoonPayQuoteInputSchema = $quoteInput;
 var $stepRefusal = import_zod2.z.enum(["NOT_ELIGIBLE", "DOCUMENTS_REQUIRED", "FINAL_REJECTION", "CUSTOMER_MISMATCH"]);
 var $orderRefusal = import_zod2.z.enum(["CUSTOMER_MISMATCH", "WALLET_MISMATCH", "UNRECORDABLE"]);
-var $fieldError = obj2({ fieldId: $nonEmpty, message: $nonEmpty });
+var FIELD_OF_CODE = { PHONE_IN_USE: "PHONE_NUMBER", TAX_ID_IN_USE: "TAX_IDENTIFIER" };
+var $fieldError = obj2({ fieldId: $nonEmpty, message: $nonEmpty, code: import_zod2.z.enum(["PHONE_IN_USE", "TAX_ID_IN_USE"]).optional() });
 var $pending = obj2({ status: import_zod2.z.literal("PENDING"), retryAfterMs: import_zod2.z.number().int().positive().max(6e4) });
 var $stepStatus = import_zod2.z.discriminatedUnion("status", [
   obj2({ status: import_zod2.z.literal("TERMS"), stage: import_zod2.z.enum(["CHECKOUT", "KYC"]), documents: import_zod2.z.array(TermsDocumentSchema).min(1) }),
-  obj2({ status: import_zod2.z.literal("SDK_AUTH"), sessionToken: $nonEmpty, quoteInput: $quoteInput }),
+  obj2({ status: import_zod2.z.literal("SDK_AUTH"), sessionToken: $nonEmpty, quoteInput: $quoteInput, resetConnection: import_zod2.z.literal(true).optional() }),
   obj2({ status: import_zod2.z.literal("KYC"), fields: import_zod2.z.array(FormFieldSchema).min(1), fieldErrors: import_zod2.z.array($fieldError).min(1).optional() }),
   $pending,
   obj2({ status: import_zod2.z.literal("READY"), orderId: $nonEmpty, quoteInput: $quoteInput }),
@@ -2745,6 +2866,9 @@ var $stepResponse2 = $stepStatus.superRefine((response, context) => {
     if (response.fieldErrors?.some((error) => !fieldIds.includes(error.fieldId))) {
       context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error must name a field in this response" });
     }
+    if (response.fieldErrors?.some((error) => error.code && FIELD_OF_CODE[error.code] !== error.fieldId)) {
+      context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error code must match its field" });
+    }
   }
 });
 var MoonPayStepResponseSchema = $stepResponse2;

package/dist/index.mjs

@@ -12,16 +12,19 @@ import {
   tableEntry,
   unofferedEndpoints,
   unreachableStates
-} from "./chunk-PP6S7FSJ.mjs";
+} from "./chunk-EI56NQ7K.mjs";
 import {
   MOONPAY_ENDPOINTS
-} from "./chunk-I63WALQK.mjs";
+} from "./chunk-3HCZ6JBJ.mjs";
 import {
   FIAT_TERMS_ENDPOINT,
   FUN_KYC_CONSENT_DOCUMENTS,
   PROVIDER_CHECKOUT_DOCUMENTS,
   PUBLISHED_TERMS_DOCUMENTS
 } from "./chunk-5GRPYE2U.mjs";
+import {
+  ROUTING_ENDPOINTS
+} from "./chunk-KYE2HYV5.mjs";
 
 // src/codes.ts
 var US_STATE_CODES = [
@@ -859,6 +862,8 @@ var $providerBoundFlowState = z.union([
 var $flowState = z.union([$providerBoundFlowState, $blockedState]);
 var FlowStateSchema = $flowState;
 var $nonBlank = z.string().refine((value) => value.trim().length > 0, "must not be blank");
+var $isoInstant = z.string().datetime({ offset: true });
+var $errorBodyFields = { errorMsg: z.string(), reqId: z.string().optional() };
 var $termsStage = z.enum(["CHECKOUT", "KYC"]);
 var $termsDocument = obj({
   id: $nonBlank,
@@ -874,7 +879,7 @@ var $termsAcceptance = obj({
   documentId: $nonBlank,
   version: $nonBlank,
   contentDigest: $nonBlank,
-  acceptedAt: z.string().datetime({ offset: true })
+  acceptedAt: $isoInstant
 });
 var TermsDocumentAcceptanceSchema = $termsAcceptance;
 var $termsRequest = obj({
@@ -886,12 +891,117 @@ var $termsResponse = obj({ recorded: z.array($nonBlank) });
 var FiatTermsResponseSchema = $termsResponse;
 var $termsErrorBody = obj({
   errorCode: $nonBlank,
-  errorMsg: z.string(),
-  reqId: z.string().optional(),
+  ...$errorBodyFields,
   reason: z.enum(["STALE_TERMS", "INVALID_REQUEST", "RATE_LIMITED", "PROVIDER_UNAVAILABLE"]),
   recovery: z.enum(["RETRY", "REQUOTE", "NONE"])
 });
 var FiatTermsErrorBodySchema = $termsErrorBody;
+var $decimalAmount = z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/, "must be a decimal string");
+var compareDecimals = (left, right) => {
+  const [leftWhole = "", leftFraction = ""] = left.split(".");
+  const [rightWhole = "", rightFraction = ""] = right.split(".");
+  if (leftWhole.length !== rightWhole.length) return leftWhole.length - rightWhole.length;
+  const width = Math.max(leftFraction.length, rightFraction.length);
+  const leftDigits = leftWhole + leftFraction.padEnd(width, "0");
+  const rightDigits = rightWhole + rightFraction.padEnd(width, "0");
+  return leftDigits < rightDigits ? -1 : leftDigits > rightDigits ? 1 : 0;
+};
+var $countryCode = z.enum(Object.keys(CountryCode));
+var $routingProvider = $provider.extract(["TRANSAK", "BANXA", "MOONPAY", "STRIPE", "COINBASE"]);
+var $optionalGeoField = z.union([$nonBlank, z.literal("")]).optional();
+var US_REGION_REQUIRED = "a US buyer needs a US state code as region";
+var hasUsRegion = (country, region) => country !== "US" || UsStateCodeSchema.safeParse(region).success;
+var $routingTableQuery = obj({
+  fiatCurrencyCode: z.enum(FIAT_CURRENCY_CODES).optional(),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  country: $countryCode,
+  region: $optionalGeoField,
+  methods: z.string().refine(
+    (methods) => methods.split(",").every((method) => PAYMENT_METHOD_CATEGORIES.includes(method.trim())),
+    "must be comma-separated payment method categories"
+  )
+}).refine((query) => hasUsRegion(query.country, query.region), { message: US_REGION_REQUIRED, path: ["region"] });
+var FiatRoutingTableQuerySchema = $routingTableQuery;
+var $routingTableProvider = obj({
+  provider: $routingProvider,
+  next: z.enum(["READY", "AUTH", "DECLARATIVE_KYC", "DOCUMENTARY_KYC", "PENDING_REVIEW"]),
+  visibility: z.enum(["COMPLETE", "PARTIAL", "AUTH_GATED"])
+});
+var $routingTableInterval = obj({
+  min: $decimalAmount,
+  max: $decimalAmount,
+  providers: z.array($routingTableProvider).min(1).refine((providers) => hasUniqueIds(providers.map((entry) => entry.provider)), "each provider is listed once")
+}).refine((interval) => compareDecimals(interval.min, interval.max) <= 0, { message: "min must not exceed max", path: ["max"] });
+var $routingTableMethod = obj({
+  method: z.enum(PAYMENT_METHOD_CATEGORIES),
+  unavailableReason: z.enum(["USER_LIMIT", "KYC_REJECTED", "PROVIDER_OUTAGE", "NOT_SERVED"]).optional(),
+  intervals: z.array($routingTableInterval).superRefine((intervals, context) => {
+    intervals.forEach((interval, index) => {
+      const previous = intervals[index - 1];
+      if (previous !== void 0 && compareDecimals(interval.min, previous.max) <= 0) {
+        context.addIssue({ code: "custom", path: [index, "min"], message: "intervals are sorted and do not overlap" });
+      }
+    });
+  })
+}).refine((method) => method.unavailableReason === void 0 || method.intervals.length === 0, {
+  message: "unavailableReason only with no interval",
+  path: ["unavailableReason"]
+});
+var $routingTableResponse = obj({
+  expiresAt: $isoInstant,
+  methods: z.array($routingTableMethod).refine((methods) => hasUniqueIds(methods.map((entry) => entry.method)), "each method is listed once")
+});
+var FiatRoutingTableResponseSchema = $routingTableResponse;
+var $routingQuoteRequest = obj({
+  provider: $routingProvider,
+  fiatCurrency: z.enum(FIAT_CURRENCY_CODES),
+  fiatAmount: $decimalAmount.refine((amount) => Number(amount) > 0, "must be positive"),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  paymentMethodId: z.enum(PAYMENT_METHOD_CATEGORIES),
+  geo: obj({ alpha2: $countryCode, region: $optionalGeoField, ip: $optionalGeoField, city: z.string().optional() }).refine(
+    (geo) => hasUsRegion(geo.alpha2, geo.region),
+    { message: US_REGION_REQUIRED, path: ["region"] }
+  ),
+  prepareSessionAuth: z.boolean().optional()
+});
+var FiatRoutingQuoteRequestSchema = $routingQuoteRequest;
+var $routingServiceableRange = obj({ min: $money, max: $money, userMax: $money.nullable().optional() });
+var $noRouteFields = {
+  ...$errorBodyFields,
+  errorCode: z.literal("FiatNoRouteError"),
+  serviceableRanges: z.array($routingServiceableRange),
+  retryable: z.boolean()
+};
+var $routingNoRouteErrorBody = z.union([
+  obj({ ...$noRouteFields, reason: z.enum(["NO_CANDIDATE", "PROVIDER_DECLINED", "PROVIDER_OUTAGE", "KYC_REJECTED"]) }),
+  obj({ ...$noRouteFields, reason: z.literal("USER_LIMIT"), code: z.literal("LIMITS_EXCEEDED"), recovery: z.literal("REQUOTE") })
+]);
+var $amountErrorFields = { ...$errorBodyFields, fiatCurrencyCode: z.enum(FIAT_CURRENCY_CODES) };
+var $routingAmountErrorBody = z.union([
+  obj({ ...$amountErrorFields, errorCode: z.literal("FiatAmountBelowMinimumError"), minFiatAmount: $decimalAmount }),
+  obj({ ...$amountErrorFields, errorCode: z.literal("FiatAmountAboveMaximumError"), maxFiatAmount: $decimalAmount })
+]);
+var $routingRateLimitedErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: z.literal("TooManyRequestsError"),
+  retryAfterSeconds: z.number().int().positive().optional()
+});
+var ROUTING_ERROR_CODES = [
+  "FiatNoRouteError",
+  "FiatAmountBelowMinimumError",
+  "FiatAmountAboveMaximumError",
+  "TooManyRequestsError"
+];
+var $routingFaultErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: $nonBlank.refine((code) => !ROUTING_ERROR_CODES.includes(code), "this errorCode carries its own fields")
+});
+var $routingTableErrorBody = z.union([$routingRateLimitedErrorBody, $routingFaultErrorBody]);
+var FiatRoutingTableErrorBodySchema = $routingTableErrorBody;
+var $routingQuoteErrorBody = z.union([$routingNoRouteErrorBody, $routingAmountErrorBody, $routingFaultErrorBody]);
+var FiatRoutingQuoteErrorBodySchema = $routingQuoteErrorBody;
 var $providerBoundStepResponse = obj({
   state: $providerBoundFlowState,
   provider: $provider,
@@ -2058,11 +2168,12 @@ var $quoteInput = obj2({
 var MoonPayQuoteInputSchema = $quoteInput;
 var $stepRefusal = z2.enum(["NOT_ELIGIBLE", "DOCUMENTS_REQUIRED", "FINAL_REJECTION", "CUSTOMER_MISMATCH"]);
 var $orderRefusal = z2.enum(["CUSTOMER_MISMATCH", "WALLET_MISMATCH", "UNRECORDABLE"]);
-var $fieldError = obj2({ fieldId: $nonEmpty, message: $nonEmpty });
+var FIELD_OF_CODE = { PHONE_IN_USE: "PHONE_NUMBER", TAX_ID_IN_USE: "TAX_IDENTIFIER" };
+var $fieldError = obj2({ fieldId: $nonEmpty, message: $nonEmpty, code: z2.enum(["PHONE_IN_USE", "TAX_ID_IN_USE"]).optional() });
 var $pending = obj2({ status: z2.literal("PENDING"), retryAfterMs: z2.number().int().positive().max(6e4) });
 var $stepStatus = z2.discriminatedUnion("status", [
   obj2({ status: z2.literal("TERMS"), stage: z2.enum(["CHECKOUT", "KYC"]), documents: z2.array(TermsDocumentSchema).min(1) }),
-  obj2({ status: z2.literal("SDK_AUTH"), sessionToken: $nonEmpty, quoteInput: $quoteInput }),
+  obj2({ status: z2.literal("SDK_AUTH"), sessionToken: $nonEmpty, quoteInput: $quoteInput, resetConnection: z2.literal(true).optional() }),
   obj2({ status: z2.literal("KYC"), fields: z2.array(FormFieldSchema).min(1), fieldErrors: z2.array($fieldError).min(1).optional() }),
   $pending,
   obj2({ status: z2.literal("READY"), orderId: $nonEmpty, quoteInput: $quoteInput }),
@@ -2085,6 +2196,9 @@ var $stepResponse2 = $stepStatus.superRefine((response, context) => {
     if (response.fieldErrors?.some((error) => !fieldIds.includes(error.fieldId))) {
       context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error must name a field in this response" });
     }
+    if (response.fieldErrors?.some((error) => error.code && FIELD_OF_CODE[error.code] !== error.fieldId)) {
+      context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error code must match its field" });
+    }
   }
 });
 var MoonPayStepResponseSchema = $stepResponse2;
@@ -2128,6 +2242,11 @@ export {
   FiatCurrencyCode,
   FiatEndpointSchema,
   FiatProviderSchema,
+  FiatRoutingQuoteErrorBodySchema,
+  FiatRoutingQuoteRequestSchema,
+  FiatRoutingTableErrorBodySchema,
+  FiatRoutingTableQuerySchema,
+  FiatRoutingTableResponseSchema,
   FiatStepResponseSchema,
   FiatTermsErrorBodySchema,
   FiatTermsRequestSchema,
@@ -2179,6 +2298,7 @@ export {
   QuoteLimitsSchema,
   QuoteSchema,
   QuoteStateSchema,
+  ROUTING_ENDPOINTS,
   RecoverySchema,
   RefundSchema,
   ReportSpecSchema,

package/dist/providers/moonpay.d.ts

@@ -103,10 +103,16 @@ export type MoonPayStepRefusal = 'NOT_ELIGIBLE' | 'DOCUMENTS_REQUIRED' | 'FINAL_
  * assertion's. `UNRECORDABLE`: a charge no retry can record, held for refund review.
  */
 export type MoonPayOrderRefusal = 'CUSTOMER_MISMATCH' | 'WALLET_MISMATCH' | 'UNRECORDABLE';
-/** A reason on one field of a `KYC` response. `fieldId` names a field in that response. */
+/** Another MoonPay customer already holds the value; only a different one goes through. */
+export type MoonPayFieldErrorCode = 'PHONE_IN_USE' | 'TAX_ID_IN_USE';
+/**
+ * A reason on one field of a `KYC` response. `fieldId` names a field in that response. `code` is set
+ * only for a refusal the client words itself: `PHONE_IN_USE` on `PHONE_NUMBER`, `TAX_ID_IN_USE` on `TAX_IDENTIFIER`.
+ */
 export interface MoonPayFieldError {
     fieldId: string;
     message: string;
+    code?: MoonPayFieldErrorCode;
 }
 /** The answer to `observe` and `kyc`. */
 export type MoonPayStepResponse = 
@@ -116,11 +122,15 @@ export type MoonPayStepResponse =
     stage: TermsStage;
     documents: TermsDocument[];
 }
-/** Run the MoonPay connection check with `sessionToken`, then `observe` with the credentials. */
+/**
+ * Run the MoonPay connection check with `sessionToken`, then `observe` with the credentials.
+ * `resetConnection`: the device's connection is another buyer's, so reset it before the check.
+ */
  | {
     status: 'SDK_AUTH';
     sessionToken: string;
     quoteInput: MoonPayQuoteInput;
+    resetConnection?: true;
 }
 /** Show the shared form, then send `kyc`. */
  | {

package/dist/providers/moonpay.mjs

@@ -1,6 +1,6 @@
 import {
   MOONPAY_ENDPOINTS
-} from "../chunk-I63WALQK.mjs";
+} from "../chunk-3HCZ6JBJ.mjs";
 export {
   MOONPAY_ENDPOINTS
 };

package/dist/routing.d.ts

@@ -0,0 +1,168 @@
+/**
+ * The routing table: `GET /fiat/routing/table` and `POST /fiat/routing/quote`.
+ *
+ * The client loads the table when the sheet opens. For each payment method it lists every amount
+ * interval and the providers that serve it, best first, each with what it needs from the buyer next.
+ * The client then shows min, max, provider and the Continue label for any amount with no call, and
+ * quotes only the interval's first provider, and the next one after a fall-through refusal
+ * (`FiatRoutingQuoteErrorBody`).
+ *
+ * The table is advisory: every routing quote checks the named provider's eligibility again. Refetch it
+ * at `expiresAt`, on `refreshLimits: true`, and after auth, KYC or a `REQUOTE` refusal.
+ *
+ * Changes to both routes only add fields and enum values. Map an unknown `next` to the generic
+ * Continue label.
+ *
+ * Zero runtime dependencies, so production React Native code can import it. The zod schemas are
+ * exported from the package root. Like every schema in the package they are strict: a request with
+ * an extra key or a blank string fails them, so send only the declared fields.
+ */
+import type { CountryCode, FiatCurrencyCode, PaymentMethodCategory } from './codes';
+import type { FiatAmount, FiatProvider, QuoteLimitRange } from './types';
+export declare const ROUTING_ENDPOINTS: {
+    readonly table: "GET /fiat/routing/table";
+    /** Temporary: each provider's `intent` route replaces it. */
+    readonly quote: "POST /fiat/routing/quote";
+};
+/**
+ * The query string of `GET /fiat/routing/table`. `country` and `region` are the geo endpoint's
+ * `alpha2` and `region`, held to the `POST /fiat/quote` geo rules: a US buyer's `region` must be a
+ * `UsStateCode`, and an empty `region` counts as absent.
+ */
+export interface FiatRoutingTableQuery {
+    /** Defaults to `USD`. */
+    fiatCurrencyCode?: FiatCurrencyCode;
+    cryptoCurrencyCode: string;
+    chainId: string;
+    country: CountryCode;
+    region?: string;
+    /** Comma-separated `PaymentMethodCategory` values, for example `apple_pay,card`. */
+    methods: string;
+}
+/** What a provider needs from this buyer before it can take the payment. */
+export type RoutingNextStep = 'READY' | 'AUTH' | 'DECLARATIVE_KYC' | 'DOCUMENTARY_KYC' | 'PENDING_REVIEW';
+/** How much past `next` the backend can see: the whole picture, part of it, or nothing before auth. */
+export type RoutingVisibility = 'COMPLETE' | 'PARTIAL' | 'AUTH_GATED';
+/**
+ * Why a method has no interval. Present only when `intervals` is empty, and absent there too when the
+ * cause is unknown. `NOT_SERVED`: every provider was ruled out for reasons that depend on neither the
+ * buyer nor provider health: it does not offer the corridor, currency, method or asset, or config has
+ * not enabled it.
+ */
+export type RoutingUnavailableReason = 'USER_LIMIT' | 'KYC_REJECTED' | 'PROVIDER_OUTAGE' | 'NOT_SERVED';
+/** The providers the backend can route and take an order through. */
+export type RoutingProvider = Extract<FiatProvider, 'TRANSAK' | 'BANXA' | 'MOONPAY' | 'STRIPE' | 'COINBASE'>;
+export interface RoutingTableProvider {
+    provider: RoutingProvider;
+    next: RoutingNextStep;
+    visibility: RoutingVisibility;
+}
+/**
+ * A `QuoteLimitRange` with two decimals (`"20.00"`) and the providers that serve it. The next
+ * interval starts one cent above `max`. Adjacent intervals always rank differently.
+ */
+export interface RoutingTableInterval extends QuoteLimitRange {
+    /** Best first; never empty. Quote the first, and the next one after a decline. */
+    providers: RoutingTableProvider[];
+}
+/**
+ * One requested payment method. An amount in no interval has no provider: show the nearest edges
+ * ("Minimum $X", "Maximum $Y", or both around a gap), never a blocked state while `intervals` is not
+ * empty. With no interval at all, show `unavailableReason` instead of the amount picker.
+ */
+export interface RoutingTableMethod {
+    method: PaymentMethodCategory;
+    unavailableReason?: RoutingUnavailableReason;
+    /** Sorted and non-overlapping. */
+    intervals: RoutingTableInterval[];
+}
+export interface FiatRoutingTableResponse {
+    /** ISO-8601. The earliest of 60 s after the build and the expiry of any limit, coverage or provider session behind it. */
+    expiresAt: string;
+    /** In request order, duplicates removed. */
+    methods: RoutingTableMethod[];
+}
+/**
+ * The `POST /fiat/quote` body plus the one `provider` to price, which is the interval's first
+ * provider, and never `routingOverrides`. The response is the same `FiatStepResponse` as
+ * `POST /fiat/quote`; a refusal is a `FiatRoutingQuoteErrorBody`.
+ */
+export interface FiatRoutingQuoteRequest {
+    provider: RoutingProvider;
+    fiatCurrency: FiatCurrencyCode;
+    /** A positive decimal string with no leading zero, exponent or sign (`"20"`, `"20.5"`). */
+    fiatAmount: string;
+    cryptoCurrencyCode: string;
+    chainId: string;
+    paymentMethodId: PaymentMethodCategory;
+    /**
+     * The Fun geo endpoint's response, forwarded as is. An empty `region` or `ip` counts as absent, a
+     * US buyer's `region` must be a `UsStateCode`, and `city` is ignored.
+     */
+    geo: {
+        alpha2: CountryCode;
+        region?: string;
+        ip?: string;
+        city?: string;
+    };
+    prepareSessionAuth?: boolean;
+}
+/** One serviceable range of the named provider. `userMax` is this buyer's own ceiling inside it, `null` when unmeasured. */
+export interface RoutingServiceableRange {
+    min: FiatAmount;
+    max: FiatAmount;
+    userMax?: FiatAmount | null;
+}
+/**
+ * Why the named provider cannot price the request. `NO_CANDIDATE`: it does not serve this corridor,
+ * method or amount. `PROVIDER_DECLINED`: it priced and then declined this buyer. `PROVIDER_OUTAGE`:
+ * it is down, so `retryable` is true. `KYC_REJECTED`: it refused this buyer's identity for good.
+ * `USER_LIMIT`: this buyer's limits at it do not allow the amount.
+ */
+export type RoutingNoRouteReason = 'NO_CANDIDATE' | 'PROVIDER_DECLINED' | 'PROVIDER_OUTAGE' | 'KYC_REJECTED' | 'USER_LIMIT';
+/** The shared fields of every `/fiat/*` error body. */
+interface ErrorBodyFields {
+    errorMsg: string;
+    reqId?: string;
+}
+/** 404, or 400 for `USER_LIMIT`, which alone carries `code` and `recovery`. The same body `POST /fiat/quote` sends. */
+export type RoutingNoRouteErrorBody = ErrorBodyFields & {
+    errorCode: 'FiatNoRouteError';
+    serviceableRanges: RoutingServiceableRange[];
+    retryable: boolean;
+} & ({
+    reason: Exclude<RoutingNoRouteReason, 'USER_LIMIT'>;
+} | {
+    reason: 'USER_LIMIT';
+    code: 'LIMITS_EXCEEDED';
+    recovery: 'REQUOTE';
+});
+/** 400: the amount is outside the named provider's bounds. */
+export type RoutingAmountErrorBody = ErrorBodyFields & {
+    fiatCurrencyCode: FiatCurrencyCode;
+} & ({
+    errorCode: 'FiatAmountBelowMinimumError';
+    minFiatAmount: string;
+} | {
+    errorCode: 'FiatAmountAboveMaximumError';
+    maxFiatAmount: string;
+});
+/** 429: the per-login budget is spent. Retry after `retryAfterSeconds`. */
+export type RoutingRateLimitedErrorBody = ErrorBodyFields & {
+    errorCode: 'TooManyRequestsError';
+    retryAfterSeconds?: number;
+};
+/** Any other fault: a bad request (400), a missing assertion (401) or a server error (5xx). `errorCode` is the error's name. */
+export type RoutingFaultErrorBody = ErrorBodyFields & {
+    errorCode: string;
+};
+/** `GET /fiat/routing/table` refusals. */
+export type FiatRoutingTableErrorBody = RoutingRateLimitedErrorBody | RoutingFaultErrorBody;
+/**
+ * `POST /fiat/routing/quote` refusals. A `FiatNoRouteError` (any `reason`) or either amount error is
+ * the named provider's alone: quote the interval's next provider. Anything else stops the fall-through:
+ * a validation or auth refusal, a 5xx, or no provider left to try.
+ */
+export type FiatRoutingQuoteErrorBody = RoutingNoRouteErrorBody | RoutingAmountErrorBody | RoutingFaultErrorBody;
+export {};
+//# sourceMappingURL=routing.d.ts.map

package/dist/routing.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/routing.ts
+var routing_exports = {};
+__export(routing_exports, {
+  ROUTING_ENDPOINTS: () => ROUTING_ENDPOINTS
+});
+module.exports = __toCommonJS(routing_exports);
+var ROUTING_ENDPOINTS = {
+  table: "GET /fiat/routing/table",
+  /** Temporary: each provider's `intent` route replaces it. */
+  quote: "POST /fiat/routing/quote"
+};
+//# sourceMappingURL=routing.js.map

package/dist/routing.mjs

@@ -0,0 +1,7 @@
+import {
+  ROUTING_ENDPOINTS
+} from "./chunk-KYE2HYV5.mjs";
+export {
+  ROUTING_ENDPOINTS
+};
+//# sourceMappingURL=routing.mjs.map

package/dist/schemas.d.ts

@@ -30,6 +30,7 @@ import { z } from 'zod';
 import type { UsStateCode } from './codes';
 import type { BlockedReason, CryptoAmount, FailureReason, FeeLine, FiatAmount, FiatEndpoint, FiatProvider, FiatStepResponse, FieldSpec, FlowState, FormDescriptor, FormField, FormFieldType, InstructionField, Instructions, Instrument, JsonValue, KYCProvider, OrderRef, OrderStatus, OrderSummary, PollSpec, PreparedPayment, PaymentSurface, Quote, QuoteLimitRange, QuoteLimits, Recovery, Refund, ReportSpec, SelectOption, StatusHistoryEntry, Surface, PreferredIdentityDocument, KycFieldId, ClientExecutedDelivery, KycSdkResultReport, SurfaceKind, SurfaceProvider, TermsAcceptance, Transition, TransitionInputs, TransitionParams, Tx } from './types';
 import type { FiatTermsErrorBody, FiatTermsRequest, FiatTermsResponse, TermsDocument, TermsDocumentAcceptance } from './terms';
+import type { FiatRoutingQuoteErrorBody, FiatRoutingQuoteRequest, FiatRoutingTableErrorBody, FiatRoutingTableQuery, FiatRoutingTableResponse } from './routing';
 export declare const JsonSchema: z.ZodType<JsonValue>;
 export declare const HTTP_VERBS: readonly ["GET", "POST"];
 /** `"POST /fiat/session/verify"`, `"GET /fiat/orders/o_31c"` — the verb rides the string. */
@@ -111,6 +112,11 @@ export declare const TermsDocumentAcceptanceSchema: z.ZodType<TermsDocumentAccep
 export declare const FiatTermsRequestSchema: z.ZodType<FiatTermsRequest>;
 export declare const FiatTermsResponseSchema: z.ZodType<FiatTermsResponse>;
 export declare const FiatTermsErrorBodySchema: z.ZodType<FiatTermsErrorBody>;
+export declare const FiatRoutingTableQuerySchema: z.ZodType<FiatRoutingTableQuery>;
+export declare const FiatRoutingTableResponseSchema: z.ZodType<FiatRoutingTableResponse>;
+export declare const FiatRoutingQuoteRequestSchema: z.ZodType<FiatRoutingQuoteRequest>;
+export declare const FiatRoutingTableErrorBodySchema: z.ZodType<FiatRoutingTableErrorBody>;
+export declare const FiatRoutingQuoteErrorBodySchema: z.ZodType<FiatRoutingQuoteErrorBody>;
 export declare const FiatStepResponseSchema: z.ZodType<FiatStepResponse>;
 export {};
 //# sourceMappingURL=schemas.d.ts.map

package/dist/table.js

@@ -36,7 +36,7 @@ __export(table_exports, {
 module.exports = __toCommonJS(table_exports);
 
 // package.json
-var version = "0.22.1";
+var version = "0.23.0";
 
 // src/table.ts
 var TABLE_VERSION = version;

package/dist/table.mjs

@@ -11,7 +11,7 @@ import {
   tableEntry,
   unofferedEndpoints,
   unreachableStates
-} from "./chunk-PP6S7FSJ.mjs";
+} from "./chunk-EI56NQ7K.mjs";
 export {
   DOCUMENTED_ENDPOINTS,
   STATE_KEYS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fun-xyz/fiat-contract",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Published conformance contract for Fun's headless fiat onramp: FlowState/Transition types, zod schemas, the transition table as data, recorded fixtures, assertion helpers.",
   "license": "MIT",
   "repository": {
@@ -38,6 +38,11 @@
       "import": "./dist/terms.mjs",
       "require": "./dist/terms.js"
     },
+    "./routing": {
+      "types": "./dist/routing.d.ts",
+      "import": "./dist/routing.mjs",
+      "require": "./dist/routing.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -50,6 +55,8 @@
     "moonpay.d.ts",
     "terms.js",
     "terms.d.ts",
+    "routing.js",
+    "routing.d.ts",
     "README.md",
     "!dist/**/*.map"
   ],
@@ -95,6 +102,9 @@
       ],
       "terms": [
         "./dist/terms.d.ts"
+      ],
+      "routing": [
+        "./dist/routing.d.ts"
       ]
     }
   }

package/routing.d.ts

@@ -0,0 +1 @@
+export * from './dist/routing';

package/routing.js

@@ -0,0 +1,2 @@
+// Compat stub — see table.js. Metro before RN 0.79 resolves `@fun-xyz/fiat-contract/routing` by path.
+module.exports = require('./dist/routing.js');