@coinlist-co/react 0.12.2-rc.e1f6c82 → 0.12.2

package/dist/client/index.d.ts

@@ -1,24 +1,23 @@
 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 StablecoinSymbol, F as Erc20Asset, G as CoinListTokenSaleOfferDetail, H as OfferDetail, I as CentrifugeVaultLegId, J as CentrifugeVaultOfferDetail, K as Seconds, L as AsyncOfferDetail, M as Offer, N as TokenMetadata, Q as RequirementStatusInfo, U as KycLevelName, V as RequirementType, X as RequirementStatusValue, Y as RequirementId, Z as PinoLoggerOptions, _ as Logger, $ as BuildCentrifugeVaultBuyParams, a0 as BuildOndoBuyParams, a1 as OndoSwapOfferDetail, a2 as BuildOndoSellParams, a3 as OndoQuote, a4 as OndoQuoteSize, a5 as OndoTradingStatus, a6 as AssetDecimals, a7 as SuperstateSwapOfferDetail, a8 as CentrifugeVaultLeg, a9 as CentrifugeVault, aa as OfferOptionAddressId, ab as DocumentSubmission, ac as CentrifugeVaultStatus, ad as CentrifugeVaultRef, ae as TokenIdentifier } from '../time-Bbqlt2x7.js';
+import { A as AuthorizationGrant, W as WalletError, E as EthereumChain, a as AssetSymbol, O as OfferVaultContract, b as EvmContractAddress, B as BlockchainAmount, C as CentrifugeVaultBuyTransaction, c as CentrifugeClaimDirection, d as CentrifugeNamespace, e as CoinListTokenSaleOfferDetail, f as OfferOptionId, S as StablecoinSymbol, P as Participation, g as CoinListTokenSaleNamespace, h as OfferSwapContract, i as OndoBuyTransaction, j as OndoSellTransaction, k as OndoNamespace, l as OndoSwapTransactionCore, m as OrderBookSide, n as OfferId, o 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 Erc20Asset, I as CentrifugeVaultLegId, J as CentrifugeVaultOfferDetail, K as Seconds, L as AsyncOfferDetail, M as RequirementStatusInfo, N as KycLevelName, Q as RequirementType, U as RequirementStatusValue, V as RequirementId, X as PinoLoggerOptions, Y as Logger, Z as AuthorizationCode, _ as CodeVerifier, $ 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 ParticipationId, ac as ParticipationStatus, ad as EpochMillis, ae as OfferOptionAddressId, af as DocumentSubmission, ag as TokenIdentifier } from '../time-ChSGmKZe.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-DttZXGvY.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-DMubXr2c.js';
 
 type AuthState = 'unknown' | 'logged-in' | 'logged-out';
 /** Discriminated error reasons from {@link CoinListClient.completeOAuth}. */
 type OAuthClientErrorReason = 'user_canceled' | 'missing_state' | 'invalid_state' | 'missing_code' | 'missing_code_verifier';
-type OAuthClientResult = {
+type OAuthClientResult = ({
     type: 'ok';
-    code: AuthorizationCode;
-    codeVerifier: CodeVerifier;
-} | {
+} & AuthorizationGrant) | {
     type: 'error';
     reason: OAuthClientErrorReason;
 };
 
 /**
  * Everything the browser half of the SDK knows about the current user's
- * session, and the OAuth 2.0 + PKCE flow that establishes one.
+ * session, and the OAuth 2.0 + PKCE flow that establishes one - e.g.
+ * `coinlist.auth.getState()` or `coinlist.auth.startOAuth()`.
  *
  * The SDK never holds a client secret in the browser: {@link startOAuth}
  * redirects the user to CoinList, and {@link completeOAuth} only parses and
@@ -73,7 +72,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 +83,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 +116,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;
@@ -283,8 +310,8 @@ type ClaimCentrifugeVaultParams = {
  * broadcast. The two halves stay beside it. The checkout runs them itself so
  * it can drop a build that finishes after the user has left, and a host that
  * wants to show the calldata before broadcasting can do the same. The amount
- * step calls neither. The request settles later. Broadcasting it does not
- * buy shares.
+ * step calls neither, and like the builders they wrap they are not free to
+ * poll. The request settles later. Broadcasting it does not buy shares.
  *
  * @alpha
  */
@@ -326,6 +353,10 @@ type TokenSaleExecutionPhase = 'checking-allowance' | 'resetting-allowance' | 'c
 /**
  * A step-tagged reason `ClientCoinListTokenSaleNamespace.execute` failed.
  *
+ * The first three are refusals before anything is signed: the offer names no
+ * funding contract on the chain, does not accept the coin there, or has no
+ * option with that id.
+ *
  * The reset-to-zero step (`allowance-reset` / `allowance-reset-reverted`) is
  * reported distinctly from the main approval (`approval` /
  * `approval-reverted`, reused from {@link Erc20ApprovalError}) so consumers can
@@ -333,6 +364,12 @@ type TokenSaleExecutionPhase = 'checking-allowance' | 'resetting-allowance' | 'c
  * reverted on-chain.
  */
 type TokenSaleExecutionError = {
+    step: 'unsupported-chain';
+} | {
+    step: 'unsupported-asset';
+} | {
+    step: 'unknown-option';
+} | {
     step: 'allowance-check';
 } | {
     step: 'allowance-reset';
@@ -351,25 +388,44 @@ type TokenSaleExecutionResult = {
     type: 'error';
     error: TokenSaleExecutionError;
 };
+/**
+ * Which approval a participation is recorded against.
+ *
+ * `fresh` sends a new one, which is what every first attempt does. `mined`
+ * reuses one that already mined for this amount - the `approvalTxHash` of a
+ * `participation` failure - so retrying the write asks the wallet for nothing.
+ */
+type TokenSaleApproval = {
+    type: 'fresh';
+} | {
+    type: 'mined';
+    txHash: Hash;
+};
 type ExecuteTokenSaleParams = {
     wallet: EvmWallet;
-    offerId: OfferId;
-    offerOptionId: OfferOptionId;
-    assetId: AssetId;
-    /** ERC-20 the user pays with (e.g. USDC/USDT). */
-    paymentTokenAddress: EvmContractAddress;
-    /** Contract that pulls the payment — the `approve()` spender. */
-    fundingContractAddress: EvmContractAddress;
+    /**
+     * The sale being bought into. The funding contract, the coin's address and
+     * its asset id are all read off it, so the caller never supplies one.
+     */
+    offer: CoinListTokenSaleOfferDetail;
+    /** The option being bought, which sets the price. */
+    optionId: OfferOptionId;
     chain: EthereumChain;
+    /** The coin the user pays in. It must be one of the offer's funding assets. */
+    inputAsset: StablecoinSymbol;
+    /** How much of `inputAsset` to commit, in its base units. */
     amount: BlockchainAmount;
+    /** Defaults to `{ type: 'fresh' }`. */
+    approval?: TokenSaleApproval;
     onProgress?: (phase: TokenSaleExecutionPhase) => void;
 };
 
 /**
  * The client-side token-sale namespace: everything the shared
  * {@link CoinListTokenSaleNamespace} reads/writes over the API, plus the
- * on-chain flow that drives a wallet (`execute`). The flow takes the wallet
- * and addresses per call; the namespace supplies the participation writes and
+ * on-chain flow that drives a caller-supplied `EvmWallet` (`execute`) -
+ * e.g. `coinlist.tokenSale.execute({ ... })`. The flow takes the wallet and
+ * addresses per call; the namespace supplies the participation writes and
  * (via the ERC-20 namespace) the allowance read it depends on.
  */
 interface ClientCoinListTokenSaleNamespace extends CoinListTokenSaleNamespace {
@@ -388,28 +444,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 +458,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 +512,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';
 };
@@ -520,7 +564,12 @@ type ExecuteOndoSwapParams<T> = {
 
 /**
  * The Ondo namespace plus the halves of placing an order that need a wallet,
- * and so cannot live on the shared namespace.
+ * and so cannot live on the shared namespace: `prepareBuy` / `prepareSell`
+ * (approve, then commit a firm quote) and `executeSwap` (broadcast it).
+ *
+ * Like the builders they wrap, the prepare methods spend an attestation, so
+ * unlike the reads they are not free to poll: call one when the user commits
+ * to an amount, never on a timer.
  *
  * Preparing and executing are two calls rather than one because the flow is
  * two user decisions: the trader commits to an amount (approving the spend),
@@ -585,9 +634,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 +703,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';
 };
@@ -665,7 +738,8 @@ type AuthorizeWalletParams = {
 /**
  * The client-side swap namespace: everything the shared
  * {@link SuperstateSwapNamespace} reads/writes over the API, plus the on-chain flows
- * that drive a wallet (`execute`, `authorizeWallet`). The flows take the
+ * that drive a caller-supplied wallet (`execute`, `authorizeWallet`) and
+ * return a step-tagged result rather than throwing. The flows take the
  * wallet and addresses per call; the namespace itself supplies the API reads
  * they depend on.
  */
@@ -706,7 +780,7 @@ interface ClientRequirementsNamespace extends RequirementsNamespace {
 }
 
 /**
- * Getting the user to a human at CoinList.
+ * Getting the user to a human at CoinList - `coinlist.support.contact()`.
  *
  * This namespace is client-only: it opens a browser tab and has no
  * `CoinListServer` counterpart. No method here requires authentication.
@@ -767,7 +841,8 @@ type ConnectWalletParams = {
 
 /**
  * The wallets namespace plus the one operation that needs the host's wallet:
- * proving ownership of it and binding it to an offer option, in one call.
+ * proving ownership of it and binding it to an offer option, in one call -
+ * `coinlist.wallets.connect({ wallet, offerId, offerOptionId })`.
  *
  * The shared {@link WalletsNamespace} already has both halves -
  * `createOwnershipChallenge` and `connectExternal` - but a signature has to
@@ -826,96 +901,27 @@ interface ClientConfig extends Config {
  * when the user is not authenticated.
  */
 interface CoinListClient {
-    /**
-     * Authentication: the current {@link AuthState}, and the browser half of the
-     * OAuth 2.0 + PKCE flow — e.g. `coinlist.auth.startOAuth()`.
-     */
+    /** Auth state and the browser half of OAuth - see {@link ClientAuthNamespace}. */
     readonly auth: ClientAuthNamespace;
-    /**
-     * The offer catalogue: listing offers and reading one in full — e.g.
-     * `coinlist.offers.get(offerId)`.
-     */
+    /** The offer catalogue, e.g. `coinlist.offers.get(offerId)` - see {@link OffersNamespace}. */
     readonly offers: OffersNamespace;
-    /**
-     * What the user must satisfy before participating in an offer: the
-     * checklist and its statuses, identity verification (KYC), and tax-document
-     * signing — e.g. `coinlist.requirements.statuses(offerId)`.
-     *
-     * Also exposes `handle(requirement)`, which sends the user to the CoinList
-     * page that satisfies a requirement.
-     */
+    /** What a user must satisfy to participate - see {@link ClientRequirementsNamespace}. */
     readonly requirements: ClientRequirementsNamespace;
-    /**
-     * The user's external wallets: proving ownership, binding a wallet to an
-     * offer option, and managing those bindings — e.g.
-     * `coinlist.wallets.connect({ wallet, offerId, offerOptionId })`.
-     */
+    /** Wallet ownership proofs and offer-option bindings - see {@link ClientWalletsNamespace}. */
     readonly wallets: ClientWalletsNamespace;
-    /**
-     * Generic ERC-20 reads (token allowance and balance) shared across the
-     * on-chain flows — e.g. `coinlist.erc20.getBalance({ ... })`.
-     */
+    /** Generic ERC-20 allowance and balance reads - see {@link Erc20Namespace}. */
     readonly erc20: Erc20Namespace;
-    /**
-     * Token-sale operations: listing/reading/recording participations, plus the
-     * on-chain `execute` flow that submits the ERC-20 approval and records the
-     * participation over a caller-supplied {@link EvmWallet} — e.g.
-     * `coinlist.tokenSale.execute({ ... })`.
-     *
-     * `execute` drives a caller-supplied wallet and returns a step-tagged result
-     * rather than throwing.
-     */
+    /** Token-sale participations and the on-chain purchase - see {@link ClientCoinListTokenSaleNamespace}. */
     readonly tokenSale: ClientCoinListTokenSaleNamespace;
-    /**
-     * On-chain swap operations: quoting a swap, reading swap-contract state, and
-     * allow-listing a proven wallet — e.g.
-     * `coinlist.superstate.getOutputToken({ contractAddress, chain })`.
-     *
-     * The on-chain flows (`execute`, `authorizeWallet`) additionally drive a
-     * caller-supplied wallet.
-     */
+    /** Superstate swaps - see {@link ClientSuperstateSwapNamespace}. */
     readonly superstate: ClientSuperstateSwapNamespace;
-    /**
-     * Ondo swaps: whether an asset is tradable right now and what it costs - e.g.
-     * `coinlist.ondo.getQuote({ ... })` - plus placing an order, in the two
-     * halves the flow actually has: `prepareBuy` / `prepareSell` (approve, then
-     * commit a firm quote) and `executeSwap` (broadcast it).
-     *
-     * Preparing is two methods because the directions approve different tokens -
-     * the funding coin on a purchase, the asset on a sale - and commit to
-     * different terms; broadcasting is one, because it reads calldata and a
-     * deadline and knows about neither.
-     *
-     * The reads are free to poll while the user edits an order. Preparing is
-     * not: committing a quote spends an attestation.
-     *
-     * No CoinList fee is applied to a read quote; see
-     * {@link ClientOndoNamespace}.
-     */
+    /** Ondo swap quotes and orders - see {@link ClientOndoNamespace}. */
     readonly ondo: ClientOndoNamespace;
-    /**
-     * Centrifuge vault deposits and claims: the vault-wide ordering gate, each
-     * wallet's position, the two halves of placing a request, and the claim
-     * that settles a filled one.
-     *
-     * The reads are free to poll. `prepareBuy` and `placeRequest` are not.
-     * Broadcasting places a request. It does not buy shares.
-     */
+    /** Centrifuge vault requests and claims - see {@link ClientCentrifugeNamespace}. */
     readonly centrifuge: ClientCentrifugeNamespace;
-    /**
-     * Token display metadata (name, symbol, decimals, logos) from CoinList's
-     * public token registry, keyed by chain + contract address — e.g.
-     * `coinlist.tokens.get({ chain, address })` for an entry of
-     * `Offer.tokens`, or `coinlist.tokens.list()` for the whole
-     * catalogue in one request.
-     *
-     * Public and unauthenticated: unlike the other namespaces, its methods never
-     * require a logged-in user.
-     */
+    /** Public token display metadata - see {@link TokensNamespace}. */
     readonly tokens: TokensNamespace;
-    /**
-     * Contacting CoinList support — `coinlist.support.contact()`.
-     */
+    /** Contacting CoinList support - see {@link ClientSupportNamespace}. */
     readonly support: ClientSupportNamespace;
     /**
      * Calls the provided {@link ClientConfig.getAccessToken} lambda to determine
@@ -1025,140 +1031,349 @@ interface CoinListSignInCardContainerProps {
 declare function CoinListSignInCardContainer({ state, onSignIn, onClose, className, }?: CoinListSignInCardContainerProps): ReactNode;
 
 /**
- * A deposit request that has been broadcast and mined.
- *
- * Named without `Buy` so it does not collide with the dialog component when
- * both are re-exported from the client barrel.
- *
- * Success means the request was placed. The fund fulfils it later, at a price
- * set then.
- *
- * @alpha
+ * What the grid fetches, pre-fetched on the server instead. Each half is
+ * independent: seed `offers` (via `CoinListServer#offers.list()`) and the
+ * client still fetches the registry, seed `tokens` (via
+ * `CoinListServer#tokens.list()`) and it still fetches the offers, seed both
+ * and the grid makes no request of its own.
  */
-type CentrifugeOrderPlaced = {
-    wallet: EvmWallet;
-    /** What the request deposits, in the funding token's base units. */
-    amount: BlockchainAmount;
-    transaction: CentrifugeVaultBuyTransaction;
-    txHash: Hash;
-};
+interface OffersGridData {
+    offers?: Offer[];
+    tokens?: TokenMetadata[];
+}
 
+interface OffersGridContainerProps {
+    /** Maximum number of columns to render when horizontal space allows. */
+    maxColumns?: number;
+    /** Optional className applied to the grid element. */
+    className?: string;
+    /** Optional className applied to the outer wrapper element. */
+    containerClassName?: string;
+    /** Optional loading slot shown while offers are being fetched. */
+    loading?: ReactNode;
+    /** Optional error slot shown when loading offers fails. */
+    error?: ReactNode;
+    /** Optional empty state slot shown when there are no available offers. */
+    emptyState?: ReactNode;
+    /** Optional per-offer click handler; when omitted, cards are not clickable. */
+    onOfferClick?: (offer: Offer) => void;
+    /**
+     * What the grid would otherwise fetch, pre-fetched on the server: `offers`
+     * via `CoinListServer#offers.list()`, `tokens` via
+     * `CoinListServer#tokens.list()`. Each half skips its own client-side
+     * fetch; pass both for a grid that makes no request of its own.
+     */
+    data?: OffersGridData;
+    /**
+     * Default `true`. When `false` nothing is fetched, so the container can be
+     * mounted while the grid is not needed yet.
+     */
+    enabled?: boolean;
+}
 /**
- * A filled Ondo order, as the confirmation dialog and the host's
- * `onOrderConfirmed` callback need it.
- *
- * It lives here rather than beside either review viewmodel because both
- * products produce one. Declaring it in `ondo/buy/` would make the sell
- * viewmodel import a sibling product's module - which the `shared/` ladder
- * forbids for the reason it always does: two products that reach sideways can
- * no longer be moved or deleted on their own.
+ * Displays a responsive live-sale grid of {@link OfferSaleCard}, backed by
+ * {@link useOffersGridViewModel}. Each card is named and illustrated by the
+ * public token registry where it lists the offer's token, and by the offer's
+ * own fields otherwise - list offers carry no display name, so an unlisted
+ * one shows logo + tagline until the host maps from detail. For equities /
+ * past-sales browse rows, compose {@link OffersAssetGrid} instead.
  *
- * It names no asset beyond the one that was spent. The transaction does not
- * carry one, and rebuilding an `Erc20Asset` here would mean inventing a
- * `decimals` - the quote's answers for a different quantity, and the
- * transaction's is a scale rather than a property of the token. A host that
- * wants to know what was traded has the `offer` it passed in.
- */
-type OndoOrderPlaced = OndoBuyOrderPlaced | OndoSellOrderPlaced;
-/**
- * The common half of an {@link OndoOrderPlaced}, before its side's terms.
+ * Pass `data` (offers and tokens pre-fetched server-side) to use them as-is
+ * and skip the client-side fetches. Pass `enabled={false}` to skip the fetches
+ * when the container is mounted but the grid is not needed yet. Uses the
+ * `loading` / `error` / `emptyState` slots when provided; otherwise renders
+ * the standard fallbacks. Cards are interactive only when `onOfferClick` is
+ * provided.
  *
- * The transaction that was broadcast is not here, because it is not common:
- * it carries the same `side` this order does, and saying so in prose left a
- * sell order holding a buy transaction constructible and its
- * `minimumReceiveOutputAmount` unreachable behind a narrowed `side`. Each arm
- * names its own instead.
- */
-type OndoOrderPlacedCore = {
-    txHash: Hash;
-    /** What the trader spent, in the input asset's base units. */
-    amount: BlockchainAmount;
-    wallet: EvmWallet;
-};
-/** A filled purchase: a stablecoin spent, the asset received. */
-type OndoBuyOrderPlaced = OndoOrderPlacedCore & OndoBuyOrderTerms;
-/** A filled sale: the asset spent, the settlement coin received. */
-type OndoSellOrderPlaced = OndoOrderPlacedCore & OndoSellOrderTerms;
-/**
- * A buy spends a stablecoin the SDK ships a registry entry for, so its input
- * asset is narrowed to one - which is what keeps `TOKEN_REGISTRY.erc20` total
- * at the call sites that name it.
+ * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
+ * needed.
  */
-type OndoBuyOrderTerms = {
-    side: 'buy';
-    inputAsset: StablecoinSymbol;
-    /** The purchase that was broadcast, and the deposit it was struck against. */
-    transaction: OndoBuyTransaction;
-};
+declare function OffersGridContainer({ data, onOfferClick, enabled, ...viewProps }?: OffersGridContainerProps): ReactNode;
+
 /**
- * A sell spends the Ondo asset, which is in no registry: its address and
- * decimals come off the quote, and only its symbol is carried here. Hence the
- * wider `AssetSymbol`, and hence a SUM rather than one widened field - a buy
- * that lost its stablecoin guarantee would be the cost of sharing one.
+ * One image as an `<img>` renders it: a `src` for a consumer that takes a
+ * single URL, and the `srcSet` candidates for one that also knows the size
+ * it renders at. `srcSet` is absent for a vector logo and for the offer's own
+ * artwork, neither of which offers the browser a choice.
  */
-type OndoSellOrderTerms = {
-    side: 'sell';
-    inputAsset: AssetSymbol;
-    /** The sale that was broadcast, and the floor under the proceeds it names. */
-    transaction: OndoSellTransaction;
+type LogoImageUi = {
+    src: string;
+    srcSet?: string;
 };
-
 /**
- * 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.
- *
- * 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.
+ * The logo a catalogue card renders for an offer, with the registry's
+ * dark-theme counterpart when it configures one.
  *
- * 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.
+ * `dark` is `null` rather than absent so a renderer has to decide what to do
+ * without one: fall back to `light`, which is the registry's own rule.
  */
-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 OfferLogoUi = {
+    light: LogoImageUi;
+    dark: LogoImageUi | null;
+};
+declare const OfferLogoUi: {
     /**
-     * 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.
-     *
-     * 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.
+     * The registry's logo for the token an offer is about, or the offer's own
+     * artwork otherwise, or `null` when neither exists.
      *
-     * **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.
+     * The registry wins when both exist because it is the token's real artwork
+     * where `Offer.logoUrl` is catalogue artwork, and because a swap publishes
+     * without artwork more often than not - which is why `logoUrl` is `null`
+     * on the swap variants.
      */
-    preselected: EvmWallet | null;
+    fromOffer: (offer: {
+        logoUrl: string | null;
+    }, tokenMetadata: TokenMetadata | null) => OfferLogoUi | null;
+};
+
+/**
+ * An offer as {@link OfferAssetCard} renders it. Browse chrome: circular
+ * `logo`, `name`, and asset `symbol`. No wordmark.
+ *
+ * All three come from the public token registry when the caller hands over
+ * the metadata of the token the offer is about. Without it, `fromOffer`
+ * omits `name` and `symbol` - the list payload has neither - so a list-mapped
+ * card is honest about being logo-only, and `fromDetail` reads them from the
+ * detail payload (`name`, `asset.code`).
+ */
+type OfferAssetCardUi = {
+    id: OfferId;
+    /** Absent when neither the registry nor a detail payload names the offer. */
+    name?: string;
+    /** Absent when neither the registry nor a detail payload carries a ticker. */
+    symbol?: string;
+    /** `null` when neither the registry nor the offer carries artwork. */
+    logo: OfferLogoUi | null;
+};
+declare const OfferAssetCardUi: {
+    /**
+     * `tokenMetadata` is the registry's entry for the token the offer is about
+     * (`TokenRegistrySnapshot.forOffer`), or `null` when it lists none. The
+     * registry names win over the offer's own where both exist: they are the
+     * token's canonical name, ticker and artwork, where the offer's are
+     * catalogue copy.
+     */
+    fromOffer: (offer: Offer, tokenMetadata?: TokenMetadata | null) => OfferAssetCardUi;
+    fromDetail: (detail: OfferDetail, tokenMetadata?: TokenMetadata | null) => OfferAssetCardUi;
+};
+
+interface OfferAssetCardProps {
+    offer: OfferAssetCardUi;
+    /** When set, the whole card is the hit target. */
+    onClick?: () => void;
+    /** Optional className applied to the card root element. */
+    className?: string;
+    /** Optional className applied to an outer wrapper element. */
+    containerClassName?: string;
+}
+/**
+ * Light browse-row catalogue card. Self-scoped. Header is the offer's `logo`
+ * (the token registry's where it lists the token, with its dark-theme
+ * variant, the catalogue's otherwise) beside `name` (h2) and asset `symbol`
+ * under it — not a wordmark.
+ * Responsive hug: tighter pad / logo / type below `md`, desktop keeps the
+ * H4 + 48px logo row. Hosts compose this beside {@link OfferSaleCard}; the
+ * card does not pick a variant itself.
+ */
+declare function OfferAssetCard({ offer, onClick, className, containerClassName, }: OfferAssetCardProps): ReactNode;
+
+/**
+ * An offer as {@link OfferSaleCard} renders it. Countdown copy is derived in
+ * the leaf from `startsAt` / `endsAt` so it can tick; the mapper does not
+ * invent a price, FDV, unlock schedule, banner overlay, or wordmark.
+ *
+ * `name` and `logo` come from the public token registry when the caller
+ * hands over the metadata of the token the offer is about, and from the
+ * offer otherwise. The list payload carries no name, so `fromOffer` leaves
+ * `name` absent without registry metadata - do not derive one from `slug`.
+ * The card pairs `logo` with `name` as an h2 and renders each only when
+ * present. Prefer {@link OfferSaleCardUi.fromDetail} when the host has a
+ * name and no registry answer.
+ *
+ * `tagline` and `startsAt` are null for an offer that runs no sale window, an
+ * Ondo swap: the card then omits the tagline and, with nothing to count down
+ * to, reads as live.
+ */
+type OfferSaleCardUi = {
+    id: OfferId;
+    /** Absent when neither the registry nor a detail payload names the offer. */
+    name?: string;
+    tagline: string | null;
+    /** `null` when neither the registry nor the offer carries artwork. */
+    logo: OfferLogoUi | null;
+    startsAt: Date | null;
+    endsAt: Date | null;
+};
+declare const OfferSaleCardUi: {
+    /**
+     * `tokenMetadata` is the registry's entry for the token the offer is about
+     * (`TokenRegistrySnapshot.forOffer`), or `null` when it lists none. The
+     * registry names win over the offer's own where both exist: they are the
+     * token's canonical name and artwork, where the offer's are catalogue copy.
+     */
+    fromOffer: (offer: Offer, tokenMetadata?: TokenMetadata | null) => OfferSaleCardUi;
+    fromDetail: (detail: OfferDetail, tokenMetadata?: TokenMetadata | null) => OfferSaleCardUi;
+};
+
+interface OfferSaleCardProps {
+    offer: OfferSaleCardUi;
+    /** Host click handler. View offer always renders; this wires the hit target. */
+    onClick?: () => void;
+    /** Optional className applied to the card root element. */
+    className?: string;
+    /** Optional className applied to an outer wrapper element. */
+    containerClassName?: string;
+}
+/**
+ * Dark live-sale catalogue card. Self-scoped. Header is the offer's `logo`
+ * (the token registry's where it lists the token, the catalogue's otherwise)
+ * beside the `name` as an h2, then the tagline — not a wordmark. The same
+ * logo is painted as a faint right-shifted watermark over the gradient.
+ * Responsive hug layout; View offer always renders. No token price, FDV or unlock.
+ */
+declare function OfferSaleCard({ offer, onClick, className, containerClassName, }: OfferSaleCardProps): ReactNode;
+
+/**
+ * A deposit request that has been broadcast and mined.
+ *
+ * Named without `Buy` so it does not collide with the dialog component when
+ * both are re-exported from the client barrel.
+ *
+ * Success means the request was placed. The fund fulfils it later, at a price
+ * set then.
+ *
+ * @alpha
+ */
+type CentrifugeOrderPlaced = {
+    wallet: EvmWallet;
+    /** What the request deposits, in the funding token's base units. */
+    amount: BlockchainAmount;
+    transaction: CentrifugeVaultBuyTransaction;
+    txHash: Hash;
+};
+
+/**
+ * A token-sale order the checkout placed: the approval mined and the
+ * participation is recorded.
+ *
+ * It is a commitment, not a purchase. The sale pulls the payment through the
+ * approval shortly after and holds it, and allocates tokens - refunding what
+ * they do not use - when it settles. So `participation.status` starts out
+ * pending; `ClaimContainer` follows it from there.
+ *
+ * @alpha
+ */
+type TokenSaleOrderPlaced = {
+    /** The wallet that approved the payment, and that receives the tokens. */
+    wallet: EvmWallet;
+    /** What was committed, in `inputAsset`'s base units. */
+    amount: BlockchainAmount;
+    inputAsset: StablecoinSymbol;
+    participation: Participation;
+    /** The approval the participation was recorded against. */
+    approvalTxHash: Hash;
+};
+
+/**
+ * A filled Ondo order, as the confirmation dialog and the host's
+ * `onOrderConfirmed` callback need it.
+ *
+ * It lives here rather than beside either review viewmodel because both
+ * products produce one. Declaring it in `ondo/buy/` would make the sell
+ * viewmodel import a sibling product's module - which the `shared/` ladder
+ * forbids for the reason it always does: two products that reach sideways can
+ * no longer be moved or deleted on their own.
+ *
+ * It names no asset beyond the one that was spent. The transaction does not
+ * carry one, and rebuilding an `Erc20Asset` here would mean inventing a
+ * `decimals` - the quote's answers for a different quantity, and the
+ * transaction's is a scale rather than a property of the token. A host that
+ * wants to know what was traded has the `offer` it passed in.
+ */
+type OndoOrderPlaced = OndoBuyOrderPlaced | OndoSellOrderPlaced;
+/**
+ * The common half of an {@link OndoOrderPlaced}, before its side's terms.
+ *
+ * The transaction that was broadcast is not here, because it is not common:
+ * it carries the same `side` this order does, and saying so in prose left a
+ * sell order holding a buy transaction constructible and its
+ * `minimumReceiveOutputAmount` unreachable behind a narrowed `side`. Each arm
+ * names its own instead.
+ */
+type OndoOrderPlacedCore = {
+    txHash: Hash;
+    /** What the trader spent, in the input asset's base units. */
+    amount: BlockchainAmount;
+    wallet: EvmWallet;
+};
+/** A filled purchase: a stablecoin spent, the asset received. */
+type OndoBuyOrderPlaced = OndoOrderPlacedCore & OndoBuyOrderTerms;
+/** A filled sale: the asset spent, the settlement coin received. */
+type OndoSellOrderPlaced = OndoOrderPlacedCore & OndoSellOrderTerms;
+/**
+ * A buy spends a stablecoin the SDK ships a registry entry for, so its input
+ * asset is narrowed to one - which is what keeps `TOKEN_REGISTRY.erc20` total
+ * at the call sites that name it.
+ */
+type OndoBuyOrderTerms = {
+    side: 'buy';
+    inputAsset: StablecoinSymbol;
+    /** The purchase that was broadcast, and the deposit it was struck against. */
+    transaction: OndoBuyTransaction;
+};
+/**
+ * A sell spends the Ondo asset, which is in no registry: its address and
+ * decimals come off the quote, and only its symbol is carried here. Hence the
+ * wider `AssetSymbol`, and hence a SUM rather than one widened field - a buy
+ * that lost its stablecoin guarantee would be the cost of sharing one.
+ */
+type OndoSellOrderTerms = {
+    side: 'sell';
+    inputAsset: AssetSymbol;
+    /** The sale that was broadcast, and the floor under the proceeds it names. */
+    transaction: OndoSellTransaction;
+};
+
+/**
+ * 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.
+ *
+ * A `null` `externalAdapter` hides the external-wallet row entirely, for a
+ * host that only offers embedded wallets.
+ *
+ * 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 = WalletSelection & {
     /**
-     * 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.
+     * A wallet the host has already settled on, or `null` to let the user pick.
      *
-     * Rejecting is how a declined or failed connection is reported.
+     * 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:
+     *
+     * - **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.
+     *
+     * 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.
      */
-    connectExternal: () => Promise<void>;
-    /** Disconnects the external wallet. Resolves when it is gone. */
-    disconnectExternal: () => Promise<void>;
+    preselected: EvmWallet | null;
 };
 
 /** What the swap actually filled at, once it has mined. */
@@ -1196,10 +1411,8 @@ type SuperstateOrderPlaced = {
  *
  * Keyed by `OfferType` rather than by provider name. Every entry is optional,
  * and so is the whole object: a host that says nothing about a provider gets
- * its defaults, and a token sale with no entry renders nothing, since the SDK
- * ships no token-sale UI of its own. A new provider that needs config cannot be
- * wired up without a key here, since its branch in {@link CheckoutContainer}
- * has to index one.
+ * its defaults. A new provider that needs config cannot be wired up without a
+ * key here, since its branch in {@link CheckoutContainer} has to index one.
  *
  * Everything here is per-*integration*: a host builds it once and passes the
  * same object for every offer it renders. Which way the order runs is
@@ -1225,19 +1438,20 @@ type SuperstateCheckoutConfig = {
     onOrderConfirmed?: (order: SuperstateOrderPlaced) => void;
 };
 /**
- * The SDK ships no token-sale UI, so the host supplies it.
- *
- * A render function rather than a `ReactNode`, because the container knows
- * which offer it is being asked about and a host with a working token-sale page
- * of its own needs that offer to render it. Without this entry a token-sale
- * offer renders nothing.
- *
- * Alpha: may change once the SDK ships its own token-sale checkout.
+ * What a CoinList token-sale checkout can be configured with. Nothing is
+ * required: the funding contract, the coins and the price are all read off
+ * the offer. Which option is bought is per-render, so it is a prop - see
+ * {@link CheckoutContainerProps.optionId}.
  *
  * @alpha
  */
 type CoinListTokenSaleCheckoutConfig = {
-    render: (offer: CoinListTokenSaleOfferDetail) => ReactNode;
+    /**
+     * Fired once the participation is recorded. The dialog shows either way.
+     * The order is a commitment: the sale collects the payment and allocates
+     * the tokens when it settles.
+     */
+    onOrderPlaced?: (order: TokenSaleOrderPlaced) => void;
 };
 /**
  * What a Centrifuge vault checkout can be configured with.
@@ -1285,14 +1499,46 @@ 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.
+     * Which of a token sale's options is bought - each sets its own price,
+     * minimum and sale agreement. Default: the offer's first option. Every
+     * other provider buys its offer's only option and ignores it.
+     *
+     * A prop rather than a config entry for the same reason as `side`: it is
+     * per-render, chosen on the host's offer page.
+     *
+     * **Read once, at mount**, as `side` is. To switch options, remount with a
+     * `key` covering it.
+     */
+    optionId?: OfferOptionId;
+    /**
+     * 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),
+     * Centrifuge and the token sale 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;
     /**
      * What each offer type needs beyond the offer itself. Default `{}`: every
-     * provider runs on its defaults, and a token sale renders nothing.
+     * provider runs on its defaults.
      */
     config?: CheckoutConfig;
     /**
@@ -1315,22 +1561,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`, the `optionId` 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, option 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
@@ -1355,7 +1608,7 @@ interface CheckoutContainerProps {
  *
  * ```tsx
  * const config: CheckoutConfig = {
- *   'coinlist::token_sale': { render: (o) => <MyTokenSalePage offer={o} /> },
+ *   'ondo::swap': { onOrderConfirmed: (order) => track(order) },
  * };
  *
  * // The sell page. The buy page leaves `side` out.
@@ -1364,7 +1617,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
  *
@@ -1398,7 +1652,7 @@ interface CheckoutContainerProps {
  *   toggle where it can reach an executing flow — disable the tabs once the
  *   user is past the amount step, or confirm before switching.
  */
-declare function CheckoutContainer({ offer, chain, side, wallets, config, enabled, className, }: CheckoutContainerProps): ReactNode;
+declare function CheckoutContainer({ offer, chain, side, optionId, wallets, config, enabled, className, }: CheckoutContainerProps): ReactNode;
 
 /**
  * The claim card.
@@ -1616,6 +1870,9 @@ declare function useCentrifugeVaultClaimViewModel({ offer, wallets, walletLabel,
  * `CheckoutConfig`: a provider with nothing the host must decide asks for
  * nothing. Per-integration, not per-offer: a host builds it once.
  *
+ * `coinlist::token_sale` has no entry: its card only follows participations,
+ * so there is nothing for a host to decide or to hear about.
+ *
  * @alpha
  */
 type ClaimConfig = {
@@ -1634,14 +1891,15 @@ type CentrifugeVaultClaimConfig = {
 /** @alpha */
 interface ClaimContainerProps {
     /**
-     * The async offer whose positions to show. Its `type` decides which
+     * The async offer whose second leg to show. Its `type` decides which
      * provider renders. Narrow an `OfferDetail` with `AsyncOfferDetail.is`.
      */
     offer: AsyncOfferDetail;
     /**
      * The wallets to read positions for and claim from, and the host's
      * external-wallet connector. Pass `externalAdapter: null` to hide the
-     * connect affordance.
+     * connect affordance. A token sale's participations are listed for the
+     * whole account, whichever wallet paid, so it reads none of these.
      */
     wallets: WalletSelection;
     /**
@@ -1663,13 +1921,20 @@ interface ClaimContainerProps {
 }
 /**
  * The plug-and-play claim card: hand it an async offer and it renders the
- * right provider's positions - what is pending, what is claimable - and the
- * claim that collects them.
+ * right provider's second leg.
  *
  * The second leg of an async trade. The user placed a request earlier, the
- * fund fills it on its own schedule, and they come back - days or weeks later
- * - to claim. So the card is its own entry on the offer page rather than a
- * checkout step.
+ * other side fills it on its own schedule, and they come back - days or
+ * weeks later - to see how it went. So the card is its own entry on the offer
+ * page rather than a checkout step. What it shows is the provider's:
+ *
+ * - `centrifuge::vault`: each wallet's pending and claimable positions, and
+ *   the claim that collects a filled one.
+ * - `coinlist::token_sale`: the user's participations and where each one
+ *   stands. Nothing is claimed - the sale pushes the tokens it allocates
+ *   once it settles, and refunds what it does not use - and the list is
+ *   polled, so an order placed in `CheckoutContainer` on the same page shows
+ *   up on its own.
  *
  * Only the matching provider's container is mounted, so its viewmodel is the
  * only one that runs. The `switch` is exhaustive against
@@ -1692,209 +1957,6 @@ interface ClaimContainerProps {
  */
 declare function ClaimContainer({ offer, wallets, walletLabel, config, enabled, className, }: ClaimContainerProps): ReactNode;
 
-/**
- * What the grid fetches, pre-fetched on the server instead. Each half is
- * independent: seed `offers` (via `CoinListServer#offers.list()`) and the
- * client still fetches the registry, seed `tokens` (via
- * `CoinListServer#tokens.list()`) and it still fetches the offers, seed both
- * and the grid makes no request of its own.
- */
-interface OffersGridData {
-    offers?: Offer[];
-    tokens?: TokenMetadata[];
-}
-
-interface OffersGridContainerProps {
-    /** Maximum number of columns to render when horizontal space allows. */
-    maxColumns?: number;
-    /** Optional className applied to the grid element. */
-    className?: string;
-    /** Optional className applied to the outer wrapper element. */
-    containerClassName?: string;
-    /** Optional loading slot shown while offers are being fetched. */
-    loading?: ReactNode;
-    /** Optional error slot shown when loading offers fails. */
-    error?: ReactNode;
-    /** Optional empty state slot shown when there are no available offers. */
-    emptyState?: ReactNode;
-    /** Optional per-offer click handler; when omitted, cards are not clickable. */
-    onOfferClick?: (offer: Offer) => void;
-    /**
-     * What the grid would otherwise fetch, pre-fetched on the server: `offers`
-     * via `CoinListServer#offers.list()`, `tokens` via
-     * `CoinListServer#tokens.list()`. Each half skips its own client-side
-     * fetch; pass both for a grid that makes no request of its own.
-     */
-    data?: OffersGridData;
-    /**
-     * Default `true`. When `false` nothing is fetched, so the container can be
-     * mounted while the grid is not needed yet.
-     */
-    enabled?: boolean;
-}
-/**
- * Displays a responsive live-sale grid of {@link OfferSaleCard}, backed by
- * {@link useOffersGridViewModel}. Each card is named and illustrated by the
- * public token registry where it lists the offer's token, and by the offer's
- * own fields otherwise - list offers carry no display name, so an unlisted
- * one shows logo + tagline until the host maps from detail. For equities /
- * past-sales browse rows, compose {@link OffersAssetGrid} instead.
- *
- * Pass `data` (offers and tokens pre-fetched server-side) to use them as-is
- * and skip the client-side fetches. Pass `enabled={false}` to skip the fetches
- * when the container is mounted but the grid is not needed yet. Uses the
- * `loading` / `error` / `emptyState` slots when provided; otherwise renders
- * the standard fallbacks. Cards are interactive only when `onOfferClick` is
- * provided.
- *
- * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
- * needed.
- */
-declare function OffersGridContainer({ data, onOfferClick, enabled, ...viewProps }?: OffersGridContainerProps): ReactNode;
-
-/**
- * One image as an `<img>` renders it: a `src` for a consumer that takes a
- * single URL, and the `srcSet` candidates for one that also knows the size
- * it renders at. `srcSet` is absent for a vector logo and for the offer's own
- * artwork, neither of which offers the browser a choice.
- */
-type LogoImageUi = {
-    src: string;
-    srcSet?: string;
-};
-/**
- * The logo a catalogue card renders for an offer, with the registry's
- * dark-theme counterpart when it configures one.
- *
- * `dark` is `null` rather than absent so a renderer has to decide what to do
- * without one: fall back to `light`, which is the registry's own rule.
- */
-type OfferLogoUi = {
-    light: LogoImageUi;
-    dark: LogoImageUi | null;
-};
-declare const OfferLogoUi: {
-    /**
-     * The registry's logo for the token an offer is about, or the offer's own
-     * artwork otherwise, or `null` when neither exists.
-     *
-     * The registry wins when both exist because it is the token's real artwork
-     * where `Offer.logoUrl` is catalogue artwork, and because a swap publishes
-     * without artwork more often than not - which is why `logoUrl` is `null`
-     * on the swap variants.
-     */
-    fromOffer: (offer: {
-        logoUrl: string | null;
-    }, tokenMetadata: TokenMetadata | null) => OfferLogoUi | null;
-};
-
-/**
- * An offer as {@link OfferAssetCard} renders it. Browse chrome: circular
- * `logo`, `name`, and asset `symbol`. No wordmark.
- *
- * All three come from the public token registry when the caller hands over
- * the metadata of the token the offer is about. Without it, `fromOffer`
- * omits `name` and `symbol` - the list payload has neither - so a list-mapped
- * card is honest about being logo-only, and `fromDetail` reads them from the
- * detail payload (`name`, `asset.code`).
- */
-type OfferAssetCardUi = {
-    id: OfferId;
-    /** Absent when neither the registry nor a detail payload names the offer. */
-    name?: string;
-    /** Absent when neither the registry nor a detail payload carries a ticker. */
-    symbol?: string;
-    /** `null` when neither the registry nor the offer carries artwork. */
-    logo: OfferLogoUi | null;
-};
-declare const OfferAssetCardUi: {
-    /**
-     * `tokenMetadata` is the registry's entry for the token the offer is about
-     * (`TokenRegistrySnapshot.forOffer`), or `null` when it lists none. The
-     * registry names win over the offer's own where both exist: they are the
-     * token's canonical name, ticker and artwork, where the offer's are
-     * catalogue copy.
-     */
-    fromOffer: (offer: Offer, tokenMetadata?: TokenMetadata | null) => OfferAssetCardUi;
-    fromDetail: (detail: OfferDetail, tokenMetadata?: TokenMetadata | null) => OfferAssetCardUi;
-};
-
-interface OfferAssetCardProps {
-    offer: OfferAssetCardUi;
-    /** When set, the whole card is the hit target. */
-    onClick?: () => void;
-    /** Optional className applied to the card root element. */
-    className?: string;
-    /** Optional className applied to an outer wrapper element. */
-    containerClassName?: string;
-}
-/**
- * Light browse-row catalogue card. Self-scoped. Header is the offer's `logo`
- * (the token registry's where it lists the token, with its dark-theme
- * variant, the catalogue's otherwise) beside `name` (h2) and asset `symbol`
- * under it — not a wordmark.
- * Responsive hug: tighter pad / logo / type below `md`, desktop keeps the
- * H4 + 48px logo row. Hosts compose this beside {@link OfferSaleCard}; the
- * card does not pick a variant itself.
- */
-declare function OfferAssetCard({ offer, onClick, className, containerClassName, }: OfferAssetCardProps): ReactNode;
-
-/**
- * An offer as {@link OfferSaleCard} renders it. Countdown copy is derived in
- * the leaf from `startsAt` / `endsAt` so it can tick; the mapper does not
- * invent a price, FDV, unlock schedule, banner overlay, or wordmark.
- *
- * `name` and `logo` come from the public token registry when the caller
- * hands over the metadata of the token the offer is about, and from the
- * offer otherwise. The list payload carries no name, so `fromOffer` leaves
- * `name` absent without registry metadata - do not derive one from `slug`.
- * The card pairs `logo` with `name` as an h2 and renders each only when
- * present. Prefer {@link OfferSaleCardUi.fromDetail} when the host has a
- * name and no registry answer.
- *
- * `tagline` and `startsAt` are null for an offer that runs no sale window, an
- * Ondo swap: the card then omits the tagline and, with nothing to count down
- * to, reads as live.
- */
-type OfferSaleCardUi = {
-    id: OfferId;
-    /** Absent when neither the registry nor a detail payload names the offer. */
-    name?: string;
-    tagline: string | null;
-    /** `null` when neither the registry nor the offer carries artwork. */
-    logo: OfferLogoUi | null;
-    startsAt: Date | null;
-    endsAt: Date | null;
-};
-declare const OfferSaleCardUi: {
-    /**
-     * `tokenMetadata` is the registry's entry for the token the offer is about
-     * (`TokenRegistrySnapshot.forOffer`), or `null` when it lists none. The
-     * registry names win over the offer's own where both exist: they are the
-     * token's canonical name and artwork, where the offer's are catalogue copy.
-     */
-    fromOffer: (offer: Offer, tokenMetadata?: TokenMetadata | null) => OfferSaleCardUi;
-    fromDetail: (detail: OfferDetail, tokenMetadata?: TokenMetadata | null) => OfferSaleCardUi;
-};
-
-interface OfferSaleCardProps {
-    offer: OfferSaleCardUi;
-    /** Host click handler. View offer always renders; this wires the hit target. */
-    onClick?: () => void;
-    /** Optional className applied to the card root element. */
-    className?: string;
-    /** Optional className applied to an outer wrapper element. */
-    containerClassName?: string;
-}
-/**
- * Dark live-sale catalogue card. Self-scoped. Header is the offer's `logo`
- * (the token registry's where it lists the token, the catalogue's otherwise)
- * beside the `name` as an h2, then the tagline — not a wordmark. The same
- * logo is painted as a faint right-shifted watermark over the gradient.
- * Responsive hug layout; View offer always renders. No token price, FDV or unlock.
- */
-declare function OfferSaleCard({ offer, onClick, className, containerClassName, }: OfferSaleCardProps): ReactNode;
-
 type LoadRequirementsReason = 'not-authenticated' | 'generic-error';
 type LoadRequirementsState = {
     type: 'LOADING';
@@ -2325,39 +2387,334 @@ interface UseCompleteOAuthOptions {
  */
 declare function useCompleteOAuth(options: UseCompleteOAuthOptions): void;
 
+type LoadOfferDetailsReason = 'not-authenticated' | 'generic-error';
+type LoadOfferDetailsState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadOfferDetailsReason;
+} | {
+    type: 'CONTENT';
+    offerDetail: OfferDetail;
+};
+interface UseOfferDetailsOptions {
+    /**
+     * Offer detail pre-fetched on the server (e.g. via `CoinListServer#offers.get()`).
+     * When provided, the hook uses this data as-is and skips the client-side fetch entirely.
+     */
+    data?: OfferDetail;
+    /**
+     * When `false`, the hook sends no request. A seeded or already-fetched
+     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+interface UseOfferDetailsResult {
+    offerDetailsState: LoadOfferDetailsState;
+}
 /**
- * UI models every checkout provider needs. Provider-specific models stay in
- * 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.
+ * Loads CoinList offer details for a given offer id and exposes a UI-friendly state.
  *
- * No React and no hooks: this is the module Views and leaf components import.
- */
-/**
- * The state of a step's call-to-action.
+ * 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.
  *
- * A SUM type rather than `disabled`/`isLoading` booleans, so "disabled while
- * loading" and "loading without a message" are both unrepresentable. The
- * message is what the user reads while an on-chain step runs (e.g. "Approving
- * USDC…"), so it belongs to the loading arm alone.
+ * Returns `LOADING` while CoinList is initializing or while details are being fetched.
+ * Returns `CONTENT` with the offer when `offers.get()` succeeds.
+ * Returns `ERROR` with:
+ * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
+ * - `generic-error` for any other failure
  */
-type CheckoutCtaUi = {
-    type: 'enabled';
+declare function useOfferDetails(offerId: OfferId, options?: UseOfferDetailsOptions): UseOfferDetailsResult;
+
+type LoadOffersReason = 'not-authenticated' | 'generic-error';
+type LoadOffersState = {
+    type: 'LOADING';
 } | {
-    type: 'disabled';
+    type: 'ERROR';
+    reason: LoadOffersReason;
 } | {
-    type: 'loading';
-    message: string;
+    type: 'CONTENT';
+    offers: Offer[];
 };
+interface UseOffersOptions {
+    /**
+     * Offers pre-fetched on the server (e.g. via `CoinListServer#offers.list()`).
+     * When provided, the hook uses this data as-is and skips the client-side fetch entirely.
+     */
+    data?: Offer[];
+    /**
+     * When `false`, the hook sends no request. A seeded or already-fetched
+     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+interface UseOffersResult {
+    offersState: LoadOffersState;
+}
 /**
- * A status and the copy that names it: an Ondo market that is open, a sale
- * still running, a window that has closed.
+ * Loads all CoinList offers for the current user and exposes a UI-friendly state.
+ *
+ * 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.
+ *
+ * Returns `LOADING` while CoinList is initializing or while offers are being fetched.
+ * Returns `CONTENT` with all offers when `fetchOffers()` succeeds.
+ * Returns `ERROR` with:
+ * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
+ * - `generic-error` for any other failure
+ */
+declare function useOffers(options?: UseOffersOptions): UseOffersResult;
+
+/**
+ * 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, 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 = LoadErrorReason;
+
+/**
+ * The state of one vault's status poll.
+ *
+ * Stale-preserving: a failed tick with a status in hand keeps it, so a flaky
+ * read never reads as "vault halted". `ERROR` means the status is unknown -
+ * which is not the same as `CONTENT` carrying a blocked orderability, and
+ * callers must not conflate them. A vault that is *known* to be unorderable
+ * may block a request; one that is merely unknown may not.
+ *
+ * `below_minimum` never appears here: it needs an amount, which this
+ * endpoint is never given.
+ *
+ * @alpha
+ */
+type LoadCentrifugeVaultStatusState = {
+    type: 'DISABLED';
+} | {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: CentrifugeLoadErrorReason;
+} | {
+    type: 'CONTENT';
+    status: CentrifugeVaultStatus;
+};
+/** @alpha */
+interface UseCentrifugeVaultStatusesOptions {
+    /** The vaults to poll, typically one per chain an offer runs on. */
+    vaults: CentrifugeVaultRef[];
+    /** How often to refresh. Defaults to {@link CENTRIFUGE_POLL_INTERVAL_MS}. */
+    pollIntervalMs?: number;
+    /**
+     * Statuses the caller already holds, typically fetched server-side, each
+     * opening the state of the vault it names so a server-rendered panel needs
+     * no loading pass.
+     *
+     * They seed the first render only: the poll still fetches immediately. A
+     * vault that was orderable a minute ago can be unlinked now, so a seed
+     * that suppressed the first read would be answering "can I act right now"
+     * with whenever the page was rendered.
+     */
+    data?: CentrifugeVaultStatus[];
+    /** When false, the hook neither fetches nor polls. */
+    enabled: boolean;
+}
+/** @alpha */
+interface UseCentrifugeVaultStatusesResult {
+    /** One entry per vault asked for, in the order asked. */
+    statuses: {
+        vault: CentrifugeVaultRef;
+        state: LoadCentrifugeVaultStatusState;
+    }[];
+}
+/**
+ * Polls whether each of several Centrifuge vaults can be acted on right now,
+ * independent of any wallet or amount.
+ *
+ * Free to poll - it spends no attestation. Centrifuge announces none of the
+ * changes this reports, so the poll is the only way a screen notices a vault
+ * halting under it. Each vault is read independently on one shared timer, so
+ * one failing chain never holds back another.
+ *
+ * A seeded status opens its vault's state instead of `LOADING` and is
+ * 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. 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
+ */
+declare function useCentrifugeVaultStatuses(options: UseCentrifugeVaultStatusesOptions): UseCentrifugeVaultStatusesResult;
+
+/** @alpha */
+interface UseCentrifugeVaultStatusOptions {
+    /** Share token symbol of the vault, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    /** How often to refresh. Defaults to `CENTRIFUGE_POLL_INTERVAL_MS`. */
+    pollIntervalMs?: number;
+    /**
+     * A status the caller already holds, typically fetched server-side, used
+     * as the state the hook opens on so a server-rendered panel needs no
+     * loading pass.
+     *
+     * It seeds the first render only: the poll still fetches immediately. A
+     * vault that was orderable a minute ago can be unlinked now, so a seed
+     * that suppressed the first read would be answering "can I invest right
+     * now" with whenever the page was rendered.
+     */
+    data?: CentrifugeVaultStatus;
+    /** When false, the hook neither fetches nor polls. */
+    enabled: boolean;
+}
+/** @alpha */
+interface UseCentrifugeVaultStatusResult {
+    state: LoadCentrifugeVaultStatusState;
+}
+/**
+ * Polls whether a Centrifuge vault can take a request at all right now,
+ * independent of any amount.
+ *
+ * Free to poll - it spends no attestation. Centrifuge announces none of the
+ * changes this reports, so the poll is the only way a checkout notices
+ * mid-order.
+ *
+ * The one-vault case of {@link useCentrifugeVaultStatuses}, which carries the
+ * seeding, stale-preserving and disabled semantics.
+ *
+ * @alpha
+ */
+declare function useCentrifugeVaultStatus(options: UseCentrifugeVaultStatusOptions): UseCentrifugeVaultStatusResult;
+
+/**
+ * The state of the participations read.
+ *
+ * Stale-preserving: a failed poll with a list in hand keeps it, so a flaky
+ * tick never empties the user's orders. `ERROR` therefore means nothing has
+ * answered yet - or the session ended, which drops the list rather than
+ * leaving a signed-out user looking at it. `DISABLED` means the hook was
+ * switched off before an answer arrived, so nothing is in flight.
+ */
+type LoadCoinListTokenSaleParticipationsState = {
+    type: 'DISABLED';
+} | {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadErrorReason;
+} | {
+    type: 'CONTENT';
+    participations: Participation[];
+};
+interface UseCoinListTokenSaleParticipationsOptions {
+    /**
+     * Participations pre-fetched on the server (e.g. via
+     * `CoinListServer#tokenSale.list()`). When provided, the hook opens on them
+     * and skips the first client-side read; the poll and
+     * {@link UseCoinListTokenSaleParticipationsResult.refetch} still read.
+     */
+    data?: Participation[];
+    /**
+     * When `false`, the hook sends no request and holds no timer. A seeded or
+     * already-fetched `CONTENT` survives; otherwise the hook reports
+     * `DISABLED`. Defaults to `true`.
+     */
+    enabled?: boolean;
+    /** How often to read again while the page is visible. Defaults to 15s. */
+    pollInterval?: Seconds;
+}
+interface UseCoinListTokenSaleParticipationsResult {
+    participationsState: LoadCoinListTokenSaleParticipationsState;
+    /**
+     * Reads again now: the recovery path after an `ERROR`, and the way past a
+     * server seed. No-op while disabled.
+     */
+    refetch: () => void;
+}
+/**
+ * Loads, and keeps reading, the current user's CoinList token-sale
+ * participations, optionally for one offer.
+ *
+ * A participation moves on the backend's clock - its approval is verified,
+ * its payment committed in a batch, any excess refunded after the sale
+ * settles - and none of it is announced, so the list is polled while the page
+ * is visible and read once more when it becomes visible again. The poll is
+ * also how an order placed through `CheckoutContainer` on the same page shows
+ * up here, with nothing for the host to wire.
+ *
+ * Returns `LOADING` while CoinList is initializing or the first read is in
+ * flight, and `CONTENT` once a read has answered - an empty list included.
+ * Returns `ERROR` with:
+ * - `not-authenticated` when the user has to sign in first
+ * - `generic-error` for any other failure before a list was in hand
+ */
+declare function useCoinListTokenSaleParticipations(offerId?: OfferId, options?: UseCoinListTokenSaleParticipationsOptions): UseCoinListTokenSaleParticipationsResult;
+
+/**
+ * UI models every checkout provider needs. Provider-specific models stay in
+ * that provider's `use{X}ViewModel.types`; these live here because Ondo and
+ * Superstate both render them.
+ *
+ * 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.
+ */
+/**
+ * The state of a step's call-to-action.
+ *
+ * A SUM type rather than `disabled`/`isLoading` booleans, so "disabled while
+ * loading" and "loading without a message" are both unrepresentable. The
+ * message is what the user reads while an on-chain step runs (e.g. "Approving
+ * USDC…"), so it belongs to the loading arm alone.
+ */
+type CheckoutCtaUi = {
+    type: 'enabled';
+} | {
+    type: 'disabled';
+} | {
+    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.
  *
  * A SUM type rather than a `label` plus an `isActive` flag, so the label always
  * arrives with the state it describes. The label is already formatted — a
@@ -2461,6 +2818,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.
  *
@@ -2513,107 +2906,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';
-};
-
-/**
- * Why a Centrifuge read failed, in the only two flavours a 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.
- *
- * @alpha
- */
-type CentrifugeLoadErrorReason = 'not-authenticated' | 'generic-error';
-
 /**
- * The built deposit request a review step can place.
+ * Where a placed order can be checked: the wallet it settles to, and the
+ * transaction on a block explorer.
  *
- * `isRefreshing` rides on `CONTENT` so a rebuild never blanks the numbers on
- * screen. A failed rebuild keeps them and says why.
- *
- * @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.
@@ -2648,38 +2957,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.
@@ -2734,24 +3042,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;
@@ -2759,8 +3156,7 @@ type CentrifugeWalletSelectUiState = {
     type: 'completed';
     wallet: CheckoutConfirmedWalletUi;
 };
-/** @alpha */
-type CentrifugeWalletSelectUiEvent = {
+type CheckoutWalletSelectUiEvent = {
     type: 'ON_SELECT_WALLET';
     value: CheckoutWalletTypeUi;
 }
@@ -2787,8 +3183,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;
@@ -2797,7 +3198,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.
  *
@@ -2807,13 +3208,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';
@@ -2823,6 +3222,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. */
@@ -2840,53 +3248,191 @@ 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 LoadParticipationsState = {
-    type: 'LOADING';
+/**
+ * The last step of the token-sale checkout: confirming the commitment and
+ * placing it.
+ *
+ * Placing approves the payment to the sale's funding contract and records the
+ * participation. The sale pulls the payment shortly after and holds it, and
+ * allocates the tokens only when it settles, so the quantity shown is an
+ * estimate.
+ *
+ * @alpha
+ */
+type TokenSaleReviewUiState = {
+    type: 'incomplete';
 } | {
-    type: 'ERROR';
-    reason: LoadParticipationsReason;
+    type: 'active';
+    /** The token being bought. */
+    outputAsset: CheckoutAssetUi;
+    /** How many tokens the payment buys at the option's price, e.g. `200.00 TKN`. */
+    estimatedTokens: FormattedAmountAssetUi;
+    /** The option's price for one whole token, e.g. `$0.50`. */
+    pricePerToken: FormattedAmountAssetUi;
+    /** What the user commits, e.g. `100.00 USDC`. No fee comes off it. */
+    payAmount: FormattedAmountAssetUi;
+    /** Where the tokens land - the wallet that approves the payment. */
+    recipientAddress: ShortenedWalletAddress;
+    /** The option's sale agreement, which the order is placed under. */
+    saleAgreementUrl: string | null;
+    placeOrderCta: CheckoutCtaUi;
+    error: string | null;
+};
+/** @alpha */
+type TokenSaleReviewUiEvent = {
+    type: 'ON_PLACE_ORDER';
+};
+
+/**
+ * Why a token-sale checkout cannot run at all, as opposed to a step of it
+ * failing. Every one of them is a fact about the offer and the host's props,
+ * so none clears on its own:
+ *
+ * - `unsupported-chain`: the sale names no funding contract on the chain.
+ * - `unknown-option`: the host's `optionId` is not one of the offer's options.
+ * - `no-price`: the option has no fixed price - an auction, which the SDK
+ *   does not run.
+ * - `no-payable-asset`: the sale accepts no coin the SDK can pay with on the
+ *   chain.
+ *
+ * @alpha
+ */
+type TokenSaleCheckoutErrorReason = CheckoutBlockedReason<'unknown-option' | 'no-price' | 'no-payable-asset'>;
+
+/**
+ * The reference panel beside the token-sale checkout: which token is being
+ * bought, what one costs, whether the sale is running, and the terms that do
+ * not move while the order is filled in.
+ *
+ * Read-only, so there is no `UiEvent`. Everything is known from the offer the
+ * moment the checkout renders, so the state is a product rather than a union.
+ *
+ * @alpha
+ */
+type TokenSaleSidebarUiState = {
+    asset: CheckoutAssetUi;
+    /** Whether the sale is running: a live countdown, or why it is not. */
+    sale: CheckoutStatusUi;
+    /** The option's price for one whole token, e.g. `$0.50`. */
+    pricePerToken: FormattedAmountAssetUi;
+    /**
+     * The price times the option's total token supply, e.g. `$500,000,000.00`.
+     * `-` when the option publishes no supply.
+     */
+    fullyDilutedValuation: FormattedAmountAssetUi;
+    /** Display name of the chain the sale is paid on, e.g. `Ethereum`. */
+    networkName: string;
+    /** What the sale can be paid in, e.g. `USDC, USDT`. */
+    purchaseOptionsLabel: string;
+    /** The option's minimum, e.g. `$100.00`. `-` when it publishes none. */
+    minPurchase: FormattedAmountAssetUi;
+};
+
+/**
+ * The whole CoinList token-sale checkout: three steps, the sale panel, and the
+ * dialog that says the order was placed.
+ *
+ * @alpha
+ */
+type CoinListTokenSaleCheckoutUiState = {
+    type: 'content';
+    /**
+     * The wallet step, or `null` when the host preselected a wallet and the
+     * flow skipped it. The later steps are numbered from it.
+     */
+    wallet: CheckoutWalletSelectUiState | null;
+    amount: CheckoutAmountUiState;
+    review: TokenSaleReviewUiState;
+    sidebar: TokenSaleSidebarUiState;
+    orderPlaced: TokenSaleOrderPlacedUiState;
 } | {
-    type: 'CONTENT';
-    participations: Participation[];
+    type: 'error';
+    reason: TokenSaleCheckoutErrorReason;
+};
+/** @alpha */
+type CoinListTokenSaleCheckoutUiEvent = CheckoutWalletSelectUiEvent | CheckoutAmountUiEvent | TokenSaleReviewUiEvent | TokenSaleOrderPlacedUiEvent;
+/**
+ * The dialog that closes the checkout once the order is recorded.
+ *
+ * It reports a commitment, not a purchase: the sale takes and holds the
+ * payment, and allocates the tokens only when it settles. The explorer link is the approval's,
+ * the one transaction the order sent.
+ *
+ * @alpha
+ */
+type TokenSaleOrderPlacedUiState = {
+    type: 'hidden';
+} | ({
+    type: 'visible';
+    outputAsset: CheckoutAssetUi;
+    /** What was committed, e.g. `100.00 USDC`. */
+    payAmount: FormattedAmountAssetUi;
+    /** How many tokens it buys at the option's price, e.g. `200.00 TKN`. */
+    estimatedTokens: FormattedAmountAssetUi;
+} & CheckoutReceiptUi);
+/** @alpha */
+type TokenSaleOrderPlacedUiEvent = {
+    type: 'ON_CLOSE_ORDER_PLACED';
 };
-interface UseParticipationsOptions {
+
+/** @alpha */
+interface UseCoinListTokenSaleCheckoutViewModelOptions {
+    offer: CoinListTokenSaleOfferDetail;
+    /** The chain the order is paid on. The sale must name a funding contract there. */
+    chain: EthereumChain;
     /**
-     * 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.
+     * The option being bought, which sets the price, the minimum and the sale
+     * agreement. Defaults to the offer's first option.
+     *
+     * **Read once, at mount**: the price, minimum and agreement the steps were
+     * filled in against are this option's. A host whose selection can change
+     * remounts with a `key` covering it.
      */
-    data?: Participation[];
+    optionId?: OfferOptionId;
     /**
-     * When `false`, the hook sends no request. A seeded or already-fetched
-     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     * 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 participation is recorded. The dialog shows either way. */
+    onOrderPlaced?: (order: TokenSaleOrderPlaced) => void;
 }
-interface UseParticipationsResult {
-    participationsState: LoadParticipationsState;
+/** @alpha */
+interface UseCoinListTokenSaleCheckoutViewModelResult {
+    state: CoinListTokenSaleCheckoutUiState;
+    onEvent: (event: CoinListTokenSaleCheckoutUiEvent) => void;
 }
 /**
- * Loads all CoinList participations for the current user and exposes a UI-friendly state.
- * Optionally filters by offer when `offerId` is provided.
+ * Drives the CoinList token-sale checkout.
  *
- * 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.
+ * The container mounts this hook only. It composes the shared wallet and
+ * amount steps, the review that places the order, and the sale panel. The
+ * amount step only validates; the review approves the payment to the sale's
+ * funding contract and records the participation.
  *
- * Returns `LOADING` while CoinList is initializing or while participations are being fetched.
- * Returns `CONTENT` with all participations when `fetchParticipations()` succeeds.
- * Returns `ERROR` with:
- * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
- * - `generic-error` for any other failure
+ * A sale that cannot take an order on this chain at all - no funding
+ * contract, no such option, no fixed price, no coin the SDK can pay with -
+ * replaces the whole checkout. A sale outside its window blocks the amount
+ * and review steps instead, and the panel says when it opens or that it
+ * ended.
+ *
+ * @alpha
  */
-declare function useParticipations(offerId?: OfferId, options?: UseParticipationsOptions): UseParticipationsResult;
+declare function useCoinListTokenSaleCheckoutViewModel({ offer, chain, optionId: initialOptionId, wallets, enabled, onOrderPlaced, }: UseCoinListTokenSaleCheckoutViewModelOptions): UseCoinListTokenSaleCheckoutViewModelResult;
 
 /**
  * Step 2 of the Ondo checkout: how much to spend, and which asset to spend.
@@ -2952,28 +3498,43 @@ 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.
  *
- * `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.
+ * `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 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;
 };
+
+/**
+ * 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
@@ -2997,29 +3558,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.
  *
@@ -3057,38 +3639,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';
 }
@@ -3101,9 +3656,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
@@ -3112,47 +3672,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,
@@ -3223,54 +3743,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.
@@ -3290,7 +3762,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. */
@@ -3316,7 +3793,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.
  *
@@ -3326,7 +3803,7 @@ type OndoBuyCheckoutUiEvent = OndoWalletSelectUiEvent | OndoBuyAmountUiEvent | O
  */
 type OndoOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /**
      * What was bought.
@@ -3342,14 +3819,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.
  *
@@ -3378,7 +3848,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
@@ -3417,12 +3897,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.
  */
@@ -3506,23 +3986,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
@@ -3545,26 +4013,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;
 
@@ -3624,7 +4081,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;
@@ -3657,33 +4114,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';
 }
@@ -3719,7 +4149,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. */
@@ -3747,7 +4177,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.
  *
@@ -3757,7 +4187,7 @@ type OndoSellCheckoutUiEvent = OndoWalletSelectUiEvent | OndoSellAmountUiEvent |
  */
 type OndoSellOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /**
      * What was sold.
@@ -3782,14 +4212,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.
  *
@@ -3819,7 +4242,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
@@ -3884,6 +4307,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
@@ -3895,6 +4319,8 @@ declare function useOndoSellCheckoutViewModel({ offer, chain, wallets, enabled,
  * when the UI has nothing to show.
  */
 type LoadOndoPriceState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -3941,15 +4367,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
@@ -3969,6 +4392,8 @@ declare function useOndoPrice(options: UseOndoPriceOptions): UseOndoPriceResult;
  * unknown may not.
  */
 type LoadOndoTradingStatusState = {
+    type: 'DISABLED';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
@@ -3979,8 +4404,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 {
@@ -4023,94 +4448,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;
@@ -4123,12 +4484,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.
@@ -4136,11 +4497,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;
 
@@ -4161,21 +4522,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;
 
@@ -4338,10 +4723,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.
@@ -4385,7 +4771,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;
@@ -4420,7 +4806,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.
  *
@@ -4440,7 +4826,7 @@ type SuperstateSwapCheckoutRetryUiEvent = {
  */
 type SuperstateOrderConfirmedUiState = {
     type: 'hidden';
-} | {
+} | ({
     type: 'visible';
     /** What was bought. */
     asset: CheckoutAssetUi;
@@ -4464,14 +4850,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.
  *
@@ -4499,7 +4878,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
@@ -4598,11 +4987,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';
@@ -4629,8 +5021,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;
 }
@@ -4663,85 +5054,132 @@ interface UseCentrifugeClaimPositionsResult {
  */
 declare function useCentrifugeClaimPositions(options: UseCentrifugeClaimPositionsOptions): UseCentrifugeClaimPositionsResult;
 
-type LoadOfferDetailsReason = 'not-authenticated' | 'generic-error';
-type LoadOfferDetailsState = {
+/**
+ * The token-sale claim card.
+ *
+ * `HIDDEN` renders nothing: the card is switched off, or the user is signed
+ * out and the host decides whether to ask them in. `CONTENT` with no rows is
+ * a real answer - nothing placed yet - and renders as such.
+ *
+ * @alpha
+ */
+type CoinListTokenSaleClaimUiState = {
+    type: 'HIDDEN';
+} | {
     type: 'LOADING';
 } | {
     type: 'ERROR';
-    reason: LoadOfferDetailsReason;
 } | {
     type: 'CONTENT';
-    offerDetail: OfferDetail;
+    rows: ParticipationRowUi[];
 };
-interface UseOfferDetailsOptions {
-    /**
-     * Offer detail pre-fetched on the server (e.g. via `CoinListServer#offers.get()`).
-     * When provided, the hook uses this data as-is and skips the client-side fetch entirely.
-     */
-    data?: OfferDetail;
+/** @alpha */
+type CoinListTokenSaleClaimUiEvent = {
+    type: 'ON_RETRY_LOAD';
+};
+/**
+ * Where a participation stands, in the steps a user can tell apart.
+ *
+ * - `processing`: the approval is being verified, or the payment is being
+ *   committed to the sale's contract.
+ * - `committed`: the payment is held by the sale until it settles.
+ * - `failed`: the approval or the commit failed, so nothing was taken.
+ * - `refunding`: a refund is on its way back to the wallet that paid.
+ * - `refunded`: the refund arrived. It may be the whole payment or only what
+ *   the allocation did not use; the API does not say which.
+ * - `refund-failed`: the refund transaction failed, and support has to step
+ *   in.
+ *
+ * @alpha
+ */
+type ParticipationStatusUi = 'processing' | 'committed' | 'failed' | 'refunding' | 'refunded' | 'refund-failed';
+/** @alpha */
+declare const ParticipationStatusUi: {
     /**
-     * When `false`, the hook sends no request. A seeded or already-fetched
-     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     * Folds the backend's eight steps into the six a user can act on. The
+     * three before the payment is held - approval unverified, queued for a
+     * commit batch, commit broadcast - are one wait to the user.
      */
-    enabled?: boolean;
-}
-interface UseOfferDetailsResult {
-    offerDetailsState: LoadOfferDetailsState;
-}
+    fromDomain: (status: ParticipationStatus) => ParticipationStatusUi;
+};
 /**
- * Loads CoinList offer details for a given offer id and exposes a UI-friendly state.
+ * How a row reads its dates: the current instant, and the wall clock to read
+ * them on (`undefined` for the runtime's own).
  *
- * 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.
- *
- * Returns `LOADING` while CoinList is initializing or while details are being fetched.
- * Returns `CONTENT` with the offer when `offers.get()` succeeds.
- * Returns `ERROR` with:
- * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
- * - `generic-error` for any other failure
+ * @alpha
  */
-declare function useOfferDetails(offerId: OfferId, options?: UseOfferDetailsOptions): UseOfferDetailsResult;
-
-type LoadOffersReason = 'not-authenticated' | 'generic-error';
-type LoadOffersState = {
-    type: 'LOADING';
-} | {
-    type: 'ERROR';
-    reason: LoadOffersReason;
-} | {
-    type: 'CONTENT';
-    offers: Offer[];
+type ParticipationClockUi = {
+    now: EpochMillis;
+    timeZone: string | undefined;
 };
-interface UseOffersOptions {
+/**
+ * One participation as a row of the card.
+ *
+ * @alpha
+ */
+type ParticipationRowUi = {
+    key: ParticipationId;
+    /** The coin it was paid in: its name for the icon's alt text, and its icon. */
+    asset: {
+        name: string;
+        iconUrl: AssetIconUrl | null;
+    };
+    /** What was paid, e.g. `1,000.00 USDC`. */
+    amount: FormattedAmountAssetUi;
+    status: ParticipationStatusUi;
+    /** The wallet that paid, by label or shortened address; `null` if unknown. */
+    wallet: string | null;
     /**
-     * Offers pre-fetched on the server (e.g. via `CoinListServer#offers.list()`).
-     * When provided, the hook uses this data as-is and skips the client-side fetch entirely.
+     * When it was placed, on the user's clock and without the year when it is
+     * this one - `Oct 15, 10:14 AM`; `null` if the API did not say.
      */
-    data?: Offer[];
+    placedAt: string | null;
+};
+/** @alpha */
+declare const ParticipationRowUi: {
+    fromDomain: (participation: Participation, { walletLabel, locale, clock, }: {
+        walletLabel: WalletLabelResolver | undefined;
+        locale: string;
+        clock: ParticipationClockUi;
+    }) => ParticipationRowUi;
+};
+
+/** @alpha */
+interface UseCoinListTokenSaleClaimViewModelOptions {
+    offer: CoinListTokenSaleOfferDetail;
+    /** Names the wallet that paid; unnamed ones show a shortened address. */
+    walletLabel?: WalletLabelResolver;
     /**
-     * When `false`, the hook sends no request. A seeded or already-fetched
-     * `CONTENT` survives; otherwise the hook stays `LOADING`. Defaults to `true`.
+     * The offer's participations pre-fetched on the server, so the card opens
+     * on them. The poll still reads. Dates render in UTC on the server and
+     * through hydration, so the markup matches on any clock, then on the
+     * user's own clock from the render straight after.
      */
+    data?: Participation[];
+    /** How often to read the participations again while the page is visible. */
+    pollInterval?: Seconds;
+    /** Default `true`. `false` turns off every request and timer. */
     enabled?: boolean;
 }
-interface UseOffersResult {
-    offersState: LoadOffersState;
+/** @alpha */
+interface UseCoinListTokenSaleClaimViewModelResult {
+    state: CoinListTokenSaleClaimUiState;
+    onEvent: (event: CoinListTokenSaleClaimUiEvent) => void;
 }
 /**
- * Loads all CoinList offers for the current user and exposes a UI-friendly state.
+ * The token-sale claim card: every participation the user has placed in an
+ * offer, across its options and whichever wallet paid, and where each one
+ * stands.
  *
- * 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.
+ * Nothing here is claimed. A token sale pushes the tokens it allocates once
+ * it settles and refunds what it does not use, so the card follows each
+ * participation through those steps and the user has nothing to press but a
+ * retry. The list is account-wide rather than read per wallet, so it needs
+ * none of the host's wallets.
  *
- * Returns `LOADING` while CoinList is initializing or while offers are being fetched.
- * Returns `CONTENT` with all offers when `fetchOffers()` succeeds.
- * Returns `ERROR` with:
- * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
- * - `generic-error` for any other failure
+ * @alpha
  */
-declare function useOffers(options?: UseOffersOptions): UseOffersResult;
+declare function useCoinListTokenSaleClaimViewModel({ offer, walletLabel, data, pollInterval, enabled, }: UseCoinListTokenSaleClaimViewModelOptions): UseCoinListTokenSaleClaimViewModelResult;
 
 /**
  * A display-ready connect-wallet error: the core flow's machine-readable code
@@ -5032,120 +5470,6 @@ interface UseRequirementsChecklistViewModelResult {
  */
 declare function useRequirementsChecklistViewModel(options: UseRequirementsChecklistViewModelOptions): UseRequirementsChecklistViewModelResult;
 
-/**
- * The state of one vault's status poll.
- *
- * Stale-preserving: a failed tick with a status in hand keeps it, so a flaky
- * read never reads as "vault halted". `ERROR` means the status is unknown -
- * which is not the same as `CONTENT` carrying a blocked orderability, and
- * callers must not conflate them. A vault that is *known* to be unorderable
- * may block a request; one that is merely unknown may not.
- *
- * `below_minimum` never appears here: it needs an amount, which this
- * endpoint is never given.
- *
- * @alpha
- */
-type LoadCentrifugeVaultStatusState = {
-    type: 'LOADING';
-} | {
-    type: 'ERROR';
-    reason: CentrifugeLoadErrorReason;
-} | {
-    type: 'CONTENT';
-    status: CentrifugeVaultStatus;
-};
-/** @alpha */
-interface UseCentrifugeVaultStatusesOptions {
-    /** The vaults to poll, typically one per chain an offer runs on. */
-    vaults: CentrifugeVaultRef[];
-    /** How often to refresh. Defaults to {@link CENTRIFUGE_POLL_INTERVAL_MS}. */
-    pollIntervalMs?: number;
-    /**
-     * Statuses the caller already holds, typically fetched server-side, each
-     * opening the state of the vault it names so a server-rendered panel needs
-     * no loading pass.
-     *
-     * They seed the first render only: the poll still fetches immediately. A
-     * vault that was orderable a minute ago can be unlinked now, so a seed
-     * that suppressed the first read would be answering "can I act right now"
-     * with whenever the page was rendered.
-     */
-    data?: CentrifugeVaultStatus[];
-    /** When false, the hook neither fetches nor polls. */
-    enabled: boolean;
-}
-/** @alpha */
-interface UseCentrifugeVaultStatusesResult {
-    /** One entry per vault asked for, in the order asked. */
-    statuses: {
-        vault: CentrifugeVaultRef;
-        state: LoadCentrifugeVaultStatusState;
-    }[];
-}
-/**
- * Polls whether each of several Centrifuge vaults can be acted on right now,
- * independent of any wallet or amount.
- *
- * Free to poll - it spends no attestation. Centrifuge announces none of the
- * changes this reports, so the poll is the only way a screen notices a vault
- * halting under it. Each vault is read independently on one shared timer, so
- * one failing chain never holds back another.
- *
- * A seeded status opens its vault's state instead of `LOADING` and is
- * 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.
- *
- * @alpha
- */
-declare function useCentrifugeVaultStatuses(options: UseCentrifugeVaultStatusesOptions): UseCentrifugeVaultStatusesResult;
-
-/** @alpha */
-interface UseCentrifugeVaultStatusOptions {
-    /** Share token symbol of the vault, e.g. `deJTRSY`. */
-    symbol: AssetSymbol;
-    chain: EthereumChain;
-    /** How often to refresh. Defaults to `CENTRIFUGE_POLL_INTERVAL_MS`. */
-    pollIntervalMs?: number;
-    /**
-     * A status the caller already holds, typically fetched server-side, used
-     * as the state the hook opens on so a server-rendered panel needs no
-     * loading pass.
-     *
-     * It seeds the first render only: the poll still fetches immediately. A
-     * vault that was orderable a minute ago can be unlinked now, so a seed
-     * that suppressed the first read would be answering "can I invest right
-     * now" with whenever the page was rendered.
-     */
-    data?: CentrifugeVaultStatus;
-    /** When false, the hook neither fetches nor polls. */
-    enabled: boolean;
-}
-/** @alpha */
-interface UseCentrifugeVaultStatusResult {
-    state: LoadCentrifugeVaultStatusState;
-}
-/**
- * Polls whether a Centrifuge vault can take a request at all right now,
- * independent of any amount.
- *
- * Free to poll - it spends no attestation. Centrifuge announces none of the
- * changes this reports, so the poll is the only way a checkout notices
- * mid-order.
- *
- * The one-vault case of {@link useCentrifugeVaultStatuses}, which carries the
- * seeding, stale-preserving and disabled semantics.
- *
- * @alpha
- */
-declare function useCentrifugeVaultStatus(options: UseCentrifugeVaultStatusOptions): UseCentrifugeVaultStatusResult;
-
 interface UseErc20BalanceOptions {
     /**
      * The token to read, by contract address.
@@ -5156,26 +5480,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 +5534,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 +5557,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 +5733,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 CoinListTokenSaleCheckoutUiEvent, type CoinListTokenSaleCheckoutUiState, type CoinListTokenSaleClaimUiEvent, type CoinListTokenSaleClaimUiState, 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 LoadCoinListTokenSaleParticipationsState, 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 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 ParticipationClockUi, ParticipationRowUi, ParticipationStatusUi, 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 TokenSaleApproval, type TokenSaleCheckoutErrorReason, type TokenSaleExecutionError, type TokenSaleExecutionPhase, type TokenSaleExecutionResult, type TokenSaleOrderPlaced, type TokenSaleOrderPlacedUiEvent, type TokenSaleOrderPlacedUiState, type TokenSaleReviewUiEvent, type TokenSaleReviewUiState, type TokenSaleSidebarUiState, 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 UseCoinListTokenSaleCheckoutViewModelOptions, type UseCoinListTokenSaleCheckoutViewModelResult, type UseCoinListTokenSaleClaimViewModelOptions, type UseCoinListTokenSaleClaimViewModelResult, type UseCoinListTokenSaleParticipationsOptions, type UseCoinListTokenSaleParticipationsResult, 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 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, useCoinListTokenSaleCheckoutViewModel, useCoinListTokenSaleClaimViewModel, useCoinListTokenSaleParticipations, useCompleteOAuth, useConnectWallet, useErc20Balance, useErc20TokenBalances, useKycToken, useOfferDetails, useOffers, useOndoBuyCheckoutViewModel, useOndoBuyTransaction, useOndoPrice, useOndoSellCheckoutViewModel, useOndoSellTransaction, useOndoTradingStatus, useOptionAddresses, useRequirements, useRequirementsChecklistViewModel, useSuperstateSwapCheckoutViewModel, useSwapOutputToken, useSwapQuote, useTaxDocument, useTokenMetadata, useTokenRegistry };