@fun-xyz/fiat-contract 0.22.2 → 0.24.0

package/dist/providers/moonpay.d.ts

@@ -1,28 +1,31 @@
 /**
- * The MoonPay provider-owned flow: one route, `POST /fiat/providers/moonpay/intent`.
+ * The MoonPay flow on `POST /fiat/next`.
  *
- * Each request carries evidence or a user action (`kind`), and each response says what the backend
- * needs next (`status`). `observe` and `kyc` answer a `MoonPayStepResponse`, and `order` answers a
- * `MoonPayOrderResponse` (`MoonPayIntentResponseFor`). Terms and consents go through
- * the platform `POST /fiat/terms` (`./terms`). Identity and the deposit wallet always come from the
- * verified partner assertion, never from a request body.
+ * Each action has one name and two types. A response's prompt names it in `next` and carries what
+ * the client needs to do it. The client's request names it in `action` and carries the result. Every
+ * response is the next prompt, `done`, or `refused` (`MoonPayResponseFor`). `observe` carries no
+ * result and answers the current prompt. `wait` has no request: the client sends `observe` after it.
+ *
+ * The body is `MoonPayNextRequest`: `provider`, the shared `geo`, the context (`checkout`, and
+ * `credentials` after `connect`), and the action's result. Identity and the deposit wallet always
+ * come from the verified partner assertion, never from a request body.
  *
  * A retry sends the same request. Each write is idempotent on data the request carries, and every
  * call, a retry too, returns the current response.
  *
- * A fault is a 4xx/5xx whose body is `MoonPayErrorBody`. Anything the user can act on is a 200
- * `MoonPayIntentResponse`.
+ * A fault is a 4xx/5xx whose body is `MoonPayErrorBody`. Anything the user can act on is a 200.
  *
  * Zero runtime dependencies, so production React Native code can import it. The zod schemas are in
  * `./moonpay.schemas`, exported from the package root.
  */
 import type { FiatCurrencyCode } from '../codes';
-import type { TermsDocument, TermsStage } from '../terms';
-import type { FiatAmount, FiatStepResponse, FormField, KycFieldId } from '../types';
+import type { FiatTermsRequest, TermsDocument } from '../terms';
+import type { FiatAmount, FiatGeo, FiatStepResponse, FormField, KycFieldId } from '../types';
 export declare const MOONPAY_ENDPOINTS: {
-    readonly intent: "POST /fiat/providers/moonpay/intent";
+    readonly next: "POST /fiat/next";
 };
-/** The checkout terms. The client holds them and sends them on every `observe` and `kyc`. */
+export type MoonPayAction = 'observe' | 'consent' | 'connect' | 'kyc' | 'wait' | 'order';
+/** The checkout terms. The client holds them and sends them on every request. */
 export interface MoonPayCheckout {
     amount: FiatAmount;
     /** The quote's `crypto.currency` and `crypto.network`, unchanged. */
@@ -31,46 +34,17 @@ export interface MoonPayCheckout {
         network: string;
     };
     paymentMethod: 'apple_pay';
-    /** The geo endpoint's response, as sent to `POST /fiat/quote`. `alpha2` is ISO 3166-1 alpha-2. */
-    geo: {
-        alpha2: string;
-        region?: string;
-        ip?: string;
-    };
 }
 /** From the SDK's `active` connection. `accessToken` is a credential: the backend never logs it. */
 export interface MoonPaySdkCredentials {
     customerId: string;
     accessToken: string;
 }
-export type MoonPayIntentRequest = 
-/** No effect. Without credentials, the answer past the gates is `SDK_AUTH`. */
-{
-    kind: 'observe';
+/** On every request, not part of the result. `credentials` is present after `connect`. */
+export type MoonPayRequestContext = {
     checkout: MoonPayCheckout;
     credentials?: MoonPaySdkCredentials;
-}
-/** Only after a `KYC` response. `values` is keyed by the ids of that response's fields; there is no form id. */
- | {
-    kind: 'kyc';
-    checkout: MoonPayCheckout;
-    credentials: MoonPaySdkCredentials;
-    values: Partial<Record<KycFieldId, string>>;
-}
-/**
- * After every charge attempt, a failed one too. `transactionId` is from the Apple Pay event when it
- * has one; without it the backend records the failed charges MoonPay lists for `orderId`.
- * `quotedAmount` is the fiat amount the buyer saw on the quote. `geo` is the checkout's, as sent on
- * `observe`; the order records its `alpha2`, and no country when it is absent.
- */
- | {
-    kind: 'order';
-    orderId: string;
-    transactionId?: string;
-    quotedAmount: FiatAmount;
-    geo?: MoonPayCheckout['geo'];
 };
-export type MoonPayIntentKind = MoonPayIntentRequest['kind'];
 /**
  * The parameters for the device `client.getQuote`, not a quote. The backend builds them because the
  * wallet must be the verified one and MoonPay's currency codes differ by environment.
@@ -95,18 +69,39 @@ export interface MoonPayQuoteInput {
     };
     feeBehavior: 'inclusive';
 }
-/** `REQUOTE` for `NOT_ELIGIBLE` and `DOCUMENTS_REQUIRED`, `NONE` for the others. */
-export type MoonPayStepRefusal = 'NOT_ELIGIBLE' | 'DOCUMENTS_REQUIRED' | 'FINAL_REJECTION' | 'CUSTOMER_MISMATCH';
+/** No prompt of its own: the answer is the current prompt. Writes nothing. */
+export type MoonPayObserveRequest = {
+    action: 'observe';
+};
+/** MoonPay's terms first. Later, before `kyc`, Fun's KYC consent if the buyer has not accepted it. */
+export type MoonPayConsentPrompt = {
+    next: 'consent';
+    documents: TermsDocument[];
+};
+/** The `POST /fiat/terms` items, recorded under the same rules. */
+export type MoonPayConsentRequest = {
+    action: 'consent';
+    acceptances: FiatTermsRequest['acceptances'];
+};
 /**
- * After a charge, always with `recovery: NONE`. `CUSTOMER_MISMATCH`: the transaction's customer is
- * not bound to this buyer. `WALLET_MISMATCH`: the transaction pays another wallet than the
- * assertion's. `UNRECORDABLE`: a charge no retry can record, held for refund review.
+ * Run MoonPay's connection check with `sessionToken`; it asks for an OTP only if the hidden check
+ * fails. `resetConnection`: the device's connection is another buyer's, so reset it first.
  */
-export type MoonPayOrderRefusal = 'CUSTOMER_MISMATCH' | 'WALLET_MISMATCH' | 'UNRECORDABLE';
+export type MoonPayConnectPrompt = {
+    next: 'connect';
+    sessionToken: string;
+    quoteInput: MoonPayQuoteInput;
+    resetConnection?: true;
+};
+export type MoonPayConnectRequest = {
+    action: 'connect';
+    customerId: string;
+    accessToken: string;
+};
 /** 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
+ * A reason on one field of a `kyc` prompt. `fieldId` names a field in that prompt. `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 {
@@ -114,82 +109,85 @@ export interface MoonPayFieldError {
     message: string;
     code?: MoonPayFieldErrorCode;
 }
-/** The answer to `observe` and `kyc`. */
-export type MoonPayStepResponse = 
-/** Show `documents` (every one at `stage`), send `POST /fiat/terms`, then `observe`. */
-{
-    status: 'TERMS';
-    stage: TermsStage;
-    documents: TermsDocument[];
-}
-/**
- * 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`. */
- | {
-    status: 'KYC';
+/** Show the shared form. */
+export type MoonPayKycPrompt = {
+    next: 'kyc';
     fields: FormField[];
     fieldErrors?: MoonPayFieldError[];
-}
-/** Send `observe` after the delay. Never `kyc` again: its write is done. */
- | {
-    status: 'PENDING';
+};
+/** Keyed by the ids of the prompt's fields; there is no form id. Needs `credentials`: the backend reads the customer. */
+export type MoonPayKycRequest = {
+    action: 'kyc';
+    credentials: MoonPaySdkCredentials;
+    values: Partial<Record<KycFieldId, string>>;
+};
+/** MoonPay is reviewing. No request of its own: send `observe` after the delay. */
+export type MoonPayWaitPrompt = {
+    next: 'wait';
     retryAfterMs: number;
-}
-/** Mount Apple Pay with `externalTransactionId = orderId`, then send `order` after the charge. */
- | {
-    status: 'READY';
+};
+/** Get the device quote from `quoteInput`, mount Apple Pay with `externalTransactionId = orderId`. */
+export type MoonPayOrderPrompt = {
+    next: 'order';
     orderId: string;
     quoteInput: MoonPayQuoteInput;
-}
-/** Exit the provider flow. `REQUOTE` goes back to `POST /fiat/quote`; `NONE` ends the flow. */
- | {
-    status: 'REFUSED';
-    reason: MoonPayStepRefusal;
-    recovery: 'REQUOTE' | 'NONE';
 };
 /**
- * The answer to `order`, which runs after each charge attempt. A failed charge is recorded too: it
- * answers `DONE` with the order in `FAILED`, and the client requotes for a new `orderId`.
+ * After every charge attempt, a failed one too. `quotedAmount` is the fiat amount the device quote
+ * showed. `transactionId` is from the Apple Pay event when it has one; without it the backend
+ * records the failed charges MoonPay lists for `orderId`.
  */
-export type MoonPayOrderResponse = 
-/** The `GET /fiat/orders/:orderId` response; the shared order screen renders it. */
-{
-    status: 'DONE';
-    order: FiatStepResponse;
-}
+export type MoonPayOrderRequest = {
+    action: 'order';
+    orderId: string;
+    quotedAmount: FiatAmount;
+    transactionId?: string;
+};
+export type MoonPayRequest = MoonPayRequestContext & (MoonPayObserveRequest | MoonPayConsentRequest | MoonPayConnectRequest | MoonPayKycRequest | MoonPayOrderRequest);
+/** The wire body. The orchestrator reads `provider` and `geo`; MoonPay's action schemas read the rest. */
+export type MoonPayNextRequest = {
+    provider: 'MOONPAY';
+    geo: FiatGeo;
+} & MoonPayRequest;
+/** `REQUOTE` for `NOT_ELIGIBLE` and `DOCUMENTS_REQUIRED`, `NONE` for the others. */
+export type MoonPayStepRefusal = 'NOT_ELIGIBLE' | 'DOCUMENTS_REQUIRED' | 'FINAL_REJECTION' | 'CUSTOMER_MISMATCH';
 /**
- * MoonPay does not list the transaction yet. Send the same `order` after the delay. After a failed
- * charge with no `transactionId`, the client caps these polls.
+ * After a charge, always with `recovery: NONE`. `CUSTOMER_MISMATCH`: the transaction's customer is
+ * not bound to this buyer. `WALLET_MISMATCH`: the transaction pays another wallet than the
+ * assertion's. `UNRECORDABLE`: a charge no retry can record, held for refund review.
  */
- | {
-    status: 'PENDING';
-    retryAfterMs: number;
-}
-/** Exit the provider flow. A requote after a charge would start a second payment. */
- | {
-    status: 'REFUSED';
-    reason: MoonPayOrderRefusal;
-    recovery: 'NONE';
+export type MoonPayOrderRefusal = 'CUSTOMER_MISMATCH' | 'WALLET_MISMATCH' | 'UNRECORDABLE';
+export type MoonPayPrompt = MoonPayConsentPrompt | MoonPayConnectPrompt | MoonPayKycPrompt | MoonPayWaitPrompt | MoonPayOrderPrompt;
+/** `order` is the `GET /fiat/orders/:orderId` body; the shared order screen renders it. */
+export type MoonPayDone = {
+    next: 'done';
+    order: FiatStepResponse;
 };
-export type MoonPayIntentResponseFor = {
+/** Exit the provider flow. `REQUOTE` goes back to routing; `NONE` ends the flow. */
+export type MoonPayRefused<R, V> = {
+    next: 'refused';
+    reason: R;
+    recovery: V;
+};
+/** The answer to `observe`, `consent`, `connect` and `kyc`. */
+export type MoonPayStepResponse = MoonPayPrompt | MoonPayRefused<MoonPayStepRefusal, 'REQUOTE' | 'NONE'>;
+/**
+ * The answer to `order`. A failed charge is recorded too: `done` with the order in `FAILED`, and the
+ * client requotes for a new `orderId`. `order` again while MoonPay does not list the transaction
+ * yet. A refusal after a charge never requotes: that would start a second payment.
+ */
+export type MoonPayOrderResponse = MoonPayDone | MoonPayOrderPrompt | MoonPayRefused<MoonPayOrderRefusal, 'NONE'>;
+export type MoonPayResponseFor = {
     observe: MoonPayStepResponse;
+    consent: MoonPayStepResponse;
+    connect: MoonPayStepResponse;
     kyc: MoonPayStepResponse;
     order: MoonPayOrderResponse;
 };
-export type MoonPayIntentResponse = MoonPayStepResponse | MoonPayOrderResponse;
-export type MoonPayIntentStatus = MoonPayIntentResponse['status'];
-/** `RETRY` sends the same request again. `REQUOTE` goes back to `POST /fiat/quote`. `NONE` ends the flow. */
+/** `RETRY` sends the same request again. `REQUOTE` goes back to routing. `NONE` ends the flow. */
 export type MoonPayRecovery = 'RETRY' | 'REQUOTE' | 'NONE';
 /**
- * `SESSION_BUDGET_SPENT`: the per-login SDK session mint budget (429). `RATE_LIMITED`: the kind's
+ * `SESSION_BUDGET_SPENT`: the per-login SDK session mint budget (429). `RATE_LIMITED`: the action's
  * request budget (429). `PROVIDER_UNAVAILABLE`: MoonPay or Sumsub is down. `INVALID_REQUEST`: a bad
  * body (400).
  */

package/dist/providers/moonpay.js

@@ -24,6 +24,6 @@ __export(moonpay_exports, {
 });
 module.exports = __toCommonJS(moonpay_exports);
 var MOONPAY_ENDPOINTS = {
-  intent: "POST /fiat/providers/moonpay/intent"
+  next: "POST /fiat/next"
 };
 //# sourceMappingURL=moonpay.js.map

package/dist/providers/moonpay.mjs

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

package/dist/providers/moonpay.schemas.d.ts

@@ -1,16 +1,33 @@
 /**
- * zod schemas for the MoonPay provider-owned flow. Test-time and backend-boundary only: exported from
- * the package root, never from `./moonpay`, so the production entry stays free of zod.
+ * zod schemas for the MoonPay flow on `POST /fiat/next`. Test-time and backend-boundary only:
+ * exported from the package root, never from `./moonpay`, so the production entry stays free of zod.
  */
 import { z } from 'zod';
-import type { MoonPayCheckout, MoonPayErrorBody, MoonPayFault, MoonPayIntentRequest, MoonPayIntentResponse, MoonPayOrderResponse, MoonPayQuoteInput, MoonPaySdkCredentials, MoonPayStepResponse } from './moonpay';
+import type { MoonPayCheckout, MoonPayConnectPrompt, MoonPayConnectRequest, MoonPayConsentPrompt, MoonPayConsentRequest, MoonPayDone, MoonPayErrorBody, MoonPayFault, MoonPayKycPrompt, MoonPayKycRequest, MoonPayNextRequest, MoonPayObserveRequest, MoonPayOrderPrompt, MoonPayOrderRequest, MoonPayOrderResponse, MoonPayPrompt, MoonPayQuoteInput, MoonPayRequest, MoonPayRequestContext, MoonPayResponseFor, MoonPaySdkCredentials, MoonPayStepResponse, MoonPayWaitPrompt } from './moonpay';
 export declare const MoonPayCheckoutSchema: z.ZodType<MoonPayCheckout>;
 export declare const MoonPaySdkCredentialsSchema: z.ZodType<MoonPaySdkCredentials>;
-export declare const MoonPayIntentRequestSchema: z.ZodType<MoonPayIntentRequest>;
+export declare const MoonPayRequestContextSchema: z.ZodType<MoonPayRequestContext>;
 export declare const MoonPayQuoteInputSchema: z.ZodType<MoonPayQuoteInput>;
+export declare const MoonPayObserveRequestSchema: z.ZodType<MoonPayRequestContext & MoonPayObserveRequest>;
+export declare const MoonPayConsentRequestSchema: z.ZodType<MoonPayRequestContext & MoonPayConsentRequest>;
+export declare const MoonPayConnectRequestSchema: z.ZodType<MoonPayRequestContext & MoonPayConnectRequest>;
+export declare const MoonPayKycRequestSchema: z.ZodType<MoonPayRequestContext & MoonPayKycRequest>;
+export declare const MoonPayOrderRequestSchema: z.ZodType<MoonPayRequestContext & MoonPayOrderRequest>;
+export declare const MoonPayRequestSchema: z.ZodType<MoonPayRequest>;
+export declare const MoonPayNextRequestSchema: z.ZodType<MoonPayNextRequest>;
+export declare const MoonPayConsentPromptSchema: z.ZodType<MoonPayConsentPrompt>;
+export declare const MoonPayConnectPromptSchema: z.ZodType<MoonPayConnectPrompt>;
+export declare const MoonPayKycPromptSchema: z.ZodType<MoonPayKycPrompt>;
+export declare const MoonPayWaitPromptSchema: z.ZodType<MoonPayWaitPrompt>;
+export declare const MoonPayOrderPromptSchema: z.ZodType<MoonPayOrderPrompt>;
+export declare const MoonPayPromptSchema: z.ZodType<MoonPayPrompt>;
+export declare const MoonPayDoneSchema: z.ZodType<MoonPayDone>;
 export declare const MoonPayStepResponseSchema: z.ZodType<MoonPayStepResponse>;
 export declare const MoonPayOrderResponseSchema: z.ZodType<MoonPayOrderResponse>;
-export declare const MoonPayIntentResponseSchema: z.ZodType<MoonPayIntentResponse>;
+/** The response schema for each request action, as `MoonPayResponseFor` types it. */
+export declare const MoonPayResponseSchemaFor: {
+    readonly [A in keyof MoonPayResponseFor]: z.ZodType<MoonPayResponseFor[A]>;
+};
 export declare const MoonPayFaultSchema: z.ZodType<MoonPayFault>;
 export declare const MoonPayErrorBodySchema: z.ZodType<MoonPayErrorBody>;
 //# sourceMappingURL=moonpay.schemas.d.ts.map

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: `POST /fiat/next` replaces it for each provider that moves there. */
+    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: `POST /fiat/next` replaces it for each provider that moves there. */
+  quote: "POST /fiat/routing/quote"
+};
+//# sourceMappingURL=routing.js.map

package/dist/routing.mjs

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

package/dist/schemas.d.ts

@@ -28,8 +28,9 @@
  */
 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 { 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, FiatGeo, FiatNextRequest } 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,13 @@ 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 FiatGeoSchema: z.ZodType<FiatGeo>;
+export declare const FiatNextRequestSchema: z.ZodType<FiatNextRequest>;
 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.2";
+var version = "0.24.0";
 
 // src/table.ts
 var TABLE_VERSION = version;

package/dist/table.mjs

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

package/dist/terms.d.ts

@@ -2,7 +2,7 @@
  * The platform terms route: `POST /fiat/terms`, shared by every provider.
  *
  * A checkout shows the user documents to accept. `CHECKOUT` documents are the constants below;
- * `KYC` documents arrive in a provider flow's `TERMS` response. The user's Continue tap is the
+ * `KYC` documents arrive in a provider flow's consent prompt. The user's Continue tap is the
  * acceptance, and the client records it here before the next provider call. A repeat writes nothing.
  *
  * Zero runtime dependencies, so production React Native code can import it. The zod schemas are
@@ -39,7 +39,7 @@ export interface FiatTermsRequest {
     /** One per document the screen showed, each document at most once. */
     acceptances: TermsDocumentAcceptance[];
 }
-/** The recorded document ids. The client then calls the provider's `intent`. */
+/** The recorded document ids. The client then calls `POST /fiat/next`. */
 export interface FiatTermsResponse {
     recorded: string[];
 }

package/dist/terms.mjs

@@ -3,7 +3,7 @@ import {
   FUN_KYC_CONSENT_DOCUMENTS,
   PROVIDER_CHECKOUT_DOCUMENTS,
   PUBLISHED_TERMS_DOCUMENTS
-} from "./chunk-5GRPYE2U.mjs";
+} from "./chunk-CRNKRIKR.mjs";
 export {
   FIAT_TERMS_ENDPOINT,
   FUN_KYC_CONSENT_DOCUMENTS,