@coinlist-co/react 0.12.2-rc.0ff2d03 → 0.12.2-rc.3de3751

package/dist/client/index.d.ts

@@ -1,8 +1,8 @@
 import * as react from 'react';
 import { ReactNode, MouseEventHandler } from 'react';
-import { A as AuthorizationCode, C as CodeVerifier, W as WalletError, a as AssetSymbol, E as EthereumChain, O as OfferVaultContract, b as EvmContractAddress, B as BlockchainAmount, c as CentrifugeVaultBuyTransaction, d as CentrifugeClaimDirection, e as CentrifugeNamespace, f as OfferId, g as OfferOptionId, h as AssetId, P as Participation, i as CoinListTokenSaleNamespace, j as OfferSwapContract, k as OndoBuyTransaction, l as OndoSellTransaction, m as OndoNamespace, n as OndoSwapTransactionCore, o as OrderBookSide, S as SwapQuote, p as Bps, q as EvmWalletAddress, r as SuperstateSwapNamespace, R as RequirementsNamespace, s as Requirement, t as WalletChallengeType, u as OfferOptionAddress, v as WalletsNamespace, w as Config, x as OAuthAccessToken, y as OffersNamespace, z as Erc20Namespace, T as TokensNamespace, D as Offer, F as TokenMetadata, G as OfferDetail, H as StablecoinSymbol, I as Erc20Asset, J as CoinListTokenSaleOfferDetail, K as CentrifugeVaultLegId, L as CentrifugeVaultOfferDetail, M as Seconds, N as AsyncOfferDetail, Q as RequirementStatusInfo, U as KycLevelName, V as RequirementType, X as RequirementStatusValue, Y as RequirementId, Z as PinoLoggerOptions, _ as Logger, $ as CentrifugeVaultStatus, a0 as CentrifugeVaultRef, a1 as BuildCentrifugeVaultBuyParams, a2 as BuildOndoBuyParams, a3 as OndoSwapOfferDetail, a4 as BuildOndoSellParams, a5 as OndoQuote, a6 as OndoQuoteSize, a7 as OndoTradingStatus, a8 as AssetDecimals, a9 as SuperstateSwapOfferDetail, aa as CentrifugeVaultLeg, ab as CentrifugeVault, ac as OfferOptionAddressId, ad as DocumentSubmission, ae as TokenIdentifier } from '../time-BDzqB806.js';
+import { A as AuthorizationCode, C as CodeVerifier, W as WalletError, E as EthereumChain, a as AssetSymbol, O as OfferVaultContract, b as EvmContractAddress, B as BlockchainAmount, c as CentrifugeVaultBuyTransaction, d as CentrifugeClaimDirection, e as CentrifugeNamespace, f as OfferId, g as OfferOptionId, h as AssetId, P as Participation, i as CoinListTokenSaleNamespace, j as OfferSwapContract, k as OndoBuyTransaction, l as OndoSellTransaction, m as OndoNamespace, n as OndoSwapTransactionCore, o as OrderBookSide, S as SwapQuote, p as Bps, q as EvmWalletAddress, r as SuperstateSwapNamespace, R as RequirementsNamespace, s as Requirement, t as WalletChallengeType, u as OfferOptionAddress, v as WalletsNamespace, w as Config, x as OAuthAccessToken, y as OffersNamespace, z as Erc20Namespace, T as TokensNamespace, D as Offer, F as TokenMetadata, G as OfferDetail, H as StablecoinSymbol, I as Erc20Asset, J as CoinListTokenSaleOfferDetail, K as CentrifugeVaultLegId, L as CentrifugeVaultOfferDetail, M as Seconds, N as AsyncOfferDetail, Q as RequirementStatusInfo, U as KycLevelName, V as RequirementType, X as RequirementStatusValue, Y as RequirementId, Z as PinoLoggerOptions, _ as Logger, $ as CentrifugeVaultStatus, a0 as CentrifugeVaultRef, a1 as BuildOndoBuyParams, a2 as OndoSwapOfferDetail, a3 as BuildOndoSellParams, a4 as OndoQuote, a5 as OndoQuoteSize, a6 as OndoTradingStatus, a7 as AssetDecimals, a8 as SuperstateSwapOfferDetail, a9 as CentrifugeVaultLeg, aa as CentrifugeVault, ab as OfferOptionAddressId, ac as DocumentSubmission, ad as TokenIdentifier } from '../time-DkU7jivQ.js';
 import { Hash } from 'viem';
-import { E as EvmWallet, C as ConnectWallet, F as FormattedAmountAssetUi, T as TxExplorerUrl, A as AssetIconUrl, W as WalletSelection, a as WalletLabelResolver, S as ShortenedWalletAddress, b as FormattedPercentUi, N as NonEmptyArray, c as TokenRegistrySnapshot } from '../token-registry-snapshot-cvLsnMo_.js';
+import { E as EvmWallet, C as ConnectWallet, W as WalletSelection, F as FormattedAmountAssetUi, T as TxExplorerUrl, A as AssetIconUrl, a as WalletLabelResolver, S as ShortenedWalletAddress, b as FormattedPercentUi, N as NonEmptyArray, c as TokenRegistrySnapshot } from '../token-registry-snapshot-D0OWXMe4.js';
 
 type AuthState = 'unknown' | 'logged-in' | 'logged-out';
 /** Discriminated error reasons from {@link CoinListClient.completeOAuth}. */
@@ -73,7 +73,7 @@ interface ClientAuthNamespace {
     logout(): void;
 }
 
-type Erc20AllowancePhase = 'checking-allowance' | 'resetting-allowance' | 'confirming-allowance-reset' | 'approving' | 'confirming-approval';
+type Erc20AllowancePhase = 'checking-allowance' | ResetThenApprovePhase;
 type Erc20AllowanceError = {
     step: 'allowance-check';
 } | Erc20ApprovalError;
@@ -84,24 +84,32 @@ type Erc20ApprovalError = {
 } | {
     step: 'approval-reverted';
 };
+/**
+ * The phases {@link resetThenApprove} reports, in order. The two reset phases
+ * occur only when there is a non-zero allowance to reset.
+ */
+type ResetThenApprovePhase = 'resetting-allowance' | 'confirming-allowance-reset' | 'approving' | 'confirming-approval';
 
 /**
- * Progress phases emitted while a request is being prepared, in order. An
- * allowance that already covers the deposit skips the approval phases.
- *
- * @alpha
+ * Progress phases emitted while a backend-built order is being prepared, in
+ * the order they occur. An allowance that already covers the order skips the
+ * approval phases.
  */
-type CentrifugeBuyPreparationPhase = Erc20AllowancePhase | 'building-transaction';
+type ApproveThenBuildPhase = Erc20AllowancePhase | 'building-transaction';
 /**
  * A step-tagged reason a preparation failed.
  *
- * `insufficient-allowance` is the one with a remedy that is not a new
- * approval: the approval this flow just mined is not the one frontline sees,
- * usually because its node is a block behind. Retrying reads it again.
+ * Every arm names a *remedy* rather than a provider or a trade: an unsupported
+ * chain, a refused approval and a build that would not complete are fixed the
+ * same way whichever token was being approved, and whoever built it.
  *
- * @alpha
+ * `insufficient-allowance` is separated from the generic build failure because
+ * it is the one with a remedy: the backend reads the allowance itself before
+ * building, so reaching it means the approval this flow just mined is not the
+ * one the backend sees. That is usually its RPC node lagging a block behind,
+ * which retrying fixes - so it is a retry, not a re-approval.
  */
-type CentrifugeBuyPreparationError = {
+type ApproveThenBuildError = {
     step: 'unsupported-chain';
     chain: EthereumChain;
 } | Erc20AllowanceError | {
@@ -109,14 +117,34 @@ type CentrifugeBuyPreparationError = {
 } | {
     step: 'build-transaction';
 };
-/** @alpha */
-type CentrifugeBuyPreparationResult = {
+/**
+ * A prepared order of whichever kind was asked for, or the step that stopped
+ * it. Generic in the transaction, so a caller gets back the type its `build`
+ * returned.
+ */
+type ApproveThenBuildResult<T> = {
     type: 'success';
-    transaction: CentrifugeVaultBuyTransaction;
+    transaction: T;
 } | {
     type: 'error';
-    error: CentrifugeBuyPreparationError;
+    error: ApproveThenBuildError;
 };
+
+/**
+ * Progress phases emitted while a request is being prepared, in order. An
+ * allowance that already covers the deposit skips the approval phases.
+ *
+ * @alpha
+ */
+type CentrifugeBuyPreparationPhase = ApproveThenBuildPhase;
+/**
+ * A step-tagged reason a preparation failed - see {@link ApproveThenBuildError}.
+ *
+ * @alpha
+ */
+type CentrifugeBuyPreparationError = ApproveThenBuildError;
+/** @alpha */
+type CentrifugeBuyPreparationResult = ApproveThenBuildResult<CentrifugeVaultBuyTransaction>;
 /** @alpha */
 type PrepareCentrifugeBuyParams = {
     wallet: EvmWallet;
@@ -388,28 +416,13 @@ interface ClientCoinListTokenSaleNamespace extends CoinListTokenSaleNamespace {
  * Progress phases emitted while an order is being prepared, in the order they
  * occur. An allowance that already covers the order skips the approval phases.
  */
-type OndoSwapPreparationPhase = Erc20AllowancePhase | 'building-transaction';
+type OndoSwapPreparationPhase = ApproveThenBuildPhase;
 /**
- * A step-tagged reason a preparation failed.
- *
- * Shared by both directions because every arm names a *remedy* rather than a
- * trade: an unsupported chain, a refused approval and a build that would not
- * complete are fixed the same way whichever token was being approved.
- *
- * `insufficient-allowance` is separated from the generic build failure because
- * it is the one with a remedy: frontline reads the allowance before asking
- * Ninshubur for anything, so reaching it means the approval this flow just
- * mined is not the one frontline sees. That is usually its RPC node lagging a
- * block behind, which retrying fixes - so it is a retry, not a re-approval.
+ * A step-tagged reason a preparation failed. Shared by both directions, and
+ * with every other backend-built checkout, because every arm names a remedy
+ * rather than a trade - see {@link ApproveThenBuildError}.
  */
-type OndoSwapPreparationError = {
-    step: 'unsupported-chain';
-    chain: EthereumChain;
-} | Erc20AllowanceError | {
-    step: 'insufficient-allowance';
-} | {
-    step: 'build-transaction';
-};
+type OndoSwapPreparationError = ApproveThenBuildError;
 /**
  * A prepared order of whichever kind was asked for, or the step that stopped
  * it.
@@ -417,13 +430,7 @@ type OndoSwapPreparationError = {
  * Generic in the transaction rather than a union over the two, so a caller
  * that asked for a sale cannot be handed a purchase to narrow.
  */
-type OndoSwapPreparationResult<T> = {
-    type: 'success';
-    transaction: T;
-} | {
-    type: 'error';
-    error: OndoSwapPreparationError;
-};
+type OndoSwapPreparationResult<T> = ApproveThenBuildResult<T>;
 type OndoBuyPreparationResult = OndoSwapPreparationResult<OndoBuyTransaction>;
 type OndoSellPreparationResult = OndoSwapPreparationResult<OndoSellTransaction>;
 /** What both preparations take, before the two fields whose meaning forks. */
@@ -477,12 +484,21 @@ type OndoSwapExecutionPhase = 'broadcasting-swap' | 'confirming-swap';
  * `quote-expired` is a refusal to broadcast rather than a failure of a
  * broadcast: it would revert on chain and cost the user gas, and it is fixed
  * by building a fresh transaction.
+ *
+ * `swap` means the wallet never sent it, so placing again is safe.
+ * `swap-unconfirmed` means it was sent and the receipt wait failed: the swap
+ * may still mine, and placing again can fill the order twice. `txHash` is
+ * the transaction to look up before doing anything else.
  */
 type OndoSwapExecutionError = {
     step: 'quote-expired';
 } | {
     step: 'swap';
     cause: WalletError;
+} | {
+    step: 'swap-unconfirmed';
+    txHash: Hash;
+    cause: WalletError;
 } | {
     step: 'swap-reverted';
 };
@@ -585,9 +601,21 @@ type SwapExecutionError = {
     step: 'swap-paused';
 } | {
     step: 'swap-stopped';
-} | Erc20AllowanceError | {
+} | Erc20AllowanceError
+/** The wallet never sent the swap, so swapping again is safe. */
+ | {
     step: 'swap';
     cause: WalletError;
+}
+/**
+ * The swap was sent and the receipt wait failed. It may still mine, so
+ * swapping again can fill the order twice: `txHash` is the transaction to
+ * look up before doing anything else.
+ */
+ | {
+    step: 'swap-unconfirmed';
+    txHash: Hash;
+    cause: WalletError;
 } | {
     step: 'swap-reverted';
 };
@@ -642,9 +670,21 @@ type WalletAuthorizationError = {
     cause: WalletError;
 } | {
     step: 'allow-wallet';
-} | {
+}
+/** The wallet never sent the allow-list transaction. */
+ | {
     step: 'broadcast';
     cause: WalletError;
+}
+/**
+ * The allow-list transaction was sent and the receipt wait failed. It may
+ * still mine, so authorizing again would send a second one: `txHash` is the
+ * transaction to look up first.
+ */
+ | {
+    step: 'broadcast-unconfirmed';
+    txHash: Hash;
+    cause: WalletError;
 } | {
     step: 'not-authorized';
 };
@@ -1307,61 +1347,45 @@ type OndoSellOrderTerms = {
 };
 
 /**
- * The wallets a checkout can spend from, supplied by the host.
- *
- * The SDK ships no wallet stack and is not coupled to Privy, AppKit or
- * anything else - a partner may be a wallet provider themselves - so wallet
- * discovery and connection are inverted onto the host. It hands over ready
- * {@link EvmWallet}s and two lambdas; the SDK decides nothing about how they
- * came to exist.
+ * The wallets a checkout can spend from, supplied by the host: the shared
+ * {@link WalletSelection} every screen reads its wallets from, plus the one
+ * thing only a checkout asks for.
  *
- * There is no separate wallet model here on purpose: `EvmWallet` already
- * carries the `address`, so a `{ address, signer }` pair would be a second
- * wallet type to keep in sync with the first.
+ * A `null` `externalAdapter` hides the external-wallet row entirely, for a
+ * host that only offers embedded wallets.
  *
- * Everything the row displays beyond the address - the network name - comes
- * from the checkout's execution chain rather than from the wallet, because
- * that is the chain the transaction goes to whatever the wallet is currently
- * pointed at.
+ * Everything a wallet row displays beyond the address - the network name -
+ * comes from the checkout's execution chain rather than from the wallet,
+ * because that is the chain the transaction goes to whatever the wallet is
+ * currently pointed at.
  */
-type CheckoutWalletSelection = {
-    /**
-     * The user's embedded (custodial) wallets, in display order. Empty when they
-     * have none, which is a normal state, not an error.
-     */
-    embedded: EvmWallet[];
-    /** The connected external wallet, or `null` while none is connected. */
-    external: EvmWallet | null;
+type CheckoutWalletSelection = WalletSelection & {
     /**
      * A wallet the host has already settled on, or `null` to let the user pick.
      *
-     * When set, a checkout that supports it skips its wallet step entirely and
-     * opens on the amount, renumbering the steps that remain. That is for the
-     * host that already knows the answer - a sell page reached from a position
-     * knows which wallet holds it, and asking again would be a question with one
-     * possible answer.
+     * That is for the host that already knows the answer - a sell page reached
+     * from a position knows which wallet holds it, and a host with a single
+     * embedded wallet has only one answer on a buy too - so asking again would
+     * be a question with one possible answer. Every checkout honours it, in one
+     * of two ways:
      *
-     * It does not have to appear in `embedded` or `external`. The host supplies a
-     * ready {@link EvmWallet} either way, and the SDK never resolves this back to
-     * a row.
+     * - **Ondo buy, Ondo sell and Centrifuge buy skip their wallet step** and
+     *   open on the amount, renumbering the steps that remain. The wallet does
+     *   not have to appear in `embedded` or `external`: the host supplies a
+     *   ready {@link EvmWallet}, and these flows never resolve it back to a row.
+     * - **Superstate never skips its wallet step**, because that step
+     *   allow-lists the wallet on-chain and no preselection can stand in for it.
+     *   The step opens with the preselected wallet's row already selected, so
+     *   the user confirms it rather than finding it. That needs a row: a wallet
+     *   matching neither an `embedded` one nor the connected `external` one by
+     *   address selects nothing, and the user picks as if none was preselected.
      *
-     * **Only the Ondo sell checkout honours it today.** The field is on this seam
-     * rather than on one provider's config because nothing about it is Ondo's -
-     * any flow that opens on a wallet step could skip one - but a provider that
-     * has not adopted it ignores it rather than half-implementing it, so do not
-     * assume a skip from the field being set.
+     * Read **once**, when the checkout mounts. The approval a checkout asks for
+     * is granted by one specific wallet, so a change mid-flow is ignored; remount
+     * the checkout (a `key`) to apply a new one. After an order the flow resets
+     * to the step it opened on, so a skipped wallet step stays skipped.
      */
     preselected: EvmWallet | null;
-    /**
-     * Opens the host's wallet connector. Resolves once the attempt finishes; the
-     * SDK reads the outcome from `external` on the next render rather than from
-     * a return value, so a host that connects through a redirect still works.
-     *
-     * Rejecting is how a declined or failed connection is reported.
-     */
-    connectExternal: () => Promise<void>;
-    /** Disconnects the external wallet. Resolves when it is gone. */
-    disconnectExternal: () => Promise<void>;
 };
 
 /** What the swap actually filled at, once it has mined. */
@@ -1488,9 +1512,29 @@ interface CheckoutContainerProps {
      */
     side?: OrderBookSide;
     /**
-     * The wallets the buyer can spend from, and the lambdas that connect and
-     * disconnect an external one. The SDK ships no wallet stack, so this is how
-     * a host plugs in Privy, AppKit, or its own.
+     * The wallets the buyer can spend from, and the host's connector for an
+     * external one. The SDK ships no wallet stack, so this is how a host plugs
+     * in Privy, AppKit, or its own.
+     *
+     * ```tsx
+     * const wallets: CheckoutWalletSelection = {
+     *   embedded: myEmbeddedWallets,
+     *   external: myConnectedWallet, // or null
+     *   // `null` hides the external-wallet row, for a host with embedded
+     *   // wallets only.
+     *   externalAdapter: {
+     *     connect: () => myConnector.open(),
+     *     disconnect: () => myConnector.disconnect(),
+     *   },
+     *   preselected: null, // or the wallet the host already settled on
+     * };
+     * ```
+     *
+     * Every provider honours `wallets.preselected`. Ondo (buy and sell) and
+     * Centrifuge skip their wallet step and open on the amount, renumbering the
+     * cards that remain. Superstate never skips it, because that step
+     * allow-lists the wallet on-chain: it opens the step with the preselected
+     * wallet's row already selected instead. Read once, at mount - see below.
      */
     wallets: CheckoutWalletSelection;
     /**
@@ -1518,22 +1562,29 @@ interface CheckoutContainerProps {
  * assigns to `const exhaustive: never`, so a new offer type is a compile error
  * here as well as in {@link CheckoutConfig}.
  *
- * ## One mount, one offer, one chain, one side
- *
- * `offer`, `chain` and the `side` are read as fixed for the lifetime of
- * the mount. Each provider's viewmodel owns a step machine — which wallet was
- * authorized, how much is being spent — and that progress is bound to the order
- * it was made against: a Superstate wallet authorization is allow-listed per
- * offer, and an ERC-20 approval is granted per chain, for one specific token.
- * Changing any of the three in place would carry a completed step onto an order
- * it was never made for — a flipped side most sharply of all, since the
- * approval covers the coin the *old* direction spent. So the container does not
- * try to: `side` is read once into state and later values are ignored. A
- * swap could also land mid-execution, between an approval and the broadcast it
+ * ## One mount, one offer, one chain, one side, one preselected wallet
+ *
+ * `offer`, `chain`, the `side` and `wallets.preselected` are read as fixed for
+ * the lifetime of the mount. Each provider's viewmodel owns a step machine -
+ * which wallet was authorized, how much is being spent - and that progress is
+ * bound to the order it was made against: a Superstate wallet authorization
+ * is allow-listed per offer, and an ERC-20 approval is granted per chain, for
+ * one specific token. Changing any of them in place would carry a completed
+ * step onto an order it was never made for - a flipped side most sharply of
+ * all, since the approval covers the coin the *old* direction spent. So the
+ * container does not try to: `side` is read once into state and later values
+ * are ignored. A swap could also land mid-execution, between an approval and the broadcast it
  * was granted for, which is worse than not switching at all.
  *
- * **To render a different offer, chain or side, remount rather than
- * reassign** — give the container a `key` that changes with them:
+ * The preselected wallet is the same kind of progress: whether the flow has a
+ * wallet step at all is decided from it at mount, and the approval that
+ * follows is granted by that wallet. The rest of `wallets` stays live - a
+ * newly connected external wallet appears as a row without a remount.
+ *
+ * **To render a different offer, chain, side or preselected wallet, remount
+ * rather than reassign** - give the container a `key` that changes with them
+ * (add `wallets.preselected?.address` to it if the host's preselection can
+ * change on one page):
  *
  * ```tsx
  * <CheckoutContainer
@@ -1567,7 +1618,8 @@ interface CheckoutContainerProps {
  *
  * A sell page reached from a position also knows which wallet holds it, so it
  * usually sets {@link CheckoutWalletSelection.preselected} and opens on the
- * amount.
+ * amount. A buy page can do the same whenever the host has one answer - a
+ * single embedded wallet, say.
  *
  * ### A buy/sell toggle on one page
  *
@@ -2406,16 +2458,24 @@ interface UseOffersResult {
 declare function useOffers(options?: UseOffersOptions): UseOffersResult;
 
 /**
- * Why a Centrifuge read failed, in the only two flavours a UI acts on
- * differently.
+ * Why a read failed, in the only two flavours every UI acts on differently.
  *
  * `not-authenticated` is split out because no retry helps until the user
- * signs in. Everything else collapses into `generic-error` and is offered a
- * retry.
+ * signs in, and because the remedy is one the UI can name. Everything else
+ * collapses into `generic-error` and is offered a retry. A provider that has a
+ * third remedy of its own - Ondo's closed market - widens this union rather
+ * than restating it.
+ */
+type LoadErrorReason = 'not-authenticated' | 'generic-error';
+
+/**
+ * Why a Centrifuge read failed. Centrifuge has no remedy of its own to add,
+ * so this is {@link LoadErrorReason} under the name its states already
+ * publish, classified by `loadErrorReason`.
  *
  * @alpha
  */
-type CentrifugeLoadErrorReason = 'not-authenticated' | 'generic-error';
+type CentrifugeLoadErrorReason = LoadErrorReason;
 
 /**
  * The state of one vault's status poll.
@@ -2432,6 +2492,8 @@ type CentrifugeLoadErrorReason = 'not-authenticated' | 'generic-error';
  * @alpha
  */
 type LoadCentrifugeVaultStatusState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -2481,11 +2543,11 @@ interface UseCentrifugeVaultStatusesResult {
  * otherwise left to the poll: the first tick fires as it always does, and
  * only replaces the seed once it has a status of its own.
  *
- * Disabled it neither fetches nor holds a timer, and each vault stays on
- * whatever state it held. That is `LOADING` and not an empty `CONTENT`
- * because there is no empty vault status - and an invented one would be
- * worse than none, since `CONTENT` here is what a caller is allowed to block
- * on.
+ * Disabled it neither fetches nor holds a timer. A vault with no status in
+ * hand reports `DISABLED`, not an empty `CONTENT`: there is no empty vault
+ * status, and an invented one would be worse than none, since `CONTENT` here
+ * is what a caller is allowed to block on. A status already in hand survives
+ * being switched off.
  *
  * @alpha
  */
@@ -2536,12 +2598,16 @@ declare function useCentrifugeVaultStatus(options: UseCentrifugeVaultStatusOptio
  * that provider's `use{X}ViewModel.types`; these live here because Ondo and
  * Superstate both render them.
  *
- * Models only. A screen's `{X}UiState` and `{X}UiEvent` stay in that screen's
- * `use{X}ViewModel.types` even when two providers' happen to agree today: a
- * state machine is where providers diverge, and sharing one would make the
- * divergence a breaking change rather than a local edit. Ondo's wallet step
- * confirms synchronously and Superstate's allow-lists on-chain, from the same
- * rows and the same models.
+ * Models only. A provider screen's `{X}UiState` and `{X}UiEvent` stay in that
+ * screen's `use{X}ViewModel.types` even when two providers' happen to agree
+ * today: a state machine is where providers diverge, and sharing one would
+ * make the divergence a breaking change rather than a local edit. A step with
+ * zero provider input is the exception and is shared whole, in its own
+ * `shared/` screen directory - the wallet step Ondo and Centrifuge render as
+ * it stands, while Superstate's allow-lists on-chain from the same rows and
+ * the same models; and the validate-only amount step Centrifuge and
+ * Superstate render as it stands, while Ondo's approves on confirm and builds
+ * its own from the same rules and leaves.
  *
  * No React and no hooks: this is the module Views and leaf components import.
  */
@@ -2561,6 +2627,17 @@ type CheckoutCtaUi = {
     type: 'loading';
     message: string;
 };
+/**
+ * What an amount field's number is denominated in, drawn beside it.
+ *
+ * A token symbol follows the number as its unit (`1,000 USDC`); a currency
+ * sign leads it (`$1,000`). One closed variant rather than a `prefix` and a
+ * `suffix` that could both be set, because a figure has one unit.
+ */
+type CheckoutAmountAdornmentUi = {
+    type: 'prefix' | 'suffix';
+    text: string;
+};
 /**
  * A status and the copy that names it: an Ondo market that is open, a sale
  * still running, a window that has closed.
@@ -2667,6 +2744,42 @@ type CheckoutWalletUi = {
 type CheckoutEmbeddedWalletUi = CheckoutWalletUi & {
     walletAddress: EvmWalletAddress;
 };
+/**
+ * The external-wallet row of a checkout's wallet step.
+ *
+ * - `hidden`: the host offers no connector and none is connected, so there is
+ *   no row at all - a host that only supports embedded wallets.
+ * - `disconnected`: the host offers a connector and nothing is connected yet.
+ *   The row is the invitation to connect one.
+ * - `connected`: a wallet like any other. `canDisconnect` is `false` when the
+ *   host offers no connector (it handed over a wallet the user cannot change
+ *   from here) or while the step is using that wallet.
+ *
+ * A SUM rather than a nullable wallet beside a flag, so a View cannot offer to
+ * connect a wallet the host has no way of connecting.
+ */
+type CheckoutExternalWalletUi = {
+    type: 'hidden';
+} | {
+    type: 'disconnected';
+} | {
+    type: 'connected';
+    wallet: CheckoutWalletUi;
+    canDisconnect: boolean;
+};
+declare const CheckoutExternalWalletUi: {
+    /**
+     * The external-wallet row for the host's wallets.
+     *
+     * `locked` is for a step that is using the external wallet right now - mid
+     * signature, say - and must not let it be disconnected underneath itself.
+     */
+    fromDomain: (wallets: WalletSelection, { network, selected, locked, }: {
+        network: string;
+        selected: boolean;
+        locked: boolean;
+    }) => CheckoutExternalWalletUi;
+};
 /**
  * The wallet the user settled on.
  *
@@ -2719,95 +2832,23 @@ type CheckoutSelectableInputAssetUi = {
     rawBalance: bigint;
     selected: boolean;
 };
-
-/**
- * Step 2 of the Centrifuge checkout: how much of the funding token to deposit.
- *
- * Nothing here touches the chain. Confirming checks the amount in memory and
- * hands it up. The review step approves and places the request together.
- *
- * @alpha
- */
-type CentrifugeBuyAmountUiState = {
-    type: 'incomplete';
-} | {
-    type: 'active';
-    /** Exactly what the user has typed. `'1.'` is a legal thing to hold. */
-    amountInput: string;
-    walletAddress: ShortenedWalletAddress;
-    inputAssets: CheckoutSelectableInputAssetUi[];
-    confirmCta: CheckoutCtaUi;
-    error: string | null;
-} | {
-    type: 'complete';
-    inputAsset: CheckoutAssetUi;
-    amountFormatted: FormattedAmountAssetUi;
-};
-/** @alpha */
-type CentrifugeBuyAmountUiEvent = {
-    type: 'ON_AMOUNT_CHANGE';
-    value: string;
-} | {
-    type: 'ON_MAX_AMOUNT_CLICK';
-} | {
-    type: 'ON_SELECT_PAY_WITH';
-    value: AssetSymbol;
-} | {
-    type: 'ON_CONFIRM_AMOUNT';
-} | {
-    type: 'ON_EDIT_AMOUNT';
-};
-
 /**
- * The built deposit request a review step can place.
- *
- * `isRefreshing` rides on `CONTENT` so a rebuild never blanks the numbers on
- * screen. A failed rebuild keeps them and says why.
+ * Where a placed order can be checked: the wallet it settles to, and the
+ * transaction on a block explorer.
  *
- * @alpha
+ * Every provider's order dialog carries the pair, and builds it the same way
+ * from the same three facts, so it is one model rather than two fields each
+ * dialog re-derives.
  */
-type LoadCentrifugeBuyTransactionState = {
-    type: 'LOADING';
-} | {
-    type: 'ERROR';
-    reason: CentrifugeLoadErrorReason;
-} | {
-    type: 'CONTENT';
-    transaction: CentrifugeVaultBuyTransaction;
-    isRefreshing: boolean;
-    refreshError: CentrifugeLoadErrorReason | null;
-};
-/** @alpha */
-interface UseCentrifugeBuyTransactionOptions {
-    /**
-     * The request to build, or `null` before an amount is confirmed. A `null`
-     * request fetches nothing.
-     */
-    request: BuildCentrifugeVaultBuyParams | null;
+type CheckoutReceiptUi = {
+    /** The wallet the order settles to. */
+    recipientAddress: ShortenedWalletAddress;
     /**
-     * A request the caller already holds, typically the one `prepareBuy`
-     * returned. When present the hook adopts it and skips the initial build.
-     * `refetch` still builds.
+     * The order's transaction on a block explorer. Always present: a dialog
+     * only exists once there is a transaction to point at.
      */
-    data?: CentrifugeVaultBuyTransaction;
-    /** When false, the hook does not build. */
-    enabled: boolean;
-}
-/** @alpha */
-interface UseCentrifugeBuyTransactionResult {
-    state: LoadCentrifugeBuyTransactionState;
-    /** Builds a fresh request for the same deposit. */
-    refetch: () => void;
-}
-/**
- * Holds the deposit request the review step places, and rebuilds it when
- * asked.
- *
- * **Never polls.** A request is built once, when the user confirms an amount.
- *
- * @alpha
- */
-declare function useCentrifugeBuyTransaction(options: UseCentrifugeBuyTransactionOptions): UseCentrifugeBuyTransactionResult;
+    txExplorerUrl: TxExplorerUrl;
+};
 
 /**
  * Step 3 of the Centrifuge checkout: confirming the deposit and placing it.
@@ -2842,38 +2883,37 @@ type CentrifugeBuyReviewUiEvent = {
 };
 
 /**
- * Why a Centrifuge checkout cannot run right now, as opposed to a step of it
- * failing.
+ * Why a checkout cannot run right now, as opposed to a step of it failing.
  *
- * @alpha
- */
-type CentrifugeCheckoutErrorReason = 
-/**
- * The offer names no vault proxy on the chain the host asked for, so there
- * is no spender to approve and nothing to broadcast to.
+ * Every provider has the same two kinds of answer, and only the second is
+ * named per provider:
+ *
+ * - `unsupported-chain`: the offer names no contract on the chain the host
+ *   asked for, so there is no spender to approve and nothing to broadcast to.
+ *   Settled at mount, since the offer and the chain are both fixed for its
+ *   lifetime, so nothing can clear it.
+ * - `TBlocked`: the provider is known not to take an order right now - a
+ *   closed market, a paused vault. Known from a poll, never assumed from one
+ *   that is still loading or failed, and it clears on its own once the poll
+ *   says so.
+ *
+ * A union rather than a bare flag because the View switches on it for copy.
  */
-'unsupported-chain'
+type CheckoutBlockedReason<TBlocked extends string> = 'unsupported-chain' | TBlocked;
+
 /**
- * The vault is known to be unable to take a request: halted, unlinked, or
- * not permissioned. Known from a status whose orderability is blocked.
- * Loading and failed statuses are unknown, and unknown does not block.
+ * Why a Centrifuge checkout cannot run right now, as opposed to a step of it
+ * failing. See {@link CheckoutBlockedReason} for `unsupported-chain`, which
+ * here means the offer names no vault proxy on the chain.
+ *
+ * `not-orderable` is Centrifuge's block: the vault is known to be unable to
+ * take a request - halted, unlinked, or not permissioned. Known from a status
+ * whose orderability is blocked; loading and failed statuses are unknown, and
+ * unknown does not block.
  *
- * Shown only while the user is still choosing a wallet and no request-placed
- * dialog is up. Past that, a pause belongs to the step it interrupts.
+ * @alpha
  */
- | 'not-orderable';
-/** @alpha */
-declare const CentrifugeCheckoutErrorReason: {
-    /**
-     * Which reason, if any, replaces the whole checkout. `null` means the steps
-     * render.
-     */
-    of: ({ depositableHere, notOrderable, atEntry, }: {
-        depositableHere: boolean;
-        notOrderable: boolean;
-        atEntry: boolean;
-    }) => CentrifugeCheckoutErrorReason | null;
-};
+type CentrifugeCheckoutErrorReason = CheckoutBlockedReason<'not-orderable'>;
 
 /**
  * The asset panel beside the Centrifuge checkout.
@@ -2928,24 +2968,113 @@ type CentrifugeSidebarMinimumUi = {
 };
 
 /**
- * Step 1 of the Centrifuge checkout: which wallet funds the deposit.
+ * The amount step of a checkout whose amount step takes no provider input:
+ * how much to spend, and which stablecoin to spend it in. Centrifuge and
+ * Superstate render it as it stands.
+ *
+ * Shared whole, state machine included, because it is not a provider state
+ * machine: nothing here touches the chain, so confirming checks the amount in
+ * memory and hands it up, and there is nothing for a provider to diverge on.
+ * It forks the moment one provider needs different behaviour - Ondo's already
+ * has, since its confirm approves and builds an order, so it keeps its own
+ * state over the same rules and leaves.
+ *
+ * The CTA is a `CheckoutCtaUi` all the same, rather than a `confirmEnabled`
+ * flag, so the View renders it through the one CTA every amount step uses. It
+ * is never `loading` here.
+ */
+type CheckoutAmountUiState = {
+    type: 'incomplete';
+} | {
+    type: 'active';
+    /**
+     * Exactly what the user has typed, not a parsed number: the field is
+     * mid-edit, and `'1.'` is a legal thing to be holding.
+     */
+    amountInput: string;
+    /**
+     * What the field is denominated in: the selected coin's symbol after the
+     * number, or a `$` before it for a dollar-denominated field.
+     */
+    adornment: CheckoutAmountAdornmentUi;
+    /** The wallet the funds come from, per the wallet step. */
+    walletAddress: ShortenedWalletAddress;
+    /**
+     * Every fundable asset, in display order, whether or not the user holds
+     * any. One entry renders as a plain card, two or more as a picker.
+     */
+    inputAssets: CheckoutSelectableInputAssetUi[];
+    confirmCta: CheckoutCtaUi;
+    /**
+     * Validation copy, e.g. `Insufficient USDC.`, or why no amount can be
+     * confirmed right now, which takes its place.
+     */
+    error: string | null;
+} | {
+    type: 'complete';
+    inputAsset: CheckoutAssetUi;
+    /**
+     * The confirmed amount as the field asked for it: `1,000.00 USDC`, or
+     * `$1,000.00` for a dollar-denominated field.
+     */
+    amountFormatted: FormattedAmountAssetUi;
+    /**
+     * The same figure in the asset actually being paid, e.g. `1,000.00
+     * USDC`, when the headline names dollars rather than the asset. `null`
+     * when the headline already is in the asset.
+     *
+     * Both are shown for a dollar field because the two are only equal while
+     * the funding asset is a dollar stablecoin - the day a non-dollar one is
+     * fundable, the summary would otherwise silently claim it was.
+     */
+    inputAmountFormatted: FormattedAmountAssetUi | null;
+};
+/**
+ * Everything the amount step raises. `ON_CONFIRM_AMOUNT` only moves the flow
+ * to the review step: nothing is placed or paid for here.
+ */
+type CheckoutAmountUiEvent = {
+    type: 'ON_AMOUNT_CHANGE';
+    value: string;
+} | {
+    type: 'ON_MAX_AMOUNT_CLICK';
+} | {
+    type: 'ON_SELECT_PAY_WITH';
+    value: AssetSymbol;
+} | {
+    type: 'ON_CONFIRM_AMOUNT';
+} | {
+    type: 'ON_EDIT_AMOUNT';
+};
+
+/**
+ * Step 1 of a checkout whose wallet step takes no provider input: which wallet
+ * funds the order and receives the asset. Ondo (buy and sell) and Centrifuge
+ * render it as it stands.
  *
- * There is no `inactive` arm. This step is the first one, so it is either being
- * filled in or already answered — it is never waiting on a step above it.
+ * Shared whole, state machine included, because it is not a provider state
+ * machine: no provider answers anything here, so there is nothing for one to
+ * diverge on. It forks the moment one provider needs different behaviour -
+ * Superstate already has, since its confirm allow-lists the wallet on-chain,
+ * so it keeps its own state over the same rows.
  *
- * Nothing is allow-listed: the user picks a wallet and confirms, and confirming
- * is synchronous. Hence a plain `confirmEnabled`.
+ * There is no `inactive` arm. This step is the first one, so it is either
+ * being filled in or already answered - it is never waiting on a step above
+ * it.
  *
- * @alpha
+ * Nothing is allow-listed: the user picks a wallet and confirms, and
+ * confirming is synchronous. Hence a plain `confirmEnabled` rather than a
+ * `CheckoutCtaUi` with loading copy.
  */
-type CentrifugeWalletSelectUiState = {
+type CheckoutWalletSelectUiState = {
     type: 'active';
     /** The user's CoinList wallets. Empty when they have none. */
     embeddedWallets: CheckoutEmbeddedWalletUi[];
-    /** `null` until an external wallet is connected. The row still renders. */
-    externalWallet: CheckoutWalletUi | null;
-    /** Whether the connected external wallet may be disconnected here. */
-    canDisconnect: boolean;
+    /**
+     * The external-wallet row: absent when the host offers no connector,
+     * an invitation to connect one, or the connected wallet.
+     */
+    externalWallet: CheckoutExternalWalletUi;
     confirmEnabled: boolean;
     /** Copy for a failed connect, e.g. the user rejected the wallet prompt. */
     error: string | null;
@@ -2953,8 +3082,7 @@ type CentrifugeWalletSelectUiState = {
     type: 'completed';
     wallet: CheckoutConfirmedWalletUi;
 };
-/** @alpha */
-type CentrifugeWalletSelectUiEvent = {
+type CheckoutWalletSelectUiEvent = {
     type: 'ON_SELECT_WALLET';
     value: CheckoutWalletTypeUi;
 }
@@ -2981,8 +3109,13 @@ type CentrifugeWalletSelectUiEvent = {
  */
 type CentrifugeBuyCheckoutUiState = {
     type: 'content';
-    wallet: CentrifugeWalletSelectUiState;
-    amount: CentrifugeBuyAmountUiState;
+    /**
+     * The wallet step, or `null` when the host preselected a wallet and the
+     * flow skipped it. The later steps are numbered from it. Never `null`
+     * today: this flow does not honour a preselection yet.
+     */
+    wallet: CheckoutWalletSelectUiState | null;
+    amount: CheckoutAmountUiState;
     review: CentrifugeBuyReviewUiState;
     sidebar: CentrifugeSidebarUiState;
     orderPlaced: CentrifugeOrderPlacedUiState;
@@ -2991,7 +3124,7 @@ type CentrifugeBuyCheckoutUiState = {
     reason: CentrifugeCheckoutErrorReason;
 };
 /** @alpha */
-type CentrifugeBuyCheckoutUiEvent = CentrifugeWalletSelectUiEvent | CentrifugeBuyAmountUiEvent | CentrifugeBuyReviewUiEvent | CentrifugeOrderPlacedUiEvent;
+type CentrifugeBuyCheckoutUiEvent = CheckoutWalletSelectUiEvent | CheckoutAmountUiEvent | CentrifugeBuyReviewUiEvent | CentrifugeOrderPlacedUiEvent;
 /**
  * The dialog that closes the checkout once the request has mined.
  *
@@ -3001,13 +3134,11 @@ type CentrifugeBuyCheckoutUiEvent = CentrifugeWalletSelectUiEvent | CentrifugeBu
  */
 type CentrifugeOrderPlacedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     outputAsset: CheckoutAssetUi;
     totalCost: FormattedAmountAssetUi;
-    recipientAddress: ShortenedWalletAddress;
-    txExplorerUrl: TxExplorerUrl;
-};
+} & CheckoutReceiptUi);
 /** @alpha */
 type CentrifugeOrderPlacedUiEvent = {
     type: 'ON_CLOSE_ORDER_PLACED';
@@ -3017,6 +3148,15 @@ type CentrifugeOrderPlacedUiEvent = {
 interface UseCentrifugeBuyCheckoutViewModelOptions {
     offer: CentrifugeVaultOfferDetail;
     chain: EthereumChain;
+    /**
+     * The host's wallets, its connector for an external one if any, and
+     * optionally the wallet it has already settled on.
+     *
+     * `wallets.preselected` is read **once**, to seed the step machine: set, the
+     * flow has no wallet step and opens on the amount. A host that changes it
+     * mid-flow is ignored, because the approval the review grants is granted by
+     * one specific wallet.
+     */
     wallets: CheckoutWalletSelection;
     enabled?: boolean;
     /** Fired once the request has mined. The dialog shows either way. */
@@ -3034,15 +3174,22 @@ interface UseCentrifugeBuyCheckoutViewModelResult {
  * review, and sidebar steps. The status poll lives here. The amount step
  * only validates.
  *
- * A vault that is known to be blocked replaces the checkout only at the
- * wallet step. A status that is still loading, or that failed, does not.
+ * A vault that is known to be blocked replaces the checkout only at the step
+ * the flow opened on: the wallet step, or the amount for a wallet the host
+ * preselected. A status that is still loading, or that failed, does not.
  *
  * @alpha
  */
 declare function useCentrifugeBuyCheckoutViewModel({ offer, chain, wallets, enabled, onOrderPlaced, }: UseCentrifugeBuyCheckoutViewModelOptions): UseCentrifugeBuyCheckoutViewModelResult;
 
-type LoadParticipationsReason = 'not-authenticated' | 'generic-error';
+type LoadParticipationsReason = LoadErrorReason;
+/**
+ * The state of the participations read. `DISABLED` means the hook was
+ * switched off before an answer arrived, so nothing is in flight.
+ */
 type LoadParticipationsState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -3054,30 +3201,38 @@ type LoadParticipationsState = {
 interface UseParticipationsOptions {
     /**
      * Participations pre-fetched on the server (e.g. via `CoinListServer#tokenSale.list()`).
-     * When provided, the hook uses this data as-is and skips the client-side fetch entirely.
+     * When provided, the hook uses this data as-is and skips the initial
+     * client-side fetch; {@link UseParticipationsResult.refetch} still fetches.
      */
     data?: Participation[];
     /**
      * When `false`, the hook sends no request. A seeded or already-fetched
-     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     * `CONTENT` survives; otherwise the hook reports `DISABLED`. Defaults to
+     * `true`.
      */
     enabled?: boolean;
 }
 interface UseParticipationsResult {
     participationsState: LoadParticipationsState;
+    /**
+     * Fetches again: the recovery path after an `ERROR`, and the way past a
+     * server seed (`data`), which only the first fetch honours. No-op while
+     * disabled.
+     */
+    refetch: () => void;
 }
 /**
  * Loads all CoinList participations for the current user and exposes a UI-friendly state.
  * Optionally filters by offer when `offerId` is provided.
  *
- * Pass `data` (pre-fetched server-side) to use that data as-is and skip
- * the client-side fetch entirely. Pass `enabled: false` to skip the fetch
- * when the hook must be called but the data is not needed yet.
+ * Pass `data` (pre-fetched server-side) to open on it and skip the initial
+ * client-side fetch. Pass `enabled: false` to skip the fetch when the hook
+ * must be called but the data is not needed yet.
  *
  * Returns `LOADING` while CoinList is initializing or while participations are being fetched.
- * Returns `CONTENT` with all participations when `fetchParticipations()` succeeds.
+ * Returns `CONTENT` with all participations when the read succeeds.
  * Returns `ERROR` with:
- * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
+ * - `not-authenticated` when the user has to sign in first
  * - `generic-error` for any other failure
  */
 declare function useParticipations(offerId?: OfferId, options?: UseParticipationsOptions): UseParticipationsResult;
@@ -3146,29 +3301,44 @@ type OndoBuyAmountUiEvent = {
  * branch in every consumer to distinguish. Split it out if that stops being
  * true.
  */
-type OndoLoadErrorReason = 'not-authenticated' | 'not-tradable' | 'generic-error';
+type OndoLoadErrorReason = LoadErrorReason | 'not-tradable';
 
 /**
- * The state of the built purchase a review step acts on.
+ * The state of a firm, expiring transaction a review step acts on.
+ *
+ * `DISABLED` means the caller switched the hook off before a transaction was
+ * in hand, so nothing is being built. A transaction already in hand - a seed,
+ * or an earlier build - survives being switched off.
  *
- * `isRefreshing` rides on `CONTENT` rather than replacing it, so a refresh in
- * flight never blanks the numbers the user is reading. A refresh that fails
- * keeps them too, and reports why alongside - the previous purchase may still
- * be good, and a failed refresh is fixed by refreshing again.
+ * `isRefreshing` rides on `CONTENT` rather than replacing it, so a rebuild in
+ * flight never blanks the numbers the user is reading. A rebuild that fails
+ * keeps them too, and reports why alongside - the previous transaction may
+ * still be good, and a failed rebuild is fixed by rebuilding again.
  */
-type LoadOndoBuyTransactionState = {
+type LoadFirmTransactionState<T, R> = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
-    reason: OndoLoadErrorReason;
+    reason: R;
 } | {
     type: 'CONTENT';
-    transaction: OndoBuyTransaction;
+    transaction: T;
     isRefreshing: boolean;
-    /** Why the last refresh failed; `null` when the purchase is fresh. */
-    refreshError: OndoLoadErrorReason | null;
+    /** Why the last rebuild failed; `null` when the transaction is fresh. */
+    refreshError: R | null;
 };
-interface UseOndoBuyTransactionOptions {
+
+/**
+ * The state of the built purchase a review step acts on.
+ *
+ * `DISABLED` while switched off with no purchase in hand. `isRefreshing` rides
+ * on `CONTENT`, so a refresh in flight never blanks the numbers the user is
+ * reading, and a refresh that fails keeps them and says why.
+ */
+type LoadOndoBuyTransactionState = LoadFirmTransactionState<OndoBuyTransaction, OndoLoadErrorReason>;
+interface UseOndoBuyTransactionOptions {
     /**
      * The order to build, or `null` while there is not one yet - before the
      * amount step is confirmed. A `null` request fetches nothing.
@@ -3191,29 +3361,50 @@ interface UseOndoBuyTransactionResult {
 }
 /**
  * Holds the firm, expiring purchase the buy review step places an order
- * against, and rebuilds it on demand.
- *
- * **Never polls.** Building spends an attestation, so a new one is only ever
- * obtained when the caller asks - on `refetch`, or on the first render if no
- * `data` was supplied. That is also why an expired purchase is left expired
- * here: whether to replace it is the user's call, not a timer's.
- *
- * Disabled it fetches nothing and stays on whatever state it opened with. That
- * is `LOADING` and not an empty `CONTENT` because there is no empty
- * purchase: firm calldata for an order that does not exist is not
- * representable. A caller that switches this hook off should switch its own
- * rendering off with it - which is what the review step does, since a step
- * that is not active is `incomplete` and never reads this state at all.
+ * against, and rebuilds it on demand. **Never polls**: each build spends an
+ * attestation.
  *
  * One of a pair with `useOndoSellTransaction`, and deliberately not one hook
- * over both. The two endpoints answer different shapes - a purchase commits to
- * an exact quantity, a sale to a range - so a shared hook would hand every
- * review step a union to narrow after its own directory had already settled
- * which trade it was. The machinery below is the price of that, and it is the
- * cheaper half: what a screen reads off `CONTENT` is the expensive half.
+ * over both (ADR-10). The two endpoints answer different shapes - a purchase
+ * commits to an exact quantity, a sale to a range - so a shared public hook
+ * would hand every review step a union to narrow after its own directory had
+ * already settled which trade it was. The machinery is shared instead, in
+ * `useFirmTransaction`.
  */
 declare function useOndoBuyTransaction(options: UseOndoBuyTransactionOptions): UseOndoBuyTransactionResult;
 
+/**
+ * Whether the numbers on an Ondo review step can still be traded on.
+ *
+ * A quote is only good for a few seconds, so this drives the line above the CTA
+ * and whether the CTA can be pressed at all. `refresh-failed` is its own arm
+ * rather than folding into the step's `error`, because the remedy differs: a
+ * failed refresh is fixed by refreshing again, a failed order is not.
+ *
+ * One type for both products, because a buy and a sell quote expire, refresh
+ * and fail to refresh in exactly the same way: `useOndoReviewExecution` derives
+ * it for both from the same firm transaction state.
+ */
+type OndoQuoteStatusUi = 
+/** Still good. `expiresInLabel` is the countdown copy, already formatted. */
+{
+    type: 'valid';
+    expiresInLabel: string;
+}
+/** A refresh is in flight; the previous numbers are still on screen. */
+ | {
+    type: 'refreshing';
+}
+/** Too old to trade on. The user must refresh before placing the order. */
+ | {
+    type: 'expired';
+}
+/** The refresh failed. `message` says why. */
+ | {
+    type: 'refresh-failed';
+    message: string;
+};
+
 /**
  * Step 3 of the Ondo checkout: what the order comes to, and placing it.
  *
@@ -3251,38 +3442,11 @@ type OndoBuyReviewUiState = {
     coinlistFee: FormattedAmountAssetUi | null;
     /** What the user pays in the input asset, e.g. `1,000.00 USDC`. */
     total: FormattedAmountAssetUi;
-    quote: OndoBuyQuoteStatusUi;
+    quote: OndoQuoteStatusUi;
     placeOrderCta: CheckoutCtaUi;
     /** A failure from placing the order, distinct from a quote problem. */
     error: string | null;
 };
-/**
- * Whether the shown numbers can still be traded on.
- *
- * A quote is only good for a few seconds, so this drives the line above the CTA
- * and whether the CTA can be pressed at all. `refresh-failed` is its own arm
- * rather than folding into the step's `error`, because the remedy differs: a
- * failed refresh is fixed by refreshing again, a failed order is not.
- */
-type OndoBuyQuoteStatusUi = 
-/** Still good. `expiresInLabel` is the countdown copy, already formatted. */
-{
-    type: 'valid';
-    expiresInLabel: string;
-}
-/** A refresh is in flight; the previous numbers are still on screen. */
- | {
-    type: 'refreshing';
-}
-/** Too old to trade on. The user must refresh before placing the order. */
- | {
-    type: 'expired';
-}
-/** The refresh failed. `message` says why. */
- | {
-    type: 'refresh-failed';
-    message: string;
-};
 type OndoBuyReviewUiEvent = {
     type: 'ON_REFRESH_QUOTE';
 }
@@ -3295,9 +3459,14 @@ type OndoBuyReviewUiEvent = {
 
 /**
  * Why an Ondo checkout cannot run right now, as opposed to a step of it
- * failing.
+ * failing. See {@link CheckoutBlockedReason} for `unsupported-chain`, which
+ * here means the offer names no CoinList swap contract on the chain (see
+ * `swapSpender`).
  *
- * A union rather than a bare flag because the View switches on it for copy.
+ * `not-tradable` is Ondo's block: it is not filling orders for this asset on
+ * this side right now, because the market is closed or paused, or the asset is
+ * paused or closed for the session. The trading-status poll keeps running
+ * underneath it, and the checkout comes back once the asset is tradable again.
  *
  * Shared by both products because each reason is a property of the integration
  * or of the market rather than of a direction: buying and selling go through
@@ -3306,47 +3475,7 @@ type OndoBuyReviewUiEvent = {
  * exception the provider-level `shared/` exists for, and it is narrow - the
  * step states stay per-product, since that is where the two genuinely diverge.
  */
-type OndoCheckoutErrorReason = 
-/**
- * The offer names no CoinList swap contract on the chain the host asked for,
- * so there is no spender to approve and nothing to broadcast to.
- *
- * Not retryable, and not the host's mistake to correct at runtime: both the
- * offer and the chain are fixed for the lifetime of the mount. See
- * `swapSpender`.
- */
-'unsupported-chain'
-/**
- * Ondo is not filling orders for this asset on this side right now: the
- * market is closed or paused, or the asset is paused or closed for the
- * session. Known from the trading-status poll, never assumed from a status
- * that is still loading or failed to load.
- *
- * Unlike `unsupported-chain` this one clears on its own. The trading-status
- * poll keeps running underneath it, and the checkout comes back once the
- * asset is tradable again. Only shown while the user is on the step the flow
- * opened on: once they are past it, a pause is a step's to report, so it
- * cannot pull an order out from under the user mid-flow.
- */
- | 'not-tradable';
-declare const OndoCheckoutErrorReason: {
-    /**
-     * Which reason, if any, replaces the whole checkout. `null` means the steps
-     * render.
-     *
-     * `unsupported-chain` wins because it is settled at mount: no market state
-     * can make a chain with no contract tradable. `not-tradable` needs both a
-     * market *known* to be closed and a user still at the start of the flow,
-     * with no order confirmation on screen. Past the first step a pause belongs
-     * to the step it interrupts, and a just-placed order's dialog must not be
-     * hidden by a market that closed after it filled.
-     */
-    of: ({ swappableHere, notTradable, atEntry, }: {
-        swappableHere: boolean;
-        notTradable: boolean;
-        atEntry: boolean;
-    }) => OndoCheckoutErrorReason | null;
-};
+type OndoCheckoutErrorReason = CheckoutBlockedReason<'not-tradable'>;
 
 /**
  * The reference panel beside the Ondo checkout: which asset is being bought,
@@ -3417,54 +3546,6 @@ type OndoSidebarPriceUi =
     type: 'unavailable';
 };
 
-/**
- * Step 1 of the Ondo checkout: which wallet funds the purchase and receives the
- * asset.
- *
- * There is no `inactive` arm. This step is the first one, so it is either being
- * filled in or already answered — it is never waiting on a step above it.
- *
- * Unlike Superstate's equivalent, nothing is allow-listed here: the user picks
- * a wallet and confirms, and confirming is synchronous. Hence a plain
- * `confirmEnabled` rather than the `CheckoutCtaUi` Superstate's step carries.
- * The rows themselves are the shared `Checkout*WalletUi` models — the two
- * providers render the same wallets and disagree only about what confirming
- * does.
- */
-type OndoWalletSelectUiState = {
-    type: 'active';
-    /** The user's CoinList wallets. Empty when they have none. */
-    embeddedWallets: CheckoutEmbeddedWalletUi[];
-    /** `null` until an external wallet is connected. The row still renders. */
-    externalWallet: CheckoutWalletUi | null;
-    /** Whether the connected external wallet may be disconnected here. */
-    canDisconnect: boolean;
-    confirmEnabled: boolean;
-    /** Copy for a failed connect, e.g. the user rejected the wallet prompt. */
-    error: string | null;
-} | {
-    type: 'completed';
-    wallet: CheckoutConfirmedWalletUi;
-};
-type OndoWalletSelectUiEvent = {
-    type: 'ON_SELECT_WALLET';
-    value: CheckoutWalletTypeUi;
-}
-/**
- * Tapping the external row while nothing is connected. Split from
- * `ON_SELECT_WALLET` because it opens the host's wallet connector rather than
- * changing the selection.
- */
- | {
-    type: 'ON_CONNECT_WALLET';
-} | {
-    type: 'ON_DISCONNECT_WALLET';
-} | {
-    type: 'ON_CONFIRM_WALLET';
-} | {
-    type: 'ON_EDIT_WALLET';
-};
-
 /**
  * The whole Ondo buy checkout: three step cards, the reference panel beside
  * them, and the dialog that closes the flow.
@@ -3484,7 +3565,12 @@ type OndoWalletSelectUiEvent = {
  */
 type OndoBuyCheckoutUiState = {
     type: 'content';
-    wallet: OndoWalletSelectUiState;
+    /**
+     * The wallet step, or `null` when the host preselected a wallet and the
+     * flow skipped it. The later steps are numbered from it. Never `null`
+     * today: the buy flow does not honour a preselection yet.
+     */
+    wallet: CheckoutWalletSelectUiState | null;
     amount: OndoBuyAmountUiState;
     review: OndoBuyReviewUiState;
     /** The asset panel. Read-only, so it raises no events. */
@@ -3510,7 +3596,7 @@ type OndoBuyCheckoutUiState = {
  * tags must stay globally unique, which is why the edit events are
  * `ON_EDIT_WALLET` and `ON_EDIT_AMOUNT` rather than a shared `ON_EDIT`.
  */
-type OndoBuyCheckoutUiEvent = OndoWalletSelectUiEvent | OndoBuyAmountUiEvent | OndoBuyReviewUiEvent | OndoOrderConfirmedUiEvent;
+type OndoBuyCheckoutUiEvent = CheckoutWalletSelectUiEvent | OndoBuyAmountUiEvent | OndoBuyReviewUiEvent | OndoOrderConfirmedUiEvent;
 /**
  * The dialog that closes the Ondo checkout, once the swap is mined.
  *
@@ -3520,7 +3606,7 @@ type OndoBuyCheckoutUiEvent = OndoWalletSelectUiEvent | OndoBuyAmountUiEvent | O
  */
 type OndoOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /**
      * What was bought.
@@ -3536,14 +3622,7 @@ type OndoOrderConfirmedUiState = {
     totalCost: FormattedAmountAssetUi;
     /** Price of one whole token at the time of the fill, e.g. `$378.99`. */
     pricePerShare: FormattedAmountAssetUi;
-    /** The wallet the asset was delivered to. */
-    recipientAddress: ShortenedWalletAddress;
-    /**
-     * The settled swap on a block explorer. Always present: the dialog only
-     * exists once there is a mined transaction to point at.
-     */
-    txExplorerUrl: TxExplorerUrl;
-};
+} & CheckoutReceiptUi);
 /**
  * Closing is the only thing the dialog raises.
  *
@@ -3572,7 +3651,17 @@ interface UseOndoBuyCheckoutViewModelOptions {
      * Fixed for the lifetime of the hook, as `offer` is.
      */
     chain: EthereumChain;
-    /** The host's wallets, and the lambdas that connect and disconnect one. */
+    /**
+     * The host's wallets, its connector for an external one if any, and
+     * optionally the wallet it has already settled on.
+     *
+     * `wallets.preselected` is read **once**, to seed the step machine: set, the
+     * flow has no wallet step and opens on the amount. A host that changes it
+     * mid-flow is ignored, because the approval that follows the amount step is
+     * granted by one specific wallet, and moving the flow onto another one under
+     * it would strand that approval and build calldata the new wallet cannot
+     * broadcast.
+     */
     wallets: CheckoutWalletSelection;
     /**
      * Default `true`. When `false` nothing is fetched and no timer runs, for a
@@ -3611,12 +3700,12 @@ interface UseOndoBuyCheckoutViewModelResult {
  * wallet is the same kind of answer for as long as it lasts. See
  * {@link OndoCheckoutErrorReason}.
  *
- * `offer` and `chain` are read as fixed for the lifetime of the hook. The step
- * machine holds a committed quote and an approval granted on one chain for one
- * order, so changing either in place would carry them onto an order they were
- * never priced for. Remount instead: give the component holding this hook a
- * `key` that changes with the offer and the chain, as {@link CheckoutContainer}
- * documents. That discards the flow with its component instance, which is the
+ * `offer` and `chain` are read as fixed for the lifetime of the hook, and so is
+ * the wallet the flow opened on. The step machine holds a committed quote and
+ * an approval granted on one chain by one wallet for one order, so changing any
+ * of them in place would carry them onto an order they were never priced for.
+ * Remount instead: give the component holding this hook a `key` that changes
+ * with the offer and the chain, as {@link CheckoutContainer} documents. That discards the flow with its component instance, which is the
  * only reset that cannot land between an approval and the broadcast it was
  * granted for.
  */
@@ -3700,23 +3789,11 @@ type OndoSellAmountUiEvent = {
 /**
  * The state of the built sale a review step acts on.
  *
- * `isRefreshing` rides on `CONTENT` rather than replacing it, so a refresh in
- * flight never blanks the numbers the user is reading. A refresh that fails
- * keeps them too, and reports why alongside - the previous sale may still
- * be good, and a failed refresh is fixed by refreshing again.
+ * `DISABLED` while switched off with no sale in hand. `isRefreshing` rides on
+ * `CONTENT`, so a refresh in flight never blanks the numbers the user is
+ * reading, and a refresh that fails keeps them and says why.
  */
-type LoadOndoSellTransactionState = {
-    type: 'LOADING';
-} | {
-    type: 'ERROR';
-    reason: OndoLoadErrorReason;
-} | {
-    type: 'CONTENT';
-    transaction: OndoSellTransaction;
-    isRefreshing: boolean;
-    /** Why the last refresh failed; `null` when the sale is fresh. */
-    refreshError: OndoLoadErrorReason | null;
-};
+type LoadOndoSellTransactionState = LoadFirmTransactionState<OndoSellTransaction, OndoLoadErrorReason>;
 interface UseOndoSellTransactionOptions {
     /**
      * The order to build, or `null` while there is not one yet - before the
@@ -3739,26 +3816,15 @@ interface UseOndoSellTransactionResult {
     refetch: () => void;
 }
 /**
- * Holds the firm, expiring sale the sell review step places an order
- * against, and rebuilds it on demand.
- *
- * **Never polls.** Building spends an attestation, so a new one is only ever
- * obtained when the caller asks - on `refetch`, or on the first render if no
- * `data` was supplied. That is also why an expired sale is left expired
- * here: whether to replace it is the user's call, not a timer's.
- *
- * Disabled it fetches nothing and stays on whatever state it opened with. That
- * is `LOADING` and not an empty `CONTENT` because there is no empty
- * sale: firm calldata for an order that does not exist is not
- * representable. A caller that switches this hook off should switch its own
- * rendering off with it - which is what the review step does, since a step
- * that is not active is `incomplete` and never reads this state at all.
+ * Holds the firm, expiring sale the sell review step places an order against,
+ * and rebuilds it on demand. **Never polls**: each build spends an
+ * attestation.
  *
  * The sell half of the pair `useOndoBuyTransaction` opens - see there for why
- * the two are not one hook. What differs is entirely in what `CONTENT` carries:
- * an {@link OndoSellTransaction} publishes an expected outcome and a floor
- * beneath it rather than one attested quantity, and the review step renders
- * both.
+ * the two are not one hook. What differs is entirely in what `CONTENT`
+ * carries: an {@link OndoSellTransaction} publishes an expected outcome and a
+ * floor beneath it rather than one attested quantity, and the review step
+ * renders both.
  */
 declare function useOndoSellTransaction(options: UseOndoSellTransactionOptions): UseOndoSellTransactionResult;
 
@@ -3818,7 +3884,7 @@ type OndoSellReviewUiState = {
      * is what the order is expected to fill at.
      */
     pricePerShare: FormattedAmountAssetUi;
-    quote: OndoSellQuoteStatusUi;
+    quote: OndoQuoteStatusUi;
     placeOrderCta: CheckoutCtaUi;
     /** A failure from placing the order, distinct from a quote problem. */
     error: string | null;
@@ -3851,33 +3917,6 @@ type OndoSellOutcomeUi = {
      */
     fee: FormattedAmountAssetUi | null;
 };
-/**
- * Whether the shown numbers can still be traded on.
- *
- * A quote is only good for a few seconds, so this drives the line above the CTA
- * and whether the CTA can be pressed at all. `refresh-failed` is its own arm
- * rather than folding into the step's `error`, because the remedy differs: a
- * failed refresh is fixed by refreshing again, a failed order is not.
- */
-type OndoSellQuoteStatusUi = 
-/** Still good. `expiresInLabel` is the countdown copy, already formatted. */
-{
-    type: 'valid';
-    expiresInLabel: string;
-}
-/** A refresh is in flight; the previous numbers are still on screen. */
- | {
-    type: 'refreshing';
-}
-/** Too old to trade on. The user must refresh before placing the order. */
- | {
-    type: 'expired';
-}
-/** The refresh failed. `message` says why. */
- | {
-    type: 'refresh-failed';
-    message: string;
-};
 type OndoSellReviewUiEvent = {
     type: 'ON_REFRESH_SELL_QUOTE';
 }
@@ -3913,7 +3952,7 @@ type OndoSellCheckoutUiState = {
      * two-step flow numbered `1, 2` and a three-step flow numbered `1, 2, 3`
      * cannot disagree. A boolean beside a non-null state would have let them.
      */
-    wallet: OndoWalletSelectUiState | null;
+    wallet: CheckoutWalletSelectUiState | null;
     amount: OndoSellAmountUiState;
     review: OndoSellReviewUiState;
     /** The asset panel. Read-only, so it raises no events. */
@@ -3941,7 +3980,7 @@ type OndoSellCheckoutUiState = {
  * separate, and a shared tag would make one product's event dispatch into the
  * other's handler in any host that composed both.
  */
-type OndoSellCheckoutUiEvent = OndoWalletSelectUiEvent | OndoSellAmountUiEvent | OndoSellReviewUiEvent | OndoSellOrderConfirmedUiEvent;
+type OndoSellCheckoutUiEvent = CheckoutWalletSelectUiEvent | OndoSellAmountUiEvent | OndoSellReviewUiEvent | OndoSellOrderConfirmedUiEvent;
 /**
  * The dialog that closes the Ondo sell checkout, once the swap is mined.
  *
@@ -3951,7 +3990,7 @@ type OndoSellCheckoutUiEvent = OndoWalletSelectUiEvent | OndoSellAmountUiEvent |
  */
 type OndoSellOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /**
      * What was sold.
@@ -3976,14 +4015,7 @@ type OndoSellOrderConfirmedUiState = {
     proceedsSymbol: AssetSymbol;
     /** Price of one whole token at the time of the fill, e.g. `$378.99`. */
     pricePerShare: FormattedAmountAssetUi;
-    /** The wallet the proceeds were delivered to. */
-    recipientAddress: ShortenedWalletAddress;
-    /**
-     * The settled swap on a block explorer. Always present: the dialog only
-     * exists once there is a mined transaction to point at.
-     */
-    txExplorerUrl: TxExplorerUrl;
-};
+} & CheckoutReceiptUi);
 /**
  * Closing is the only thing the dialog raises.
  *
@@ -4013,7 +4045,7 @@ interface UseOndoSellCheckoutViewModelOptions {
      */
     chain: EthereumChain;
     /**
-     * The host's wallets, the lambdas that connect and disconnect one, and
+     * The host's wallets, its connector for an external one if any, and
      * optionally the wallet it has already settled on.
      *
      * `wallets.preselected` is read **once**, to seed the step machine. A host
@@ -4078,6 +4110,7 @@ declare function useOndoSellCheckoutViewModel({ offer, chain, wallets, enabled,
 /**
  * The state of the indicative-price poll.
  *
+ * - `DISABLED`: switched off with no price in hand, so none is coming.
  * - `LOADING`: no price yet (initial, or the provider is still initializing).
  * - `ERROR`: no price could be fetched at all.
  * - `CONTENT`: a price is in hand; `isRefreshing` says whether a newer one is
@@ -4089,6 +4122,8 @@ declare function useOndoSellCheckoutViewModel({ offer, chain, wallets, enabled,
  * when the UI has nothing to show.
  */
 type LoadOndoPriceState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -4135,15 +4170,12 @@ interface UseOndoPriceResult {
  * - committing a fillable quote is `coinlist.ondo.prepareBuy` or
  *   `coinlist.ondo.prepareSell`, whichever way the trade runs.
  *
- * Disabled (or before the provider is ready) it neither fetches nor holds a
- * timer, and stays on whatever state it opened with - `LOADING`, or the `data`
- * seed - rather than reporting an error.
- *
- * That is `LOADING` and not an empty `CONTENT` because there is no empty price:
- * a hook whose content is a list can fall back to `[]` the way
- * `useOptionAddresses` does, and one whose content is a number cannot. A caller
- * that switches this hook off should switch its own rendering off with it,
- * rather than read `LOADING` as "a price is coming".
+ * Disabled it neither fetches nor holds a timer. With no price in hand it
+ * reports `DISABLED` - not `LOADING`, since nothing is coming, and not an
+ * empty `CONTENT`, since there is no empty price. A price already in hand (the
+ * `data` seed, or an earlier tick) survives being switched off. Before the
+ * provider is ready it is `LOADING`: the read is coming, it just cannot leave
+ * yet.
  *
  * A `data` price opens the state instead of `LOADING` and is otherwise left to
  * the poll: the first tick fires as it always does, and only replaces the seed
@@ -4163,6 +4195,8 @@ declare function useOndoPrice(options: UseOndoPriceOptions): UseOndoPriceResult;
  * unknown may not.
  */
 type LoadOndoTradingStatusState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -4173,8 +4207,8 @@ type LoadOndoTradingStatusState = {
 };
 /**
  * Whether the market is *known* to be closed for this side: the one reading of
- * the poll a caller may block an order on. `LOADING` and `ERROR` are unknown,
- * and unknown never blocks.
+ * the poll a caller may block an order on. `DISABLED`, `LOADING` and `ERROR`
+ * are unknown, and unknown never blocks.
  */
 declare function isNotTradable(state: LoadOndoTradingStatusState): boolean;
 interface UseOndoTradingStatusOptions {
@@ -4217,94 +4251,30 @@ interface UseOndoTradingStatusResult {
  * the poll: the first tick fires as it always does, and only replaces the seed
  * once it has a status of its own.
  *
- * Disabled it neither fetches nor holds a timer, and stays on whatever state it
- * opened with. That is `LOADING` and not an empty `CONTENT` because there is no
- * empty market status - and an invented one would be worse than none, since
- * `CONTENT` here is what a caller is allowed to block an order on. A caller
- * that switches this hook off should switch its own rendering off with it.
+ * Disabled it neither fetches nor holds a timer. With no status in hand it
+ * reports `DISABLED`, not an empty `CONTENT`: there is no empty market status,
+ * and an invented one would be worse than none, since `CONTENT` here is what a
+ * caller is allowed to block an order on. A status already in hand survives
+ * being switched off.
  */
 declare function useOndoTradingStatus(options: UseOndoTradingStatusOptions): UseOndoTradingStatusResult;
 
 /**
- * Step 2 of the Superstate checkout: how much to spend, and which asset to
- * spend.
+ * The state of the swap's output-token read.
  *
- * Nothing here touches the chain. Unlike Ondo's amount step, which approves and
- * commits a quote, this one only validates locally and hands the amount up — a
- * Superstate swap approves and executes together on the review step. Hence a
- * plain `confirmEnabled` rather than a `CheckoutCtaUi` with loading copy: there
- * is no phase to report.
- */
-type SuperstateAmountUiState = {
-    type: 'incomplete';
-} | {
-    type: 'active';
-    /**
-     * Exactly what the user has typed, not a parsed number: the field is
-     * mid-edit, and `'1.'` is a legal thing to be holding.
-     */
-    amountInput: string;
-    /** The wallet the funds come from, per step 1. */
-    walletAddress: ShortenedWalletAddress;
-    /**
-     * Every supported input asset, in display order, whether or not the user
-     * holds any. One entry renders as a plain card, two or more as a picker.
-     */
-    inputAssets: CheckoutSelectableInputAssetUi[];
-    confirmEnabled: boolean;
-    /** Validation copy, e.g. `Amount must be greater than 0.` */
-    error: string | null;
-} | {
-    type: 'complete';
-    inputAsset: CheckoutAssetUi;
-    /**
-     * What the user is spending, as the field asked for it: dollars, e.g.
-     * `$1,000.00`. The Superstate field is dollar-denominated, which is why
-     * this is prefixed rather than suffixed with a symbol.
-     */
-    amountFormatted: FormattedAmountAssetUi;
-    /**
-     * The same figure in the asset actually being paid, e.g. `1,000.00 USDC`.
-     *
-     * Both are shown because the two are only equal while the funding asset
-     * is a dollar stablecoin — the day a non-dollar one is fundable, the
-     * summary would otherwise silently claim it was.
-     */
-    inputAmountFormatted: FormattedAmountAssetUi;
-};
-type SuperstateAmountUiEvent = {
-    type: 'ON_AMOUNT_CHANGE';
-    value: string;
-} | {
-    type: 'ON_MAX_AMOUNT_CLICK';
-} | {
-    type: 'ON_SELECT_PAY_WITH';
-    value: AssetSymbol;
-}
-/**
- * Named for what it does rather than for the step: confirming here previews
- * the order on step 3, it does not place or pay for anything.
+ * - `DISABLED`: switched off before an answer arrived.
+ * - `LOADING`: no answer yet (initial, a re-read after the contract or chain
+ *   changed, or the provider still initializing).
+ * - `ERROR`: the read failed.
+ * - `CONTENT`: the output token was read.
  */
- | {
-    type: 'ON_PREVIEW_ORDER';
+type LoadSwapOutputTokenState = {
+    type: 'DISABLED';
 } | {
-    type: 'ON_EDIT_AMOUNT';
-};
-
-/**
- * The state of the swap's output-token fetch.
- *
- * - `LOADING`: no result yet (initial, or provider still initializing).
- * - `ERROR`: the fetch failed.
- * - `CONTENT`: the output token was fetched successfully.
- *
- * A stale `CONTENT`/`ERROR` is preserved while a re-fetch (e.g. after a chain
- * change) is in flight, rather than flipping back to `LOADING`.
- */
-type SwapOutputTokenState = {
     type: 'LOADING';
 } | {
     type: 'ERROR';
+    reason: LoadErrorReason;
 } | {
     type: 'CONTENT';
     outputToken: Erc20Asset;
@@ -4317,12 +4287,12 @@ interface UseSwapOutputTokenOptions {
     enabled: boolean;
 }
 interface UseSwapOutputTokenResult {
-    outputTokenState: SwapOutputTokenState;
+    state: LoadSwapOutputTokenState;
     /**
-     * Runs the fetch again after a failure.
+     * Runs the read again after a failure.
      *
      * The output token is read once and never polled, so `ERROR` is otherwise
-     * terminal until a dependency changes — and without it there is no quote,
+     * terminal until a dependency changes - and without it there is no quote,
      * no price and no minimum received, which is why the Superstate checkout
      * surfaces it as a whole-flow failure with a retry rather than as one
      * unavailable corner.
@@ -4330,11 +4300,11 @@ interface UseSwapOutputTokenResult {
     refetch: () => void;
 }
 /**
- * Fetches the ERC-20 output token a swap contract pays out. Re-fetches when the
+ * Reads the ERC-20 output token a swap contract pays out. Reads again when the
  * contract or chain changes, and once when `enabled` flips to true.
  *
- * The fetch runs once (no polling); a failure resolves to `ERROR` and is not
- * retried until a dependency changes.
+ * The read runs once (no polling); a failure resolves to `ERROR` and is not
+ * retried until a dependency changes or `refetch` is called.
  */
 declare function useSwapOutputToken(options: UseSwapOutputTokenOptions): UseSwapOutputTokenResult;
 
@@ -4355,21 +4325,45 @@ interface UseSwapQuoteOptions {
     /** When false, the hook neither fetches nor polls. */
     enabled: boolean;
 }
-interface UseSwapQuoteResult {
-    /** The latest quote, or `null` until the first successful fetch. */
-    quote: SwapQuote | null;
-    /** True until the first quote arrives; false while the hook is disabled. */
-    isLoading: boolean;
-    /** True while a background poll refreshes an existing quote. */
+/**
+ * The state of the quote poll.
+ *
+ * - `DISABLED`: switched off with no quote in hand, so none is coming.
+ * - `LOADING`: no quote yet - the first read is in flight, the provider is
+ *   still initializing, or the output token's decimals are not known yet.
+ * - `ERROR`: no quote could be read at all.
+ * - `CONTENT`: a quote is in hand; `isRefreshing` says whether a newer one is
+ *   on the way.
+ *
+ * A tick that fails with a quote already in hand stays `CONTENT`, so `ERROR`
+ * means "never got one". A quote also survives a change of amount until the
+ * new one lands, with `isRefreshing` set: the review step compares the quote
+ * against the amount, and that flag is what tells it the mismatch is a reprice
+ * in flight rather than a quote for the wrong order.
+ */
+type LoadSwapQuoteState = {
+    type: 'DISABLED';
+} | {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadErrorReason;
+} | {
+    type: 'CONTENT';
+    quote: SwapQuote;
     isRefreshing: boolean;
+};
+interface UseSwapQuoteResult {
+    state: LoadSwapQuoteState;
 }
 /**
  * Polls a read-only swap quote for `inputAmount` of `inputTokenAddress` against
  * the given swap contract, refreshing every `pollIntervalMs`.
  *
- * A failed fetch is swallowed: the last quote stays visible and the next poll
- * tick retries. Quoting is skipped while `outputTokenDecimals` is `null` or
- * `enabled` is false, and until the CoinList provider finishes initializing.
+ * A failed tick with a quote in hand keeps it and the next tick retries.
+ * Quoting waits while `outputTokenDecimals` is `null` and until the CoinList
+ * provider finishes initializing. Disabled it neither fetches nor holds a
+ * timer; a quote already in hand survives being switched off.
  */
 declare function useSwapQuote(options: UseSwapQuoteOptions): UseSwapQuoteResult;
 
@@ -4532,10 +4526,11 @@ type SuperstateWalletUiState = {
     type: 'active';
     /** The user's CoinList wallets. Empty when they have none. */
     embeddedWallets: CheckoutEmbeddedWalletUi[];
-    /** `null` until an external wallet is connected. The row still renders. */
-    externalWallet: CheckoutWalletUi | null;
-    /** Whether the connected external wallet may be disconnected here. */
-    canDisconnect: boolean;
+    /**
+     * The external-wallet row: absent when the host offers no connector,
+     * an invitation to connect one, or the connected wallet.
+     */
+    externalWallet: CheckoutExternalWalletUi;
     /**
      * Confirming runs the authorization, so this reports its phase as
      * loading copy — `Sign the message in your wallet…` and the rest.
@@ -4579,7 +4574,7 @@ type SuperstateWalletUiEvent = {
 type SuperstateSwapCheckoutUiState = {
     type: 'content';
     wallet: SuperstateWalletUiState;
-    amount: SuperstateAmountUiState;
+    amount: CheckoutAmountUiState;
     review: SuperstateReviewUiState;
     /** The sale panel. Read-only, so it raises no events. */
     sidebar: SuperstateSidebarUiState;
@@ -4614,7 +4609,7 @@ type SuperstateSwapLoadErrorReason =
  * edit events are `ON_EDIT_WALLET` and `ON_EDIT_AMOUNT` rather than a shared
  * `ON_EDIT`.
  */
-type SuperstateSwapCheckoutUiEvent = SuperstateWalletUiEvent | SuperstateAmountUiEvent | SuperstateReviewUiEvent | SuperstateOrderConfirmedUiEvent | SuperstateSwapCheckoutRetryUiEvent;
+type SuperstateSwapCheckoutUiEvent = SuperstateWalletUiEvent | CheckoutAmountUiEvent | SuperstateReviewUiEvent | SuperstateOrderConfirmedUiEvent | SuperstateSwapCheckoutRetryUiEvent;
 /**
  * Retrying the load behind the flow-level `error` arm.
  *
@@ -4634,7 +4629,7 @@ type SuperstateSwapCheckoutRetryUiEvent = {
  */
 type SuperstateOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /** What was bought. */
     asset: CheckoutAssetUi;
@@ -4658,14 +4653,7 @@ type SuperstateOrderConfirmedUiState = {
      * `outputAmount`, so `outputAmountConfirmed` covers it too.
      */
     pricePerShare: FormattedAmountAssetUi;
-    /** The wallet the asset was delivered to. */
-    recipientAddress: ShortenedWalletAddress;
-    /**
-     * The settled swap on a block explorer. Always present: the dialog only
-     * exists once there is a mined transaction to point at.
-     */
-    txExplorerUrl: TxExplorerUrl;
-};
+} & CheckoutReceiptUi);
 /**
  * Closing is the only thing the dialog raises.
  *
@@ -4693,7 +4681,17 @@ interface UseSuperstateSwapCheckoutViewModelOptions {
      * Fixed for the lifetime of the hook, as `offer` is.
      */
     chain: EthereumChain;
-    /** The host's wallets, and the lambdas that connect and disconnect one. */
+    /**
+     * The host's wallets, its connector for an external one if any, and
+     * optionally the wallet it has already settled on.
+     *
+     * `wallets.preselected` never skips the wallet step here: that step
+     * allow-lists the wallet on-chain, which no preselection can stand in for.
+     * It pre-selects the wallet's row instead, so the user confirms and
+     * allow-lists it rather than picking it again. A preselected wallet that
+     * is neither one of `embedded` nor the connected `external` has no row to
+     * select, and the step opens with nothing picked.
+     */
     wallets: CheckoutWalletSelection;
     /**
      * Default `true`. When `false` nothing is fetched and no timer runs, for a
@@ -4792,11 +4790,14 @@ declare function useCentrifugeClaim(): UseCentrifugeClaimResult;
  * failures: a flaky tick must not make a claimable position vanish under the
  * user. A read that has never answered is absent, not zero. `ERROR` is
  * reserved for the case where nothing answered at all, so a screen has
- * nothing to show but a retry.
+ * nothing to show but a retry. `DISABLED` means the hook is switched off and
+ * holds nothing.
  *
  * @alpha
  */
 type LoadCentrifugeClaimPositionsState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -4823,8 +4824,7 @@ interface UseCentrifugeClaimPositionsOptions {
      */
     data?: CentrifugeVaultLeg[];
     /**
-     * Default `true`. When `false`: no requests, no timers, and an empty
-     * `CONTENT`.
+     * Default `true`. When `false`: no requests, no timers, and `DISABLED`.
      */
     enabled?: boolean;
 }
@@ -5156,26 +5156,47 @@ interface UseErc20BalanceOptions {
      * has one.
      */
     tokenAddress: EvmContractAddress | null;
-    owner: EvmWalletAddress;
+    /**
+     * The wallet whose balance is read. `null` when there is no wallet yet,
+     * which reads nothing and holds `DISABLED`, exactly as `enabled: false`
+     * does: there is no holding to wait for.
+     */
+    owner: EvmWalletAddress | null;
     chain: EthereumChain;
     /** How often to refresh. Defaults to {@link ERC20_BALANCE_POLL_INTERVAL_MS}. */
     pollIntervalMs?: number;
     /** When false, the hook neither fetches nor polls. */
     enabled: boolean;
 }
+/**
+ * The state of one balance read.
+ *
+ * Every arm answers for the token, owner and chain currently named by the
+ * options, and nothing else: from the moment any of them changes the state is
+ * `LOADING` until the read for the new one lands. A balance carried across
+ * that change would be a number read for something else, indistinguishable
+ * from a fresh one.
+ *
+ * - `DISABLED`: switched off. No balance is held, for the same reason.
+ * - `LOADING`: no read has settled for this request yet, or `tokenAddress` is
+ *   not known yet.
+ * - `ERROR`: the last read failed. A failed read is not a zero balance, and an
+ *   order must not be sized against the one before it, so it is dropped.
+ * - `CONTENT`: raw base units of the token.
+ */
+type LoadErc20BalanceState = {
+    type: 'DISABLED';
+} | {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadErrorReason;
+} | {
+    type: 'CONTENT';
+    balance: bigint;
+};
 interface UseErc20BalanceResult {
-    /**
-     * Raw base units of the token currently named by the options, or `null`.
-     *
-     * `null` covers every state that is not a settled read of *this* request:
-     * before the first one settles, after one fails, while disabled, and from
-     * the moment the token, owner or chain changes until the read for the new
-     * one lands. A caller cannot tell those apart on purpose - none of them is a
-     * number to size an order against - and `isLoading` is what says whether to
-     * wait.
-     */
-    balance: bigint | null;
-    isLoading: boolean;
+    state: LoadErc20BalanceState;
 }
 /**
  * Polls one wallet's balance of one ERC-20, named by contract address.
@@ -5189,15 +5210,18 @@ interface UseErc20BalanceResult {
  * each independently, which is a different job from following a single token
  * whose address may not be known yet.
  *
- * A poll tick is skipped while the previous read is in flight, so a slow one
- * cannot resolve last and overwrite a fresher balance. `isLoading` is true only
- * until the first read settles; background polls do not toggle it. Disabled, or
- * with no `tokenAddress`, it neither fetches nor holds a timer.
+ * Disabled, with no `owner`, or with no `tokenAddress`, it neither fetches
+ * nor holds a timer.
  */
 declare function useErc20Balance(options: UseErc20BalanceOptions): UseErc20BalanceResult;
 
 interface UseErc20TokenBalancesOptions {
-    address: EvmWalletAddress;
+    /**
+     * The wallet whose balances are read. `null` when there is no wallet yet -
+     * a checkout step waiting on the wallet step - which reads nothing and holds
+     * `DISABLED`, exactly as `enabled: false` does.
+     */
+    address: EvmWalletAddress | null;
     chain: EthereumChain;
     /** The assets to read balances for. */
     assets: NonEmptyArray<StablecoinSymbol>;
@@ -5209,29 +5233,47 @@ interface UseErc20TokenBalancesOptions {
     /** When false, the hook neither fetches nor polls. */
     enabled: boolean;
 }
-interface UseErc20TokenBalancesResult {
-    /**
-     * Raw on-chain balances keyed by the requested assets. Each requested asset
-     * with a deployment on the chain has an entry once a fetch settles
-     * (`bigint` on success, `null` on a failed read). Assets the chain has no
-     * deployment for (e.g. USDT on Base Sepolia) are omitted entirely, so
-     * absence and failure stay tellable apart.
-     */
+/**
+ * The state of the balance reads.
+ *
+ * Every arm answers for the address, chain and assets currently named by the
+ * options: from the moment any of them changes the state is `LOADING` until
+ * the reads for the new ones land, so one wallet's balances never stand in
+ * for another's.
+ *
+ * - `DISABLED`: switched off. No balances are held.
+ * - `LOADING`: no poll has settled for this request yet.
+ * - `ERROR`: every read the last poll made failed, so there is no balance at
+ *   all to show.
+ * - `CONTENT`: raw on-chain balances keyed by the requested assets. Each
+ *   requested asset with a deployment on the chain has an entry (`bigint` on
+ *   success, `null` on a failed read). Assets the chain has no deployment for
+ *   (e.g. USDT on Base Sepolia) are omitted entirely, so absence and failure
+ *   stay tellable apart.
+ */
+type LoadErc20TokenBalancesState = {
+    type: 'DISABLED';
+} | {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadErrorReason;
+} | {
+    type: 'CONTENT';
     balances: Map<StablecoinSymbol, bigint | null>;
-    isLoading: boolean;
+};
+interface UseErc20TokenBalancesResult {
+    state: LoadErc20TokenBalancesState;
 }
 /**
  * Polls the raw ERC-20 balances of `assets` for `address`, refreshing every
  * `pollIntervalMs`. Each asset settles independently: a failed read maps to
  * `null` while the others still resolve, and an asset the chain has no
  * deployment for is omitted from the result rather than read at a fake
- * address. A poll tick is skipped while the previous fetch is still in
- * flight. `assets` is compared by contents, so passing an inline array does
+ * address. `assets` is compared by contents, so passing an inline array does
  * not restart the poll.
  *
- * `isLoading` is true only until the first poll settles; background polls do
- * not toggle it. Disabled (or before the provider is ready) the hook does not
- * fetch.
+ * Disabled, or with no `address`, it neither fetches nor holds a timer.
  */
 declare function useErc20TokenBalances(options: UseErc20TokenBalancesOptions): UseErc20TokenBalancesResult;
 
@@ -5367,4 +5409,4 @@ declare class CoinListClientInitializationError extends Error {
     constructor(message?: string);
 }
 
-export { type AuthState, type AuthorizeWalletParams, type BuyCentrifugeParams, type CentrifugeBuyAmountUiEvent, type CentrifugeBuyAmountUiState, type CentrifugeBuyCheckoutUiEvent, type CentrifugeBuyCheckoutUiState, type CentrifugeBuyError, type CentrifugeBuyPhase, type CentrifugeBuyPlacementError, type CentrifugeBuyPlacementPhase, type CentrifugeBuyPlacementResult, type CentrifugeBuyPreparationError, type CentrifugeBuyPreparationPhase, type CentrifugeBuyPreparationResult, type CentrifugeBuyResult, type CentrifugeBuyReviewUiEvent, type CentrifugeBuyReviewUiState, CentrifugeCheckoutErrorReason, type CentrifugeClaimActionUi, type CentrifugeClaimBlockedReasonUi, type CentrifugeClaimDialogUi, type CentrifugeClaimError, type CentrifugeClaimFailureUi, type CentrifugeClaimParams, type CentrifugeClaimPhase, type CentrifugeClaimProgressUi, type CentrifugeClaimResult, type CentrifugeClaimRowUi, type CentrifugeClaimState, type CentrifugeClaimStepUi, type CentrifugeLoadErrorReason, type CentrifugeOrderPlaced, type CentrifugeOrderPlacedUiEvent, type CentrifugeOrderPlacedUiState, type CentrifugeSidebarMinimumUi, type CentrifugeSidebarUiState, type CentrifugeVaultCheckoutConfig, type CentrifugeVaultClaimConfig, type CentrifugeVaultClaimUiEvent, type CentrifugeVaultClaimUiState, type CentrifugeVaultClaimed, type CentrifugeWalletSelectUiEvent, type CentrifugeWalletSelectUiState, ChecklistStatus, CheckoutAssetUi, type CheckoutConfig, type CheckoutConfirmedWalletUi, CheckoutContainer, type CheckoutContainerProps, type CheckoutCtaUi, type CheckoutEmbeddedWalletUi, type CheckoutNetworkUi, type CheckoutSelectableInputAssetUi, type CheckoutStatusUi, type CheckoutWalletSelection, type CheckoutWalletTypeUi, type CheckoutWalletUi, type ClaimCentrifugeVaultParams, type ClaimConfig, ClaimContainer, type ClaimContainerProps, type ClaimExternalWalletUi, type ClientAuthNamespace, type ClientCentrifugeNamespace, type ClientCoinListTokenSaleNamespace, type ClientConfig, type ClientOndoNamespace, type ClientRequirementsNamespace, type ClientSuperstateSwapNamespace, type ClientSupportNamespace, type ClientWalletsNamespace, type CoinListClient, CoinListClientInitializationError, CoinListProvider, type CoinListProviderProps, CoinListSignInButton, type CoinListSignInButtonProps, CoinListSignInCardContainer, type CoinListSignInCardContainerProps, type CoinListSignInCardUiEvent, type CoinListSignInCardUiState, CoinListStyleScope, type CoinListStyleScopeProps, type CoinListTokenSaleCheckoutConfig, type CompleteOAuthFailureReason, type ConnectWalletError, type ConnectWalletErrorCode, type ConnectWalletFlowError, type ConnectWalletFlowResult, type ConnectWalletParams, type ConnectWalletPhase, type ConnectWalletSignState, type ConnectWalletState, type ConnectedWalletUi, type Erc20AllowanceError, type Erc20AllowancePhase, type Erc20ApprovalError, type ExecuteOndoSwapParams, type ExecuteSwapParams, type ExecuteTokenSaleParams, type ExternalWalletRequestUi, type KycTokenErrorReason, type KycTokenState, type LoadCentrifugeBuyTransactionState, type LoadCentrifugeClaimPositionsState, type LoadCentrifugeVaultStatusState, type LoadOfferDetailsReason, type LoadOfferDetailsState, type LoadOffersReason, type LoadOffersState, type LoadOndoBuyTransactionState, type LoadOndoPriceState, type LoadOndoSellTransactionState, type LoadOndoTradingStatusState, type LoadOptionAddressesReason, type LoadOptionAddressesState, type LoadParticipationsReason, type LoadParticipationsState, type LoadRequirementsReason, type LoadRequirementsState, type LoadTokenMetadataState, type LoadTokenRegistryState, type LogoImageUi, type OAuthClientErrorReason, type OAuthClientResult, OfferAssetCard, type OfferAssetCardProps, OfferAssetCardUi, OfferLogoUi, OfferSaleCard, type OfferSaleCardProps, OfferSaleCardUi, OffersGridContainer, type OffersGridContainerProps, type OffersGridData, type OndoBuyAmountUiEvent, type OndoBuyAmountUiState, type OndoBuyCheckoutUiEvent, type OndoBuyCheckoutUiState, type OndoBuyOrderPlaced, type OndoBuyOrderTerms, type OndoBuyPreparationResult, type OndoBuyQuoteStatusUi, type OndoBuyReviewUiEvent, type OndoBuyReviewUiState, type OndoCheckoutConfig, OndoCheckoutErrorReason, type OndoLoadErrorReason, type OndoOrderConfirmedUiEvent, type OndoOrderConfirmedUiState, type OndoOrderPlaced, type OndoOrderPlacedCore, type OndoSellAmountUiEvent, type OndoSellAmountUiState, type OndoSellBalanceUi, type OndoSellCheckoutUiEvent, type OndoSellCheckoutUiState, type OndoSellOrderConfirmedUiEvent, type OndoSellOrderConfirmedUiState, type OndoSellOrderPlaced, type OndoSellOrderTerms, type OndoSellOutcomeUi, type OndoSellPreparationResult, type OndoSellQuoteStatusUi, type OndoSellReviewUiEvent, type OndoSellReviewUiState, type OndoSellSourceWalletUi, type OndoSidebarPriceUi, type OndoSidebarUiState, type OndoSwapExecutionError, type OndoSwapExecutionPhase, type OndoSwapExecutionResult, type OndoSwapPreparationError, type OndoSwapPreparationPhase, type OndoSwapPreparationResult, type OndoWalletSelectUiEvent, type OndoWalletSelectUiState, type PlaceCentrifugeRequestParams, type PrepareCentrifugeBuyParams, type PrepareOndoBuyParams, type PrepareOndoSellParams, type PrepareOndoSwapParamsCore, RequirementItemUi, RequirementStatus, RequirementVariant, RequirementsChecklistContainer, type RequirementsChecklistContainerProps, type RequirementsChecklistItemUi, type RequirementsChecklistUiEvent, type RequirementsChecklistUiState, RequirementsChecklistView, type RequirementsChecklistViewProps, type RequirementsData, type RequirementsVerificationUi, type SignState, type SuperstateAmountUiEvent, type SuperstateAmountUiState, type SuperstateCheckoutConfig, type SuperstateOrderConfirmedUiEvent, type SuperstateOrderConfirmedUiState, type SuperstateOrderPlaced, type SuperstateReviewUiEvent, type SuperstateReviewUiState, type SuperstateSidebarPriceUi, type SuperstateSidebarUiState, type SuperstateSlippageOptionUi, type SuperstateSlippageUi, type SuperstateSwapCheckoutRetryUiEvent, type SuperstateSwapCheckoutUiEvent, type SuperstateSwapCheckoutUiState, type SuperstateSwapLoadErrorReason, type SuperstateWalletUiEvent, type SuperstateWalletUiState, type SwapExecutionError, type SwapExecutionPhase, type SwapExecutionResult, type SwapOutputTokenState, type TaxDocumentAddressParts, type TaxDocumentFields, type TaxDocumentState, type TokenSaleExecutionError, type TokenSaleExecutionPhase, type TokenSaleExecutionResult, type UseCentrifugeBuyCheckoutViewModelOptions, type UseCentrifugeBuyCheckoutViewModelResult, type UseCentrifugeBuyTransactionOptions, type UseCentrifugeBuyTransactionResult, type UseCentrifugeClaimPositionsOptions, type UseCentrifugeClaimPositionsResult, type UseCentrifugeClaimResult, type UseCentrifugeVaultClaimViewModelOptions, type UseCentrifugeVaultClaimViewModelResult, type UseCentrifugeVaultStatusOptions, type UseCentrifugeVaultStatusResult, type UseCentrifugeVaultStatusesOptions, type UseCentrifugeVaultStatusesResult, type UseCoinListResult, type UseCoinListSignInCardViewModelOptions, type UseCoinListSignInCardViewModelResult, type UseCompleteOAuthOptions, type UseConnectWalletOptions, type UseConnectWalletResult, type UseErc20BalanceOptions, type UseErc20BalanceResult, type UseErc20TokenBalancesOptions, type UseErc20TokenBalancesResult, type UseKycTokenResult, type UseOfferDetailsOptions, type UseOfferDetailsResult, type UseOffersOptions, type UseOffersResult, type UseOndoBuyCheckoutViewModelOptions, type UseOndoBuyCheckoutViewModelResult, type UseOndoBuyTransactionOptions, type UseOndoBuyTransactionResult, type UseOndoPriceOptions, type UseOndoPriceResult, type UseOndoSellCheckoutViewModelOptions, type UseOndoSellCheckoutViewModelResult, type UseOndoSellTransactionOptions, type UseOndoSellTransactionResult, type UseOndoTradingStatusOptions, type UseOndoTradingStatusResult, type UseOptionAddressesOptions, type UseOptionAddressesResult, type UseParticipationsOptions, type UseParticipationsResult, type UseRequirementsChecklistViewModelOptions, type UseRequirementsChecklistViewModelResult, type UseRequirementsOptions, type UseRequirementsResult, type UseSuperstateSwapCheckoutViewModelOptions, type UseSuperstateSwapCheckoutViewModelResult, type UseSwapOutputTokenOptions, type UseSwapOutputTokenResult, type UseSwapQuoteOptions, type UseSwapQuoteResult, type UseTaxDocumentOptions, type UseTaxDocumentResult, type UseTokenMetadataOptions, type UseTokenMetadataResult, type UseTokenRegistryOptions, type UseTokenRegistryResult, type WalletAuthorizationError, type WalletAuthorizationPhase, type WalletAuthorizationResult, type WalletsStatus, createCoinListClient, isNotTradable, pinoClientLogger, useCentrifugeBuyCheckoutViewModel, useCentrifugeBuyTransaction, useCentrifugeClaim, useCentrifugeClaimPositions, useCentrifugeVaultClaimViewModel, useCentrifugeVaultStatus, useCentrifugeVaultStatuses, useCoinList, useCoinListSignInCardViewModel, useCompleteOAuth, useConnectWallet, useErc20Balance, useErc20TokenBalances, useKycToken, useOfferDetails, useOffers, useOndoBuyCheckoutViewModel, useOndoBuyTransaction, useOndoPrice, useOndoSellCheckoutViewModel, useOndoSellTransaction, useOndoTradingStatus, useOptionAddresses, useParticipations, useRequirements, useRequirementsChecklistViewModel, useSuperstateSwapCheckoutViewModel, useSwapOutputToken, useSwapQuote, useTaxDocument, useTokenMetadata, useTokenRegistry };
+export { type ApproveThenBuildError, type ApproveThenBuildPhase, type ApproveThenBuildResult, type AuthState, type AuthorizeWalletParams, type BuyCentrifugeParams, type CentrifugeBuyCheckoutUiEvent, type CentrifugeBuyCheckoutUiState, type CentrifugeBuyError, type CentrifugeBuyPhase, type CentrifugeBuyPlacementError, type CentrifugeBuyPlacementPhase, type CentrifugeBuyPlacementResult, type CentrifugeBuyPreparationError, type CentrifugeBuyPreparationPhase, type CentrifugeBuyPreparationResult, type CentrifugeBuyResult, type CentrifugeBuyReviewUiEvent, type CentrifugeBuyReviewUiState, type CentrifugeCheckoutErrorReason, type CentrifugeClaimActionUi, type CentrifugeClaimBlockedReasonUi, type CentrifugeClaimDialogUi, type CentrifugeClaimError, type CentrifugeClaimFailureUi, type CentrifugeClaimParams, type CentrifugeClaimPhase, type CentrifugeClaimProgressUi, type CentrifugeClaimResult, type CentrifugeClaimRowUi, type CentrifugeClaimState, type CentrifugeClaimStepUi, type CentrifugeLoadErrorReason, type CentrifugeOrderPlaced, type CentrifugeOrderPlacedUiEvent, type CentrifugeOrderPlacedUiState, type CentrifugeSidebarMinimumUi, type CentrifugeSidebarUiState, type CentrifugeVaultCheckoutConfig, type CentrifugeVaultClaimConfig, type CentrifugeVaultClaimUiEvent, type CentrifugeVaultClaimUiState, type CentrifugeVaultClaimed, ChecklistStatus, type CheckoutAmountAdornmentUi, type CheckoutAmountUiEvent, type CheckoutAmountUiState, CheckoutAssetUi, type CheckoutBlockedReason, type CheckoutConfig, type CheckoutConfirmedWalletUi, CheckoutContainer, type CheckoutContainerProps, type CheckoutCtaUi, type CheckoutEmbeddedWalletUi, CheckoutExternalWalletUi, type CheckoutNetworkUi, type CheckoutReceiptUi, type CheckoutSelectableInputAssetUi, type CheckoutStatusUi, type CheckoutWalletSelectUiEvent, type CheckoutWalletSelectUiState, type CheckoutWalletSelection, type CheckoutWalletTypeUi, type CheckoutWalletUi, type ClaimCentrifugeVaultParams, type ClaimConfig, ClaimContainer, type ClaimContainerProps, type ClaimExternalWalletUi, type ClientAuthNamespace, type ClientCentrifugeNamespace, type ClientCoinListTokenSaleNamespace, type ClientConfig, type ClientOndoNamespace, type ClientRequirementsNamespace, type ClientSuperstateSwapNamespace, type ClientSupportNamespace, type ClientWalletsNamespace, type CoinListClient, CoinListClientInitializationError, CoinListProvider, type CoinListProviderProps, CoinListSignInButton, type CoinListSignInButtonProps, CoinListSignInCardContainer, type CoinListSignInCardContainerProps, type CoinListSignInCardUiEvent, type CoinListSignInCardUiState, CoinListStyleScope, type CoinListStyleScopeProps, type CoinListTokenSaleCheckoutConfig, type CompleteOAuthFailureReason, type ConnectWalletError, type ConnectWalletErrorCode, type ConnectWalletFlowError, type ConnectWalletFlowResult, type ConnectWalletParams, type ConnectWalletPhase, type ConnectWalletSignState, type ConnectWalletState, type ConnectedWalletUi, type Erc20AllowanceError, type Erc20AllowancePhase, type Erc20ApprovalError, type ExecuteOndoSwapParams, type ExecuteSwapParams, type ExecuteTokenSaleParams, type ExternalWalletRequestUi, type KycTokenErrorReason, type KycTokenState, type LoadCentrifugeClaimPositionsState, type LoadCentrifugeVaultStatusState, type LoadErc20BalanceState, type LoadErc20TokenBalancesState, type LoadErrorReason, type LoadFirmTransactionState, type LoadOfferDetailsReason, type LoadOfferDetailsState, type LoadOffersReason, type LoadOffersState, type LoadOndoBuyTransactionState, type LoadOndoPriceState, type LoadOndoSellTransactionState, type LoadOndoTradingStatusState, type LoadOptionAddressesReason, type LoadOptionAddressesState, type LoadParticipationsReason, type LoadParticipationsState, type LoadRequirementsReason, type LoadRequirementsState, type LoadSwapOutputTokenState, type LoadSwapQuoteState, type LoadTokenMetadataState, type LoadTokenRegistryState, type LogoImageUi, type OAuthClientErrorReason, type OAuthClientResult, OfferAssetCard, type OfferAssetCardProps, OfferAssetCardUi, OfferLogoUi, OfferSaleCard, type OfferSaleCardProps, OfferSaleCardUi, OffersGridContainer, type OffersGridContainerProps, type OffersGridData, type OndoBuyAmountUiEvent, type OndoBuyAmountUiState, type OndoBuyCheckoutUiEvent, type OndoBuyCheckoutUiState, type OndoBuyOrderPlaced, type OndoBuyOrderTerms, type OndoBuyPreparationResult, type OndoBuyReviewUiEvent, type OndoBuyReviewUiState, type OndoCheckoutConfig, type OndoCheckoutErrorReason, type OndoLoadErrorReason, type OndoOrderConfirmedUiEvent, type OndoOrderConfirmedUiState, type OndoOrderPlaced, type OndoOrderPlacedCore, type OndoQuoteStatusUi, type OndoSellAmountUiEvent, type OndoSellAmountUiState, type OndoSellBalanceUi, type OndoSellCheckoutUiEvent, type OndoSellCheckoutUiState, type OndoSellOrderConfirmedUiEvent, type OndoSellOrderConfirmedUiState, type OndoSellOrderPlaced, type OndoSellOrderTerms, type OndoSellOutcomeUi, type OndoSellPreparationResult, type OndoSellReviewUiEvent, type OndoSellReviewUiState, type OndoSellSourceWalletUi, type OndoSidebarPriceUi, type OndoSidebarUiState, type OndoSwapExecutionError, type OndoSwapExecutionPhase, type OndoSwapExecutionResult, type OndoSwapPreparationError, type OndoSwapPreparationPhase, type OndoSwapPreparationResult, type PlaceCentrifugeRequestParams, type PrepareCentrifugeBuyParams, type PrepareOndoBuyParams, type PrepareOndoSellParams, type PrepareOndoSwapParamsCore, RequirementItemUi, RequirementStatus, RequirementVariant, RequirementsChecklistContainer, type RequirementsChecklistContainerProps, type RequirementsChecklistItemUi, type RequirementsChecklistUiEvent, type RequirementsChecklistUiState, RequirementsChecklistView, type RequirementsChecklistViewProps, type RequirementsData, type RequirementsVerificationUi, type ResetThenApprovePhase, type SignState, type SuperstateCheckoutConfig, type SuperstateOrderConfirmedUiEvent, type SuperstateOrderConfirmedUiState, type SuperstateOrderPlaced, type SuperstateReviewUiEvent, type SuperstateReviewUiState, type SuperstateSidebarPriceUi, type SuperstateSidebarUiState, type SuperstateSlippageOptionUi, type SuperstateSlippageUi, type SuperstateSwapCheckoutRetryUiEvent, type SuperstateSwapCheckoutUiEvent, type SuperstateSwapCheckoutUiState, type SuperstateSwapLoadErrorReason, type SuperstateWalletUiEvent, type SuperstateWalletUiState, type SwapExecutionError, type SwapExecutionPhase, type SwapExecutionResult, type TaxDocumentAddressParts, type TaxDocumentFields, type TaxDocumentState, type TokenSaleExecutionError, type TokenSaleExecutionPhase, type TokenSaleExecutionResult, type UseCentrifugeBuyCheckoutViewModelOptions, type UseCentrifugeBuyCheckoutViewModelResult, type UseCentrifugeClaimPositionsOptions, type UseCentrifugeClaimPositionsResult, type UseCentrifugeClaimResult, type UseCentrifugeVaultClaimViewModelOptions, type UseCentrifugeVaultClaimViewModelResult, type UseCentrifugeVaultStatusOptions, type UseCentrifugeVaultStatusResult, type UseCentrifugeVaultStatusesOptions, type UseCentrifugeVaultStatusesResult, type UseCoinListResult, type UseCoinListSignInCardViewModelOptions, type UseCoinListSignInCardViewModelResult, type UseCompleteOAuthOptions, type UseConnectWalletOptions, type UseConnectWalletResult, type UseErc20BalanceOptions, type UseErc20BalanceResult, type UseErc20TokenBalancesOptions, type UseErc20TokenBalancesResult, type UseKycTokenResult, type UseOfferDetailsOptions, type UseOfferDetailsResult, type UseOffersOptions, type UseOffersResult, type UseOndoBuyCheckoutViewModelOptions, type UseOndoBuyCheckoutViewModelResult, type UseOndoBuyTransactionOptions, type UseOndoBuyTransactionResult, type UseOndoPriceOptions, type UseOndoPriceResult, type UseOndoSellCheckoutViewModelOptions, type UseOndoSellCheckoutViewModelResult, type UseOndoSellTransactionOptions, type UseOndoSellTransactionResult, type UseOndoTradingStatusOptions, type UseOndoTradingStatusResult, type UseOptionAddressesOptions, type UseOptionAddressesResult, type UseParticipationsOptions, type UseParticipationsResult, type UseRequirementsChecklistViewModelOptions, type UseRequirementsChecklistViewModelResult, type UseRequirementsOptions, type UseRequirementsResult, type UseSuperstateSwapCheckoutViewModelOptions, type UseSuperstateSwapCheckoutViewModelResult, type UseSwapOutputTokenOptions, type UseSwapOutputTokenResult, type UseSwapQuoteOptions, type UseSwapQuoteResult, type UseTaxDocumentOptions, type UseTaxDocumentResult, type UseTokenMetadataOptions, type UseTokenMetadataResult, type UseTokenRegistryOptions, type UseTokenRegistryResult, type WalletAuthorizationError, type WalletAuthorizationPhase, type WalletAuthorizationResult, type WalletsStatus, createCoinListClient, isNotTradable, pinoClientLogger, useCentrifugeBuyCheckoutViewModel, useCentrifugeClaim, useCentrifugeClaimPositions, useCentrifugeVaultClaimViewModel, useCentrifugeVaultStatus, useCentrifugeVaultStatuses, useCoinList, useCoinListSignInCardViewModel, useCompleteOAuth, useConnectWallet, useErc20Balance, useErc20TokenBalances, useKycToken, useOfferDetails, useOffers, useOndoBuyCheckoutViewModel, useOndoBuyTransaction, useOndoPrice, useOndoSellCheckoutViewModel, useOndoSellTransaction, useOndoTradingStatus, useOptionAddresses, useParticipations, useRequirements, useRequirementsChecklistViewModel, useSuperstateSwapCheckoutViewModel, useSwapOutputToken, useSwapQuote, useTaxDocument, useTokenMetadata, useTokenRegistry };