@coinlist-co/react 0.12.2-rc.7b430dd → 0.12.2-rc.8a0d02a

package/dist/client/index.d.ts

@@ -1,9 +1,9 @@
 import * as react from 'react';
 import { ReactNode, ButtonHTMLAttributes } from 'react';
-import { A as AuthorizationCode, C as CodeVerifier, L as Logger, W as WalletError, E as Erc20Namespace, a as EthereumChain, b as EvmContractAddress, B as BlockchainAmount, c as CoinListTokenSaleNamespace, O as OfferId, d as OfferOptionId, e as AssetId, P as Participation, f as CoinListTokenSaleNamespaceImpl, U as UniversalNamespaceContext, g as OndoNamespace, h as AssetSymbol, i as OfferSwapContract, j as OndoBuyTransaction, k as OndoSellTransaction, l as OndoSwapTransactionCore, m as OrderBookSide, n as OndoNamespaceImpl, S as SuperstateSwapNamespace, o as WalletsNamespace, p as Bps, q as EvmWalletAddress, r as SuperstateSwapNamespaceImpl, R as RequirementsNamespace, s as Requirement, t as RequirementsNamespaceImpl, u as Config, v as OAuthAccessToken, w as OffersNamespace, T as TokensNamespace, x as StablecoinSymbol, y as Erc20Asset, z as OfferDetail, D as TokenMetadata, F as OfferType, G as OndoSwapOfferDetail, H as CoinListTokenSaleOfferDetail, I as SuperstateSwapOfferDetail, J as Offer, K as RequirementStatusInfo, M as RequirementType, N as RequirementStatusValue, Q as OfferOptionAddress, V as RequirementId, X as KycLevelName, Y as DocumentSubmission, Z as WalletChallengeType, _ as PinoLoggerOptions, $ as OndoTradingStatus, a0 as AssetDecimals, a1 as BuildOndoBuyParams, a2 as BuildOndoSellParams, a3 as OndoQuote, a4 as OndoQuoteSize, a5 as TokenIdentifier, a6 as OfferOptionAddressId, a7 as TokenLogo } from '../tokens-namespace-CIWBtgt2.js';
-export { a8 as DebugEvent, a9 as FrontlineEventId, aa as HttpError, ab as HttpResponse, ac as KycToken, ad as LogBinding, ae as LogBindings, af as LogCause, ag as LogLevel, ah as LogScope, ai as LogValue, aj as ProductionLogLevel, ak as RedactedWalletError, al as RequestId, am as RpcFailureReason, an as SafeEvent, ao as SafeFields, ap as UnredactedFields } from '../tokens-namespace-CIWBtgt2.js';
-import { P as PKCEConfig, E as EvmWallet, S as SwapQuote, A as AssetIconUrl, a as ShortenedWalletAddress, F as FormattedAmountAssetUi, b as FormattedPercentUi, T as TxExplorerUrl, C as ConnectWallet, N as NonEmptyArray, c as TokenRegistrySnapshot } from '../token-registry-snapshot-BNBNuDu1.js';
-export { B as BroadcastTxParams, d as EvmSigner, W as WriteContractParams } from '../token-registry-snapshot-BNBNuDu1.js';
+import { A as AuthorizationCode, C as CodeVerifier, L as Logger, W as WalletError, E as Erc20Namespace, a as EthereumChain, b as EvmContractAddress, B as BlockchainAmount, c as CentrifugeNamespace, d as AssetSymbol, O as OfferVaultContract, e as CentrifugeVaultBuyTransaction, f as CentrifugeClaimDirection, g as CentrifugeNamespaceImpl, U as UniversalNamespaceContext, h as CoinListTokenSaleNamespace, i as OfferId, j as OfferOptionId, k as AssetId, P as Participation, l as CoinListTokenSaleNamespaceImpl, m as OndoNamespace, n as OfferSwapContract, o as OndoBuyTransaction, p as OndoSellTransaction, q as OndoSwapTransactionCore, r as OrderBookSide, s as OndoNamespaceImpl, S as SuperstateSwapNamespace, t as WalletsNamespace, u as Bps, v as EvmWalletAddress, w as SuperstateSwapNamespaceImpl, R as RequirementsNamespace, x as Requirement, y as RequirementsNamespaceImpl, z as Config, D as OAuthAccessToken, F as OffersNamespace, T as TokensNamespace, G as StablecoinSymbol, H as Erc20Asset, I as OfferDetail, J as TokenMetadata, K as CentrifugeVaultOfferDetail, M as OfferType, N as OndoSwapOfferDetail, Q as CoinListTokenSaleOfferDetail, V as SuperstateSwapOfferDetail, X as CentrifugeVaultLegId, Y as Seconds, Z as AsyncOfferType, _ as AsyncOfferDetail, $ as Offer, a0 as RequirementStatusInfo, a1 as RequirementType, a2 as RequirementStatusValue, a3 as OfferOptionAddress, a4 as RequirementId, a5 as KycLevelName, a6 as DocumentSubmission, a7 as WalletChallengeType, a8 as PinoLoggerOptions, a9 as AssetDecimals, aa as BuildCentrifugeVaultBuyParams, ab as CentrifugeOrderReason, ac as CentrifugeOrderability, ad as OndoTradingStatus, ae as BuildOndoBuyParams, af as BuildOndoSellParams, ag as OndoQuote, ah as OndoQuoteSize, ai as TokenIdentifier, aj as CentrifugeVaultLeg, ak as OfferOptionAddressId, al as CentrifugeVaultStatus, am as TokenLogo } from '../time-CVZpAkGY.js';
+export { an as DebugEvent, ao as FrontlineEventId, ap as HttpError, aq as HttpResponse, ar as KycToken, as as LogBinding, at as LogBindings, au as LogCause, av as LogLevel, aw as LogScope, ax as LogValue, ay as ProductionLogLevel, az as RedactedWalletError, aA as RequestId, aB as RpcFailureReason, aC as SafeEvent, aD as SafeFields, aE as UnredactedFields } from '../time-CVZpAkGY.js';
+import { P as PKCEConfig, E as EvmWallet, S as SwapQuote, A as AssetIconUrl, F as FormattedAmountAssetUi, a as ShortenedWalletAddress, b as FormattedPercentUi, T as TxExplorerUrl, W as WalletSelection, c as WalletLabelResolver, C as ConnectWallet, N as NonEmptyArray, d as TokenRegistrySnapshot } from '../token-registry-snapshot-BkwA8KmD.js';
+export { B as BroadcastTxParams, e as EvmSigner, f as ExternalWalletAdapter, g as WriteContractParams } from '../token-registry-snapshot-BkwA8KmD.js';
 import { Hash } from 'viem';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
@@ -165,6 +165,267 @@ declare function submitErc20Approval<Phase extends string>(args: {
     emit: (phase: Phase) => void;
 }): Promise<SubmitErc20ApprovalResult>;
 
+/**
+ * Progress phases emitted while a request is being prepared, in order. An
+ * allowance that already covers the deposit skips the approval phases.
+ */
+type CentrifugeBuyPreparationPhase = 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.
+ */
+type CentrifugeBuyPreparationError = {
+    step: 'unsupported-chain';
+    chain: EthereumChain;
+} | Erc20AllowanceError | {
+    step: 'insufficient-allowance';
+} | {
+    step: 'build-transaction';
+};
+type CentrifugeBuyPreparationResult = {
+    type: 'success';
+    transaction: CentrifugeVaultBuyTransaction;
+} | {
+    type: 'error';
+    error: CentrifugeBuyPreparationError;
+};
+type PrepareCentrifugeBuyParams = {
+    centrifuge: CentrifugeNamespace;
+    erc20: Erc20Namespace;
+    wallet: EvmWallet;
+    /** The vault's share token symbol, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    /**
+     * The offer's `vault_contracts`. The proxy is the spender, and it has to be
+     * known before the buy response arrives: the approval mines first, and
+     * `tx.to` comes too late to approve against.
+     */
+    vaultContracts: OfferVaultContract[];
+    /** The funding token being spent. Approval only; frontline resolves its own. */
+    tokenAddress: EvmContractAddress;
+    /** How much of the funding token to deposit, in its base units. */
+    amount: BlockchainAmount;
+    onProgress?: (phase: CentrifugeBuyPreparationPhase) => void;
+};
+/**
+ * Gets a deposit ready to broadcast: ensures the vault proxy may pull
+ * `amount` of the funding token, then builds the calldata that queues the
+ * request.
+ *
+ * The review step runs this when the user places the request, not when they
+ * confirm the amount. Approving on the amount step would make them sign
+ * again if they edit the amount. The allowance still has to land before the
+ * build: frontline refuses calldata the proxy cannot pull.
+ *
+ * Total: every failure is returned step-tagged rather than thrown.
+ */
+declare function prepareCentrifugeBuy(params: PrepareCentrifugeBuyParams): Promise<CentrifugeBuyPreparationResult>;
+/** Progress phases emitted by {@link placeCentrifugeRequest}, in order. */
+type CentrifugeBuyPlacementPhase = 'broadcasting-request' | 'confirming-request';
+/**
+ * A step-tagged reason {@link placeCentrifugeRequest} failed.
+ *
+ * `request-expired` is a refusal to broadcast: the deadline is inside the
+ * calldata, so sending it would revert and cost gas. A null deadline never
+ * takes this arm.
+ *
+ * `request` means the wallet never sent it, so placing again is safe.
+ * `request-unconfirmed` means it was sent and the receipt wait failed: the
+ * deposit may still mine, and placing again can queue a second one.
+ */
+type CentrifugeBuyPlacementError = {
+    step: 'request-expired';
+} | {
+    step: 'request';
+    cause: WalletError;
+} | {
+    step: 'request-unconfirmed';
+    txHash: Hash;
+    cause: WalletError;
+} | {
+    step: 'request-reverted';
+};
+type CentrifugeBuyPlacementResult = {
+    type: 'success';
+    txHash: Hash;
+    transaction: CentrifugeVaultBuyTransaction;
+} | {
+    type: 'error';
+    error: CentrifugeBuyPlacementError;
+};
+type PlaceCentrifugeRequestParams = {
+    wallet: EvmWallet;
+    /**
+     * The request to place, from {@link prepareCentrifugeBuy}. Broadcasting it
+     * queues the deposit. It does not buy shares.
+     */
+    transaction: CentrifugeVaultBuyTransaction;
+    /** The chain it was built for. The response does not say. */
+    chain: EthereumChain;
+    /**
+     * Now, as the caller sees it. A parameter so the expiry check is testable.
+     */
+    now?: Date;
+    onProgress?: (phase: CentrifugeBuyPlacementPhase) => void;
+};
+/**
+ * Broadcasts a built deposit request and waits for it to mine.
+ *
+ * A transaction with no deadline (`expiresAt === null`) is broadcast as-is.
+ * One with a deadline that has passed is refused before the wallet is asked.
+ */
+declare function placeCentrifugeRequest(params: PlaceCentrifugeRequestParams): Promise<CentrifugeBuyPlacementResult>;
+/**
+ * Every phase {@link buyCentrifuge} can emit, in order. An allowance that
+ * already covers the deposit skips the approval phases.
+ */
+type CentrifugeBuyPhase = CentrifugeBuyPreparationPhase | CentrifugeBuyPlacementPhase;
+/** A step-tagged reason {@link buyCentrifuge} failed. The step says which half. */
+type CentrifugeBuyError = CentrifugeBuyPreparationError | CentrifugeBuyPlacementError;
+type CentrifugeBuyResult = {
+    type: 'success';
+    txHash: Hash;
+    transaction: CentrifugeVaultBuyTransaction;
+} | {
+    type: 'error';
+    error: CentrifugeBuyError;
+};
+type BuyCentrifugeParams = Omit<PrepareCentrifugeBuyParams, 'onProgress'> & Pick<PlaceCentrifugeRequestParams, 'now'> & {
+    onProgress?: (phase: CentrifugeBuyPhase) => void;
+};
+/**
+ * Places a deposit request end to end: approves the vault proxy for `amount`,
+ * builds the calldata, and broadcasts it.
+ *
+ * The one call for a partner driving this from their own screen. The checkout
+ * keeps the two halves, because it has to drop a build that finishes after
+ * the user has left and must not broadcast it.
+ *
+ * Success means the request was placed. The fund fulfils it later.
+ * Broadcasting it does not buy shares.
+ *
+ * Total: every failure is returned step-tagged rather than thrown.
+ */
+declare function buyCentrifuge(params: BuyCentrifugeParams): Promise<CentrifugeBuyResult>;
+
+/** Progress phases emitted by {@link claimCentrifugeVault}, in order. */
+type CentrifugeClaimPhase = 'preparing' | 'awaiting-wallet' | 'confirming';
+/**
+ * A step-tagged reason a claim failed.
+ *
+ * `prepare` reasons are split out where the remedy differs: a wallet with
+ * nothing to claim has already been paid (a fill was claimed elsewhere, or a
+ * new request auto-claimed it), and a frozen wallet needs the issuer, not a
+ * retry. Everything else at that step is offered a retry.
+ *
+ * A mined transaction that reverted is a `confirm` failure carrying a
+ * `contract_reverted` cause, so a caller switches on one arm for "the chain
+ * said no" whether the wallet or the receipt reported it.
+ */
+type CentrifugeClaimError = {
+    step: 'prepare';
+    reason: 'nothing-to-claim' | 'frozen' | 'generic';
+} | {
+    step: 'broadcast';
+    cause: WalletError;
+} | {
+    step: 'confirm';
+    cause: WalletError;
+};
+type CentrifugeClaimResult = {
+    type: 'success';
+    direction: CentrifugeClaimDirection;
+    txHash: Hash;
+    /**
+     * What the calldata was built to collect: shares for `invest`, the
+     * funding token for `redeem`. A floor rather than an exact figure - a
+     * fill landing before the broadcast raises it, and the claim collects
+     * everything.
+     */
+    claimed: BlockchainAmount;
+} | {
+    type: 'error';
+    error: CentrifugeClaimError;
+};
+type ClaimCentrifugeVaultParams = {
+    centrifuge: CentrifugeNamespace;
+    /**
+     * The wallet that holds the position, and the one that broadcasts: the
+     * proxy credits the sender, so no other wallet can claim for it.
+     */
+    wallet: EvmWallet;
+    chain: EthereumChain;
+    /** Share token symbol of the vault, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    direction: CentrifugeClaimDirection;
+    onProgress?: (phase: CentrifugeClaimPhase) => void;
+};
+/**
+ * Claims everything a wallet has claimable on one side of a vault: builds the
+ * calldata, broadcasts it from that wallet and waits for it to mine.
+ *
+ * One function for both directions because the API forks only at the build
+ * step - `/claim` and `/claim-proceeds` are two endpoints - while broadcasting
+ * reads calldata and nothing else. Total: every failure comes back as a step
+ * tag rather than a throw.
+ *
+ * Nothing is approved first. A claim moves tokens out of the proxy, not out of
+ * the wallet, so there is no allowance to grant.
+ */
+declare function claimCentrifugeVault(params: ClaimCentrifugeVaultParams): Promise<CentrifugeClaimResult>;
+
+/**
+ * The Centrifuge namespace plus the halves of a vault trade that need a
+ * wallet - placing a request and claiming what a fill made claimable - and so
+ * cannot live on the shared namespace.
+ *
+ * {@link ClientCentrifugeNamespace.buy} is the one call: approve, build, and
+ * 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.
+ */
+interface ClientCentrifugeNamespace extends CentrifugeNamespace {
+    /**
+     * Approves the vault proxy for `amount`, builds the request, and broadcasts
+     * it. Returns a step-tagged result rather than throwing.
+     *
+     * Success means the request was placed. The fund fulfils it later.
+     */
+    buy(params: Omit<BuyCentrifugeParams, 'centrifuge' | 'erc20'>): Promise<CentrifugeBuyResult>;
+    /**
+     * Approves the vault proxy to pull `amount` of the funding token, then
+     * builds the request that spends it. Returns a step-tagged result rather
+     * than throwing.
+     */
+    prepareBuy(params: Omit<PrepareCentrifugeBuyParams, 'centrifuge' | 'erc20'>): Promise<CentrifugeBuyPreparationResult>;
+    /**
+     * Broadcasts a built request and waits for it to mine, refusing one whose
+     * deadline has passed. Returns a step-tagged result rather than throwing.
+     *
+     * Success means the request was placed. The fund fulfils it later.
+     */
+    placeRequest(params: PlaceCentrifugeRequestParams): Promise<CentrifugeBuyPlacementResult>;
+    /**
+     * Claims everything the wallet has claimable on one side of the vault and
+     * waits for it to mine. Returns a step-tagged result rather than throwing.
+     */
+    claim(params: Omit<ClaimCentrifugeVaultParams, 'centrifuge'>): Promise<CentrifugeClaimResult>;
+}
+declare class ClientCentrifugeNamespaceImpl extends CentrifugeNamespaceImpl implements ClientCentrifugeNamespace {
+    private readonly erc20;
+    constructor(ctx: UniversalNamespaceContext, erc20: Erc20Namespace);
+    buy(params: Omit<BuyCentrifugeParams, 'centrifuge' | 'erc20'>): Promise<CentrifugeBuyResult>;
+    prepareBuy(params: Omit<PrepareCentrifugeBuyParams, 'centrifuge' | 'erc20'>): Promise<CentrifugeBuyPreparationResult>;
+    placeRequest(params: PlaceCentrifugeRequestParams): Promise<CentrifugeBuyPlacementResult>;
+    claim(params: Omit<ClaimCentrifugeVaultParams, 'centrifuge'>): Promise<CentrifugeClaimResult>;
+}
+
 /**
  * Progress phases emitted by {@link executeTokenSale}, in the order they occur.
  * The `resetting-allowance`/`confirming-allowance-reset` phases only occur when
@@ -698,10 +959,24 @@ declare class ClientSupportNamespaceImpl implements ClientSupportNamespace {
 
 interface ClientConfig extends Config {
     /**
-     * The SDK user must provide this function. It is responsible for fetching a
-     * valid {@link OAuthAccessToken}, or **null** for logged-out users. If your
-     * backend is in TypeScript, it is recommended to use
-     * `CoinListServer#auth.getAccessToken` from `@/server/core/coinlist-server`.
+     * The SDK user must provide this function. It fetches a valid
+     * {@link OAuthAccessToken} from your backend. If your backend is in
+     * TypeScript, serve `CoinListServer#auth.getAccessToken` from it.
+     *
+     * Two answers, and they must not be confused:
+     *
+     * - **Resolve `null`** when there is no session - e.g. your endpoint
+     *   answered 204. After a 401 the SDK asks once more a second later before
+     *   it believes it, then signs the user out and calls
+     *   {@link Config.onSessionExpired}.
+     * - **Throw** when you could not find out - a 5xx, a network failure. The
+     *   SDK keeps its current auth state and fails only the request in hand.
+     *
+     * So a backend that answers "no session" for its own failures turns every
+     * outage into a logout. Map those to an error status and throw on it.
+     *
+     * The SDK calls this at most once at a time: concurrent requests that all
+     * need a new token share one call.
      */
     getAccessToken: () => Promise<OAuthAccessToken | null>;
     /**
@@ -790,6 +1065,15 @@ interface CoinListClient {
      * {@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.
+     */
+    readonly centrifuge: ClientCentrifugeNamespace;
     /**
      * Token display metadata (name, symbol, decimals, logos) from CoinList's
      * public token registry, keyed by chain + contract address — e.g.
@@ -810,6 +1094,10 @@ interface CoinListClient {
      * the user's {@link AuthState}. This is called automatically by
      * {@link CoinListProvider}; you typically do not need to call it yourself
      * unless you are using the client outside of the provider.
+     *
+     * @throws whatever {@link ClientConfig.getAccessToken} throws. The auth
+     * state is then left as it was (`'unknown'` on a first call), since a
+     * failure to find out is not a logout.
      */
     init(): Promise<AuthState>;
 }
@@ -879,7 +1167,7 @@ type CoinListStyleScopeProps = {
 declare function CoinListStyleScope({ children }: CoinListStyleScopeProps): react.JSX.Element;
 
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "primary" | "gradient" | "secondary" | "destructive" | "ghost" | "destructiveLink" | null | undefined;
+    variant?: "link" | "primary" | "gradient" | "secondary" | "destructive" | "outline" | "ghost" | "destructiveLink" | null | undefined;
     size?: "default" | "sm" | "lg" | "cta" | "icon" | null | undefined;
     radius?: "pill" | "rounded" | null | undefined;
     fullWidth?: boolean | null | undefined;
@@ -955,6 +1243,23 @@ interface CoinListSignInCardViewProps {
  */
 declare function CoinListSignInCardView({ state, onEvent, className, }: CoinListSignInCardViewProps): 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.
+ */
+type CentrifugeOrderPlaced = {
+    wallet: EvmWallet;
+    /** What the request deposits, in the funding token's base units. */
+    amount: BlockchainAmount;
+    transaction: CentrifugeVaultBuyTransaction;
+    txHash: Hash;
+};
+
 /**
  * A filled Ondo order, as the confirmation dialog and the host's
  * `onOrderConfirmed` callback need it.
@@ -1261,6 +1566,23 @@ type CheckoutSelectableInputAssetUi = {
     rawBalance: bigint;
     selected: boolean;
 };
+/**
+ * One fundable stablecoin as the amount step's pay-with row.
+ *
+ * `balance` is `null` before the first read settles and after one that
+ * failed. It renders as zero; the field above says why the CTA does not
+ * treat that as a genuine empty wallet.
+ *
+ * `selected` is a parameter because a step with one funding asset is always
+ * selected, and a step with several has to say which.
+ */
+declare function toInputAssetUi({ symbol, balance, selected, networkName, locale, }: {
+    symbol: StablecoinSymbol;
+    balance: bigint | null;
+    selected: boolean;
+    networkName: string;
+    locale: string;
+}): CheckoutSelectableInputAssetUi;
 
 /**
  * Step 3 of the Superstate checkout: what the swap comes to, the slippage it
@@ -1499,6 +1821,7 @@ type CheckoutConfigByOfferType = {
     'ondo::swap': OndoCheckoutConfig;
     'superstate::swap': SuperstateCheckoutConfig;
     'coinlist::token_sale': CoinListTokenSaleCheckoutConfig;
+    'centrifuge::vault': CentrifugeVaultCheckoutConfig;
 };
 type OndoCheckoutConfig = {
     /**
@@ -1566,13 +1889,42 @@ type SuperstateCheckoutConfig = {
 type CoinListTokenSaleCheckoutConfig = {
     render: (offer: CoinListTokenSaleOfferDetail) => ReactNode;
 };
+/**
+ * What a Centrifuge vault deposit needs that the offer cannot tell it.
+ *
+ * The share symbol is per-asset and this config is per-integration, so
+ * `symbol` takes the offer. It is called only for a `centrifuge::vault`
+ * offer, when that branch is mounted.
+ */
+type CentrifugeVaultCheckoutConfig = {
+    /**
+     * The share token symbol, e.g. `deJTRSY`.
+     *
+     * The SDK cannot read it off the offer: the symbol a vault trades under is
+     * the provider's, and it can disagree with `offer.asset.code`. A host whose
+     * catalogue does agree can return `AssetSymbol(offer.asset.code)`.
+     */
+    symbol: (offer: CentrifugeVaultOfferDetail) => AssetSymbol;
+    /**
+     * The fund the token tracks. Frontline does not send this yet. Omit it, or
+     * return `null`, and the asset-details row stays hidden.
+     */
+    underlyingFund?: (offer: CentrifugeVaultOfferDetail) => string | null;
+    /**
+     * Trailing yield as display copy, e.g. `3.60%`. Omit it, or return `null`,
+     * and the corner stays empty.
+     */
+    apy?: (offer: CentrifugeVaultOfferDetail) => string | null;
+    /** Fired once the request has mined. The dialog shows either way. */
+    onOrderPlaced?: (order: CentrifugeOrderPlaced) => void;
+};
 /**
  * The parts of {@link CheckoutConfig} only the host can know.
  *
  * What is missing from this list is what {@link defaultCheckoutConfig} can fill
  * in on its own.
  */
-type RequiredCheckoutConfig = Pick<CheckoutConfig, 'ondo::swap' | 'coinlist::token_sale'>;
+type RequiredCheckoutConfig = Pick<CheckoutConfig, 'ondo::swap' | 'coinlist::token_sale' | 'centrifuge::vault'>;
 /**
  * Fills in the config entries that have a sensible default, so a host only
  * writes the ones that do not.
@@ -1588,6 +1940,9 @@ type RequiredCheckoutConfig = Pick<CheckoutConfig, 'ondo::swap' | 'coinlist::tok
  *     side: () => 'buy',
  *   },
  *   'coinlist::token_sale': { render: (offer) => <MyTokenSalePage offer={offer} /> },
+ *   'centrifuge::vault': {
+ *     symbol: (offer) => AssetSymbol(offer.asset.code),
+ *   },
  * });
  * ```
  */
@@ -1677,6 +2032,9 @@ interface CheckoutContainerProps {
  * const config = defaultCheckoutConfig({
  *   'ondo::swap': { symbol: (o) => AssetSymbol(o.asset.code), side: () => 'sell' },
  *   'coinlist::token_sale': { render: (o) => <MyTokenSalePage offer={o} /> },
+ *   'centrifuge::vault': {
+ *     symbol: (offer) => AssetSymbol(offer.asset.code),
+ *   },
  * });
  * ```
  *
@@ -1723,6 +2081,358 @@ interface CheckoutContainerProps {
  */
 declare function CheckoutContainer({ offer, chain, wallets, config, enabled, className, }: CheckoutContainerProps): ReactNode;
 
+/**
+ * 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.
+ */
+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;
+};
+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';
+};
+
+interface CentrifugeBuyAmountViewProps {
+    state: CentrifugeBuyAmountUiState;
+    onEvent: (event: CentrifugeBuyAmountUiEvent) => void;
+    className?: string;
+}
+/**
+ * Step 2 of the Centrifuge checkout. Pure: amounts arrive already formatted, and
+ * every interaction leaves through `onEvent`.
+ *
+ * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
+ * needed around it.
+ */
+declare function CentrifugeBuyAmountView(props: CentrifugeBuyAmountViewProps): ReactNode;
+
+interface CentrifugeBuyCheckoutContainerProps {
+    /** The vault being deposited into: names the asset and supplies its logo. */
+    offer: CentrifugeVaultOfferDetail;
+    /** Share token symbol, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    wallets: CheckoutWalletSelection;
+    /**
+     * Default `true`. `false` turns off every request and timer, for a checkout
+     * that is mounted but not on screen yet.
+     */
+    enabled?: boolean;
+    /** Fired once the request has mined. The dialog shows either way. */
+    onOrderPlaced?: (order: CentrifugeOrderPlaced) => void;
+    /**
+     * The fund the token tracks, e.g. `Janus Henderson Treasury Fund`.
+     * Frontline does not send this yet, so pass `null` and the row stays hidden.
+     */
+    underlyingFund: string | null;
+    /**
+     * Trailing yield as display copy, e.g. `3.60%`. Frontline does not send
+     * this yet, so pass `null` and the corner stays empty.
+     */
+    apy: string | null;
+    className?: string;
+}
+/**
+ * The Centrifuge buy checkout a host mounts.
+ *
+ * Renders {@link CentrifugeBuyCheckoutView} from
+ * {@link useCentrifugeBuyCheckoutViewModel}. Placing a request does not buy
+ * shares. The fund fulfils it later.
+ */
+declare function CentrifugeBuyCheckoutContainer({ offer, symbol, chain, wallets, enabled, onOrderPlaced, underlyingFund, apy, className, }: CentrifugeBuyCheckoutContainerProps): ReactNode;
+
+/**
+ * Step 3 of the Centrifuge checkout: confirming the deposit and placing it.
+ *
+ * Placing the request does not buy shares. The fund prices the fill later.
+ */
+type CentrifugeBuyReviewUiState = {
+    type: 'incomplete';
+} | {
+    type: 'active';
+    /** The funding token, shown beside the amount being deposited. */
+    inputAsset: CheckoutAssetUi;
+    /** What the request deposits, e.g. `100.00 USDC`. */
+    investAmount: FormattedAmountAssetUi;
+    /** Where the shares land — the wallet confirmed in step 1. */
+    recipientAddress: ShortenedWalletAddress;
+    /**
+     * Always a formatted zero. This product charges no CoinList fee, and
+     * the row stays so the total is the amount invested.
+     */
+    coinlistFee: FormattedAmountAssetUi;
+    /** What the user pays. Equal to {@link investAmount}: no fee comes off. */
+    total: FormattedAmountAssetUi;
+    placeRequestCta: CheckoutCtaUi;
+    error: string | null;
+};
+type CentrifugeBuyReviewUiEvent = {
+    type: 'ON_PLACE_REQUEST';
+};
+
+/**
+ * Why a Centrifuge checkout cannot run right now, as opposed to a step of it
+ * failing.
+ */
+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.
+ */
+'unsupported-chain'
+/**
+ * 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.
+ */
+ | 'not-orderable';
+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;
+};
+
+/**
+ * The asset panel beside the Centrifuge checkout.
+ *
+ * Read-only. The identity and the minimum come from the offer. Yield and
+ * the fund the token tracks are `null` until frontline publishes them, and
+ * a `null` hides its row.
+ */
+type CentrifugeSidebarUiState = {
+    asset: CheckoutAssetUi;
+    /** The share token's symbol, e.g. `deJTRSY`. The same one under the name. */
+    ticker: string;
+    /**
+     * The fund the token tracks, e.g. `Janus Henderson Treasury Fund`.
+     * Frontline does not publish this yet. `null` hides the row.
+     */
+    underlyingFund: string | null;
+    /**
+     * What kind of instrument it is, in the supplier's own vocabulary, e.g.
+     * `Tokenized Notes`. `null` hides the row.
+     */
+    assetType: string | null;
+    minimumInvestment: CentrifugeSidebarMinimumUi;
+    /** Display name of the chain the token lives on, e.g. `Ethereum`. */
+    networkName: string;
+    /** Who issues the token, e.g. `Centrifuge`. `null` hides the row. */
+    issuer: string | null;
+    /**
+     * Trailing yield, already formatted, e.g. `3.60%`. The caption "APY" is
+     * the view's. Frontline does not publish this yet. `null` leaves the
+     * corner empty.
+     */
+    apy: FormattedPercentUi | null;
+};
+/**
+ * The minimum deposit, from the offer.
+ *
+ * A vault that sets no minimum is `none`: the row is dropped rather than
+ * dashed. `loading` stays for a caller that has not resolved the offer yet.
+ */
+type CentrifugeSidebarMinimumUi = {
+    type: 'loading';
+} | {
+    type: 'known';
+    amount: FormattedAmountAssetUi;
+} | {
+    type: 'none';
+};
+
+/**
+ * Step 1 of the Centrifuge checkout: which wallet funds the deposit.
+ *
+ * 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.
+ *
+ * Nothing is allow-listed: the user picks a wallet and confirms, and confirming
+ * is synchronous. Hence a plain `confirmEnabled`.
+ */
+type CentrifugeWalletSelectUiState = {
+    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 CentrifugeWalletSelectUiEvent = {
+    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 Centrifuge buy checkout: three steps, the asset panel, and the
+ * dialog that says the request was placed.
+ */
+type CentrifugeBuyCheckoutUiState = {
+    type: 'content';
+    wallet: CentrifugeWalletSelectUiState;
+    amount: CentrifugeBuyAmountUiState;
+    review: CentrifugeBuyReviewUiState;
+    sidebar: CentrifugeSidebarUiState;
+    orderPlaced: CentrifugeOrderPlacedUiState;
+} | {
+    type: 'error';
+    reason: CentrifugeCheckoutErrorReason;
+};
+type CentrifugeBuyCheckoutUiEvent = CentrifugeWalletSelectUiEvent | CentrifugeBuyAmountUiEvent | CentrifugeBuyReviewUiEvent | CentrifugeOrderPlacedUiEvent;
+/**
+ * The dialog that closes the checkout once the request has mined.
+ *
+ * It reports that the request was placed. It does not report a fill.
+ */
+type CentrifugeOrderPlacedUiState = {
+    type: 'hidden';
+} | {
+    type: 'visible';
+    outputAsset: CheckoutAssetUi;
+    totalCost: FormattedAmountAssetUi;
+    recipientAddress: ShortenedWalletAddress;
+    txExplorerUrl: TxExplorerUrl;
+};
+type CentrifugeOrderPlacedUiEvent = {
+    type: 'ON_CLOSE_ORDER_PLACED';
+};
+
+interface CentrifugeBuyCheckoutViewProps {
+    state: CentrifugeBuyCheckoutUiState;
+    onEvent: (event: CentrifugeBuyCheckoutUiEvent) => void;
+    className?: string;
+}
+/**
+ * The whole Centrifuge buy checkout: three step cards, the asset panel, and
+ * the dialog that says the request was placed.
+ *
+ * The panel leads on a phone and moves to the right column from `md` up.
+ */
+declare function CentrifugeBuyCheckoutView({ state, onEvent, className, }: CentrifugeBuyCheckoutViewProps): ReactNode;
+
+interface CentrifugeBuyOrderPlacedProps {
+    state: CentrifugeOrderPlacedUiState;
+    onEvent: (event: CentrifugeOrderPlacedUiEvent) => void;
+    className?: string;
+}
+/**
+ * The dialog that closes the checkout once the request has mined.
+ *
+ * It says the request was placed. The fund fulfils it later.
+ */
+declare function CentrifugeBuyOrderPlaced({ state, onEvent, className, }: CentrifugeBuyOrderPlacedProps): ReactNode;
+
+interface CentrifugeBuyReviewViewProps {
+    state: CentrifugeBuyReviewUiState;
+    onEvent: (event: CentrifugeBuyReviewUiEvent) => void;
+    className?: string;
+}
+/**
+ * Step 3 of the Centrifuge checkout. Pure: every number arrives formatted, and
+ * whether the order can be placed is decided by `placeRequestCta`.
+ *
+ * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
+ * needed around it.
+ */
+declare function CentrifugeBuyReviewView(props: CentrifugeBuyReviewViewProps): ReactNode;
+
+interface CentrifugeCheckoutErrorProps {
+    reason: CentrifugeCheckoutErrorReason;
+    className?: string;
+}
+/**
+ * What the checkout renders when there is no deposit to place, or the vault
+ * is known to be unable to take one.
+ */
+declare function CentrifugeCheckoutError({ reason, className, }: CentrifugeCheckoutErrorProps): ReactNode;
+
+interface CentrifugeSidebarViewProps {
+    state: CentrifugeSidebarUiState;
+    className?: string;
+}
+/**
+ * The asset panel beside the Centrifuge checkout. Read-only.
+ */
+declare function CentrifugeSidebarView({ state, className, }: CentrifugeSidebarViewProps): ReactNode;
+
+interface CentrifugeWalletSelectViewProps {
+    state: CentrifugeWalletSelectUiState;
+    onEvent: (event: CentrifugeWalletSelectUiEvent) => void;
+    /**
+     * The line under the heading. Defaults to the buy copy.
+     *
+     * A plain string rather than a slot: the sentence says what the wallet is for.
+     */
+    description?: string;
+    className?: string;
+}
+/**
+ * The wallet step of a Centrifuge checkout: which wallet funds the deposit.
+ * Pure - the wallets arrive already shaped, and every interaction leaves
+ * through `onEvent`.
+ *
+ * Nothing about choosing a wallet is allow-listed: confirming is a local
+ * decision. The sentence under the heading is the only copy that names what
+ * the wallet is for.
+ *
+ * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
+ * needed around it.
+ */
+declare function CentrifugeWalletSelectView(props: CentrifugeWalletSelectViewProps): ReactNode;
+
 /**
  * Step 2 of the Ondo checkout: how much to spend, and which asset to spend.
  *
@@ -1863,18 +2573,17 @@ type OndoBuyReviewUiEvent = {
 };
 
 /**
- * Why an Ondo checkout cannot run at all, as opposed to a step of it failing.
+ * Why an Ondo checkout cannot run right now, as opposed to a step of it
+ * failing.
  *
- * One arm today, and a union rather than a bare flag because the View switches
- * on it for copy and because the next entry here is already foreseeable: an
- * offer whose asset Ondo has delisted is the same kind of "there is no flow to
- * render" that no step can localise.
+ * A union rather than a bare flag because the View switches on it for copy.
  *
- * Shared by both products because it is a property of the integration rather
- * than of a direction: buying and selling go through the same contract, so a
- * chain that cannot serve one cannot serve the other. That is the exception
- * the provider-level `shared/` exists for, and it is narrow - the step states
- * below stay per-product, since that is where the two genuinely diverge.
+ * 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
+ * the same contract, so a chain that cannot serve one cannot serve the other,
+ * and a closed market reads the same whichever way the trade runs. That is the
+ * 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 = 
 /**
@@ -1885,7 +2594,38 @@ type OndoCheckoutErrorReason =
  * offer and the chain are fixed for the lifetime of the mount. See
  * `swapSpender`.
  */
-'unsupported-chain';
+'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;
+};
 
 /**
  * The reference panel beside the Ondo checkout: which asset is being bought,
@@ -2030,7 +2770,11 @@ type OndoBuyCheckoutUiState = {
     sidebar: OndoSidebarUiState;
     orderConfirmed: OndoOrderConfirmedUiState;
 }
-/** There is no checkout to render. Nothing is fetched and no timer runs. */
+/**
+ * There is no checkout to render. For `unsupported-chain` nothing is fetched
+ * and no timer runs; for `not-tradable` the trading-status poll keeps
+ * running, so the checkout comes back once the market opens.
+ */
  | {
     type: 'error';
     reason: OndoCheckoutErrorReason;
@@ -2451,7 +3195,11 @@ type OndoSellCheckoutUiState = {
     sidebar: OndoSidebarUiState;
     orderConfirmed: OndoSellOrderConfirmedUiState;
 }
-/** There is no checkout to render. Nothing is fetched and no timer runs. */
+/**
+ * There is no checkout to render. For `unsupported-chain` nothing is fetched
+ * and no timer runs; for `not-tradable` the trading-status poll keeps
+ * running, so the checkout comes back once the market opens.
+ */
  | {
     type: 'error';
     reason: OndoCheckoutErrorReason;
@@ -2647,7 +3395,8 @@ interface OndoCheckoutErrorProps {
     className?: string;
 }
 /**
- * What an Ondo checkout renders when there is no checkout to render.
+ * What an Ondo checkout renders when there is no checkout to render, or none
+ * the user can act on right now.
  *
  * Shared by both products rather than duplicated in each, because the reason
  * is a property of the integration and not of the direction: a chain that
@@ -2655,9 +3404,10 @@ interface OndoCheckoutErrorProps {
  * sentence twice.
  *
  * No retry, deliberately. Superstate's equivalent offers one for `load-failed`,
- * where a re-fetch can genuinely succeed; every reason here is settled at mount
- * and cannot change under a button. Offering one that provably cannot help is
- * worse than offering none.
+ * where a re-fetch can genuinely succeed. Here `unsupported-chain` is settled
+ * at mount and cannot change under a button, and `not-tradable` clears on its
+ * own once the market opens, since the viewmodel keeps polling underneath it.
+ * Offering a button that provably cannot help is worse than offering none.
  *
  * Self-scoped, like every exported component: it renders fully styled with no
  * provider in the tree, and the scope is idempotent so nesting costs nothing.
@@ -2977,8 +3727,6 @@ type SuperstateOrderConfirmedUiState = {
     type: 'visible';
     /** What was bought. */
     asset: CheckoutAssetUi;
-    /** Who issues it, e.g. `Superstate`. */
-    issuer: string;
     /** How much of it arrived, e.g. `981.2431 USTB`. */
     outputAmount: FormattedAmountAssetUi;
     /**
@@ -3186,7 +3934,329 @@ interface SuperstateWalletViewProps {
  * Self-scoped: renders fully styled on its own, with no `CoinListStyleScope`
  * needed around it.
  */
-declare function SuperstateWalletView(props: SuperstateWalletViewProps): ReactNode;
+declare function SuperstateWalletView(props: SuperstateWalletViewProps): ReactNode;
+
+/**
+ * The claim card.
+ *
+ * `HIDDEN` renders nothing: the user is signed out, or there is nothing to
+ * show and no wallet to connect. A host that wants an empty state can tell
+ * both apart itself.
+ */
+type CentrifugeVaultClaimUiState = {
+    type: 'HIDDEN';
+} | {
+    type: 'LOADING';
+    externalWallet: ClaimExternalWalletUi;
+} | {
+    type: 'ERROR';
+    externalWallet: ClaimExternalWalletUi;
+} | {
+    type: 'CONTENT';
+    rows: CentrifugeClaimRowUi[];
+    externalWallet: ClaimExternalWalletUi;
+    dialog: CentrifugeClaimDialogUi;
+};
+type CentrifugeVaultClaimUiEvent = {
+    type: 'ON_CLAIM';
+    legId: CentrifugeVaultLegId;
+} | {
+    type: 'ON_RETRY_CLAIM';
+} | {
+    type: 'ON_CLOSE_CLAIM_DIALOG';
+} | {
+    type: 'ON_RETRY_LOAD';
+} | {
+    type: 'ON_CONNECT_WALLET';
+} | {
+    type: 'ON_CHANGE_WALLET';
+};
+/** Why a claimable row cannot be claimed right now. */
+type CentrifugeClaimBlockedReasonUi = 'vault-paused' | 'wallet-frozen';
+/**
+ * What a claimable row's Claim button does. `claiming` while a claim on the
+ * row has not settled, including one whose dialog was closed: the
+ * transaction is still in the wallet or the mempool, and a second press
+ * would send another.
+ */
+type CentrifugeClaimActionUi = {
+    type: 'enabled';
+} | {
+    type: 'claiming';
+} | {
+    type: 'blocked';
+    reason: CentrifugeClaimBlockedReasonUi;
+};
+/**
+ * A row of the card. A leg yields a `pending` row while anything is queued
+ * and a `claimable` row while anything is filled, so one wallet can show
+ * both at once.
+ *
+ * The two kinds lay out differently on purpose: a pending row names the
+ * offer and what is queued, a claimable row leads with what the user gets.
+ */
+type CentrifugeClaimRowUi = {
+    kind: 'pending';
+    /** Unique within the card, for React keys. */
+    key: string;
+    iconUrl: AssetIconUrl | null;
+    /** The offer's name, e.g. `JTRSY deRWA`. */
+    title: string;
+    /** What is queued: funding for `invest`, shares for `redeem`. */
+    amount: FormattedAmountAssetUi;
+    wallet: string;
+} | {
+    kind: 'claimable';
+    key: string;
+    legId: CentrifugeVaultLegId;
+    iconUrl: AssetIconUrl | null;
+    /**
+     * What a claim pays out: exact shares for `invest`, an estimate of the
+     * funding token (prefixed `~`) for `redeem`.
+     */
+    amount: FormattedAmountAssetUi;
+    wallet: string;
+    action: CentrifugeClaimActionUi;
+};
+/** A connect or change request the host's connector is handling. */
+type ExternalWalletRequestUi = 'idle' | 'pending' | 'failed';
+/**
+ * The card's footer. `hidden` when the host offers no connector, so there is
+ * nothing to connect with.
+ */
+type ClaimExternalWalletUi = {
+    type: 'hidden';
+} | {
+    type: 'disconnected';
+    request: ExternalWalletRequestUi;
+} | {
+    type: 'connected';
+    wallet: string;
+    request: ExternalWalletRequestUi;
+};
+/** The steps a claim goes through, in order, as the dialog lists them. */
+type CentrifugeClaimStepUi = 'preparing' | 'awaiting-wallet' | 'confirming';
+/** Why a claim failed, in the flavours the dialog words differently. */
+type CentrifugeClaimFailureUi = 'nothing-to-claim' | 'wallet-frozen' | 'rejected' | 'insufficient-gas' | 'reverted' | 'generic';
+type CentrifugeClaimProgressUi = {
+    type: 'running';
+    step: CentrifugeClaimStepUi;
+} | {
+    type: 'failed';
+    step: CentrifugeClaimStepUi;
+    reason: CentrifugeClaimFailureUi;
+    /**
+     * Whether the dialog offers "Try again". `nothing-to-claim` has already
+     * been paid and `wallet-frozen` needs the issuer, so retrying either only
+     * repeats the refusal.
+     */
+    retryable: boolean;
+} | {
+    type: 'succeeded';
+    claimed: FormattedAmountAssetUi;
+    explorerUrl: TxExplorerUrl;
+};
+type CentrifugeClaimDialogUi = {
+    type: 'closed';
+} | {
+    type: 'open';
+    /** What the claim pays out, which the dialog's title names. */
+    amount: FormattedAmountAssetUi;
+    progress: CentrifugeClaimProgressUi;
+};
+
+interface UseCentrifugeVaultClaimViewModelOptions {
+    offer: CentrifugeVaultOfferDetail;
+    wallets: WalletSelection;
+    /** Names a wallet for display; unnamed ones show a shortened address. */
+    walletLabel?: WalletLabelResolver;
+    /** Fired once a claim has mined, whether or not the dialog is still open. */
+    onClaimed?: (claim: CentrifugeVaultClaimed) => void;
+    /** How often to re-read pending positions and vault status. */
+    pollInterval?: Seconds;
+    /** Default `true`. `false` turns off every request and timer. */
+    enabled?: boolean;
+}
+interface UseCentrifugeVaultClaimViewModelResult {
+    state: CentrifugeVaultClaimUiState;
+    onEvent: (event: CentrifugeVaultClaimUiEvent) => void;
+}
+/**
+ * What a host hears once a claim has mined. `claimed` is what the calldata
+ * was built to collect: shares for `invest`, the funding token for `redeem`.
+ */
+type CentrifugeVaultClaimed = {
+    direction: CentrifugeClaimDirection;
+    chain: EthereumChain;
+    walletAddress: EvmWalletAddress;
+    txHash: Hash;
+    claimed: BlockchainAmount;
+};
+/**
+ * The Centrifuge claim card: every wallet's pending and claimable positions on
+ * an offer's vaults, and the claim that collects a filled one.
+ *
+ * The vaults come from the offer's `vaultContracts`, each chain's share and
+ * funding token resolved through the token registry; a chain whose tokens the
+ * registry does not list is left out and logged. Positions are read for every
+ * wallet the host supplied, on both legs, and polled while anything is
+ * pending. Vault status gates the Claim button, and is polled while the page
+ * is visible.
+ *
+ * A claim runs in a dialog that tracks its steps. It is broadcast from the
+ * wallet that holds the row - the proxy credits the sender - and on success
+ * every position is read again, so the claimed amount leaves the card.
+ */
+declare function useCentrifugeVaultClaimViewModel({ offer, wallets, walletLabel, onClaimed, pollInterval, enabled, }: UseCentrifugeVaultClaimViewModelOptions): UseCentrifugeVaultClaimViewModelResult;
+
+/**
+ * Everything `ClaimContainer` needs that the offer cannot tell it, keyed by
+ * the async offer type it belongs to.
+ *
+ * Keyed by {@link AsyncOfferType} with every key required, for the same reason
+ * as `CheckoutConfig`: a host rendering `ClaimContainer` is saying it will
+ * handle whatever async offer it is given, so a new async provider is a
+ * compile error in every host rather than a card that silently renders
+ * nothing. Per-integration, not per-offer: a host builds it once.
+ */
+type ClaimConfig = {
+    [K in AsyncOfferType]: ClaimConfigByOfferType[K];
+};
+/**
+ * What each async offer type needs, before {@link ClaimConfig} maps
+ * `AsyncOfferType` over it. Private, so a new member of `AsyncOfferDetail`
+ * with no entry here fails to index this type in the SDK first.
+ */
+type ClaimConfigByOfferType = {
+    'centrifuge::vault': CentrifugeVaultClaimConfig;
+};
+/**
+ * Centrifuge needs nothing required today: the vaults come from the offer and
+ * the token registry. The key still has to be supplied, so that the day it
+ * does need something the omission is a compile error.
+ */
+type CentrifugeVaultClaimConfig = {
+    /** Fired once a claim has mined. The dialog shows either way. */
+    onClaimed?: (claim: CentrifugeVaultClaimed) => void;
+};
+interface ClaimContainerProps {
+    /**
+     * The async offer whose positions 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.
+     */
+    wallets: WalletSelection;
+    /**
+     * Names a wallet for display, e.g. `'CoinList Wallet'` for the embedded
+     * one. Omitted, or returning `null`, shows the shortened address.
+     */
+    walletLabel?: WalletLabelResolver;
+    /** What each async offer type needs beyond the offer itself. */
+    config: ClaimConfig;
+    /**
+     * Default `true`. `false` turns off every request and timer in the mounted
+     * provider, for a card that is on the tree but not on screen yet.
+     */
+    enabled?: boolean;
+    className?: string;
+}
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * Only the matching provider's container is mounted, so its viewmodel is the
+ * only one that runs. The `switch` is exhaustive against
+ * {@link AsyncOfferType}, and the `default` branch assigns to
+ * `const exhaustive: never`, so a new async offer type is a compile error here
+ * as well as in {@link ClaimConfig}.
+ *
+ * ```tsx
+ * {AsyncOfferDetail.is(offer) && (
+ *   <ClaimContainer
+ *     key={offer.id}
+ *     offer={offer}
+ *     wallets={{ embedded, external, externalAdapter }}
+ *     walletLabel={(address) => (isEmbedded(address) ? 'CoinList Wallet' : null)}
+ *     config={{ 'centrifuge::vault': {} }}
+ *   />
+ * )}
+ * ```
+ */
+declare function ClaimContainer({ offer, wallets, walletLabel, config, enabled, className, }: ClaimContainerProps): ReactNode;
+
+interface CentrifugeVaultClaimContainerProps {
+    /** The vault offer whose positions to show: its chains come from `vaultContracts`. */
+    offer: CentrifugeVaultOfferDetail;
+    /** The wallets to read positions for and claim from. */
+    wallets: WalletSelection;
+    /** Names a wallet for display; unnamed ones show a shortened address. */
+    walletLabel?: WalletLabelResolver;
+    /** Fired once a claim has mined. The dialog shows either way. */
+    onClaimed?: (claim: CentrifugeVaultClaimed) => void;
+    /**
+     * Default `true`. `false` turns off every request and timer, for a card
+     * that is mounted but not on screen yet.
+     */
+    enabled?: boolean;
+    className?: string;
+}
+/**
+ * The Centrifuge claim card: every wallet's pending and claimable positions on
+ * a vault offer, polled while anything is pending, and the claim that
+ * collects a filled one.
+ */
+declare function CentrifugeVaultClaimContainer({ offer, wallets, walletLabel, onClaimed, enabled, className, }: CentrifugeVaultClaimContainerProps): ReactNode;
+
+interface CentrifugeVaultClaimDialogProps {
+    dialog: CentrifugeClaimDialogUi;
+    onRetry: () => void;
+    onClose: () => void;
+}
+/**
+ * The dialog a claim runs in: its steps as they happen, the step that broke
+ * and why, or what was claimed.
+ *
+ * Closing it mid-claim is allowed and cancels nothing: a broadcast claim
+ * still mines, and the card refetches when it does.
+ */
+declare function CentrifugeVaultClaimDialog({ dialog, onRetry, onClose, }: CentrifugeVaultClaimDialogProps): ReactNode;
+
+interface CentrifugeVaultClaimRowProps {
+    row: CentrifugeClaimRowUi;
+    /** Asked for when the row is claimable and its Claim button is pressed. */
+    onClaim: () => void;
+}
+/**
+ * One position row of the claim card.
+ *
+ * A pending row names the offer and, on the right, what is queued and from
+ * which wallet. A claimable row leads with what the user gets, and puts the
+ * Claim button where the amount would be. A blocked claim keeps its row and
+ * says why under it, so the user is not left wondering where their claim went.
+ */
+declare function CentrifugeVaultClaimRow({ row, onClaim, }: CentrifugeVaultClaimRowProps): ReactNode;
+
+interface CentrifugeVaultClaimViewProps {
+    state: CentrifugeVaultClaimUiState;
+    onEvent: (event: CentrifugeVaultClaimUiEvent) => void;
+    className?: string;
+}
+/**
+ * The claim card: a wallet's pending and claimable Centrifuge positions, the
+ * footer that connects an external wallet, and the dialog a claim runs in.
+ */
+declare function CentrifugeVaultClaimView({ state, onEvent, className, }: CentrifugeVaultClaimViewProps): ReactNode;
 
 /**
  * One image as an `<img>` renders it: a `src` for a consumer that takes a
@@ -4334,6 +5404,294 @@ interface UseCompleteOAuthOptions {
  */
 declare function useCompleteOAuth(options: UseCompleteOAuthOptions): void;
 
+type CentrifugeBuyAmountConfirmed = {
+    amount: BlockchainAmount;
+    inputAsset: StablecoinSymbol;
+};
+type CentrifugeBuyAmountStepInput = {
+    type: 'incomplete';
+} | {
+    type: 'active';
+    wallet: EvmWallet;
+    /**
+     * Set when the vault is known to be unable to take a request. Unknown
+     * and failed statuses leave this null: they do not block a deposit.
+     */
+    depositBlockedMessage: string | null;
+    /** The offer's minimum, in dollars. `null` when the offer sets none. */
+    minimumPurchaseUsd: number | null;
+} | {
+    type: 'complete';
+    wallet: EvmWallet;
+    amount: BlockchainAmount;
+    inputAsset: StablecoinSymbol;
+};
+interface UseCentrifugeBuyAmountViewModelOptions {
+    stepInput: CentrifugeBuyAmountStepInput;
+    chain: EthereumChain;
+    enabled?: boolean;
+    onComplete: (confirmed: CentrifugeBuyAmountConfirmed) => void;
+    onEdit: () => void;
+}
+interface UseCentrifugeBuyAmountViewModelResult {
+    state: CentrifugeBuyAmountUiState;
+    onEvent: (event: CentrifugeBuyAmountUiEvent) => void;
+}
+/**
+ * Drives step 2: how much to deposit.
+ *
+ * Confirming validates the amount in memory and hands it up. The estimate
+ * for that amount is polled for the review step. Nothing here is signed.
+ */
+declare function useCentrifugeBuyAmountViewModel({ stepInput, chain, enabled, onComplete, onEdit, }: UseCentrifugeBuyAmountViewModelOptions): UseCentrifugeBuyAmountViewModelResult;
+type CentrifugeBuyAmountValidation = {
+    valid: true;
+    amount: BlockchainAmount;
+} | {
+    valid: false;
+    error: string;
+};
+declare function validateCentrifugeBuyAmount({ input, decimals, balance, symbol, minimum, locale, }: {
+    input: string;
+    decimals: AssetDecimals;
+    balance: bigint | null;
+    symbol: AssetSymbol;
+    minimum: BlockchainAmount | null;
+    locale: string;
+}): CentrifugeBuyAmountValidation;
+
+/**
+ * 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.
+ */
+type CentrifugeLoadErrorReason = 'not-authenticated' | 'generic-error';
+declare function centrifugeLoadErrorReason(error: unknown): CentrifugeLoadErrorReason;
+
+/**
+ * The built deposit request a review step can place.
+ *
+ * `isRefreshing` rides on `CONTENT` so a rebuild never blanks the numbers on
+ * screen. A failed rebuild keeps them and says why.
+ */
+type LoadCentrifugeBuyTransactionState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: CentrifugeLoadErrorReason;
+} | {
+    type: 'CONTENT';
+    transaction: CentrifugeVaultBuyTransaction;
+    isRefreshing: boolean;
+    refreshError: CentrifugeLoadErrorReason | null;
+};
+interface UseCentrifugeBuyTransactionOptions {
+    /**
+     * The request to build, or `null` before an amount is confirmed. A `null`
+     * request fetches nothing.
+     */
+    request: BuildCentrifugeVaultBuyParams | null;
+    /**
+     * 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.
+     */
+    data?: CentrifugeVaultBuyTransaction;
+    /** When false, the hook does not build. */
+    enabled: boolean;
+}
+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.
+ */
+declare function useCentrifugeBuyTransaction(options: UseCentrifugeBuyTransactionOptions): UseCentrifugeBuyTransactionResult;
+
+type CentrifugeBuyReviewStepInput = {
+    type: 'incomplete';
+} | {
+    type: 'active';
+    wallet: EvmWallet;
+    amount: BlockchainAmount;
+    inputAsset: StablecoinSymbol;
+    /** Known vault block. Unknown status leaves this null. */
+    depositBlockedMessage: string | null;
+};
+interface UseCentrifugeBuyReviewViewModelOptions {
+    stepInput: CentrifugeBuyReviewStepInput;
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    /** The offer's vault proxies. The spender the approval is written to. */
+    vaultContracts: OfferVaultContract[];
+    /**
+     * When false, placing the request does nothing. Defaults to true.
+     *
+     * The step being `incomplete` is not the same thing: a checkout switched
+     * off mid-flow leaves this step `active`, with the amount still here.
+     */
+    enabled?: boolean;
+    onComplete: (order: CentrifugeOrderPlaced) => void;
+}
+interface UseCentrifugeBuyReviewViewModelResult {
+    state: CentrifugeBuyReviewUiState;
+    onEvent: (event: CentrifugeBuyReviewUiEvent) => void;
+}
+/**
+ * Drives step 3: confirming the deposit and placing the request.
+ *
+ * Placing approves the vault proxy when the allowance is short, builds the
+ * request, and broadcasts it. None of that runs on the amount step, so a
+ * user who edits the amount has not already signed an approval for the old
+ * one.
+ */
+declare function useCentrifugeBuyReviewViewModel({ stepInput, symbol, chain, vaultContracts, enabled, onComplete, }: UseCentrifugeBuyReviewViewModelOptions): UseCentrifugeBuyReviewViewModelResult;
+
+type CentrifugeBuyStep = {
+    type: 'wallet';
+} | {
+    type: 'amount';
+    wallet: EvmWallet;
+} | {
+    type: 'review';
+    wallet: EvmWallet;
+    amount: BlockchainAmount;
+    inputAsset: StablecoinSymbol;
+};
+interface UseCentrifugeBuyCheckoutViewModelOptions {
+    offer: CentrifugeVaultOfferDetail;
+    /** Share token symbol, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    wallets: CheckoutWalletSelection;
+    enabled?: boolean;
+    /** Fired once the request has mined. The dialog shows either way. */
+    onOrderPlaced?: (order: CentrifugeOrderPlaced) => void;
+    /**
+     * The fund the token tracks. Frontline does not send this yet, so pass
+     * `null` and the asset-details row stays hidden.
+     */
+    underlyingFund: string | null;
+    /**
+     * Trailing yield as display copy, e.g. `3.60%`. Frontline does not send
+     * this yet, so pass `null` and the corner stays empty.
+     */
+    apy: string | null;
+}
+interface UseCentrifugeBuyCheckoutViewModelResult {
+    state: CentrifugeBuyCheckoutUiState;
+    onEvent: (event: CentrifugeBuyCheckoutUiEvent) => void;
+}
+/**
+ * Drives the Centrifuge buy checkout.
+ *
+ * The container mounts this hook only. It composes the wallet, amount,
+ * 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.
+ */
+declare function useCentrifugeBuyCheckoutViewModel({ offer, symbol, chain, wallets, enabled, onOrderPlaced, underlyingFund, apy, }: UseCentrifugeBuyCheckoutViewModelOptions): UseCentrifugeBuyCheckoutViewModelResult;
+
+/**
+ * User-facing copy for each `can_order` reason F-0 publishes.
+ *
+ * A record keyed by the closed set, so a new reason fails to compile here
+ * until it has a sentence. The View (or a viewmodel mapping into one) should
+ * render this rather than the wire token.
+ *
+ * Status never returns `below_minimum`. The copy stays so the closed set
+ * still has a sentence for every reason.
+ */
+declare const CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES: Record<CentrifugeOrderReason, string>;
+declare function centrifugeVaultOrderReasonMessage(reason: CentrifugeOrderReason): string;
+/**
+ * The most blocking reason in `reasons`, or `null` when the list is empty.
+ */
+declare function primaryCentrifugeVaultOrderReason<T extends CentrifugeOrderReason>(reasons: readonly T[]): T | null;
+/**
+ * The sentence to show for an {@link CentrifugeOrderability}, or `null` when
+ * the request can proceed.
+ */
+declare function centrifugeVaultOrderingMessage<R extends CentrifugeOrderReason>(orderability: CentrifugeOrderability<R>): string | null;
+
+interface UseCentrifugeSidebarViewModelOptions {
+    offer: CentrifugeVaultOfferDetail;
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    tokenMetadata: TokenMetadata | null;
+    /**
+     * The fund the token tracks. Frontline does not send this yet, so callers
+     * pass `null` and the row stays hidden.
+     */
+    underlyingFund: string | null;
+    /**
+     * Trailing yield as display copy, e.g. `3.60%`. Frontline does not send
+     * this yet, so callers pass `null` and the corner stays empty.
+     */
+    apy: string | null;
+}
+interface UseCentrifugeSidebarViewModelResult {
+    state: CentrifugeSidebarUiState;
+}
+/**
+ * Drives the asset panel beside the Centrifuge checkout.
+ *
+ * The minimum is the offer's. Yield and the underlying fund are arguments:
+ * frontline does not publish either yet, so callers pass `null`.
+ */
+declare function useCentrifugeSidebarViewModel({ offer, symbol, chain, tokenMetadata, underlyingFund, apy, }: UseCentrifugeSidebarViewModelOptions): UseCentrifugeSidebarViewModelResult;
+
+/**
+ * Whether step 1 is being filled in or already answered.
+ *
+ * There is no `incomplete` arm: this is the first step, so it is never waiting
+ * on one above it.
+ */
+type CentrifugeWalletSelectStepInput = {
+    type: 'active';
+} | {
+    type: 'completed';
+    wallet: EvmWallet;
+};
+interface UseCentrifugeWalletSelectViewModelOptions {
+    stepInput: CentrifugeWalletSelectStepInput;
+    /** The host's wallets, and the lambdas that connect and disconnect one. */
+    wallets: CheckoutWalletSelection;
+    /** The chain the order executes on, which names the network on each row. */
+    chain: EthereumChain;
+    /** Called with the wallet the user settled on. */
+    onComplete: (wallet: EvmWallet) => void;
+    /** Called when the user reopens this step from a later one. */
+    onEdit: () => void;
+}
+interface UseCentrifugeWalletSelectViewModelResult {
+    state: CentrifugeWalletSelectUiState;
+    onEvent: (event: CentrifugeWalletSelectUiEvent) => void;
+}
+/**
+ * Drives step 1 of the Centrifuge checkout: which wallet funds the deposit.
+ *
+ * Nothing here touches the network. A wallet is not allow-listed, so confirming
+ * is a local decision the viewmodel makes on its own - which is why the step's
+ * CTA is a plain `confirmEnabled`.
+ *
+ * Connecting an external wallet is the host's job: `connectExternal` opens
+ * whatever connector it ships, and the result is read from `wallets.external`
+ * on the next render rather than from a return value, so a connector that
+ * redirects works as well as one that opens a modal.
+ */
+declare function useCentrifugeWalletSelectViewModel({ stepInput, wallets, chain, onComplete, onEdit, }: UseCentrifugeWalletSelectViewModelOptions): UseCentrifugeWalletSelectViewModelResult;
+
 type LoadParticipationsReason = 'not-authenticated' | 'generic-error';
 type LoadParticipationsState = {
     type: 'LOADING';
@@ -4473,11 +5831,13 @@ declare function validateAmount({ input, decimals, balance, symbol, minimumPurch
 }): OndoBuyAmountValidation;
 
 /**
- * Why an Ondo read failed, in the only two flavours a UI acts on differently.
+ * Why an Ondo read failed, in the three flavours a 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.
+ * in, and because the remedy is one the UI can name. `not-tradable` is split
+ * out for the same reason: the market is closed or paused, so the remedy is to
+ * wait for it to open, and a retry before then fails the same way. Everything
+ * else collapses into `generic-error` and is offered a retry.
  *
  * That is a deliberate over-offer, not a claim that every such failure is
  * retryable. A `ValidationError` from the DTO boundary - an unreadable expiry,
@@ -4488,7 +5848,7 @@ declare function validateAmount({ input, decimals, balance, symbol, minimumPurch
  * branch in every consumer to distinguish. Split it out if that stops being
  * true.
  */
-type OndoLoadErrorReason = 'not-authenticated' | 'generic-error';
+type OndoLoadErrorReason = 'not-authenticated' | 'not-tradable' | 'generic-error';
 declare function ondoLoadErrorReason(error: unknown): OndoLoadErrorReason;
 
 /**
@@ -4709,7 +6069,9 @@ interface UseOndoBuyCheckoutViewModelResult {
  * no Ondo integration contract is known before any step runs, and there is no
  * region to report it in that would not first have to render something untrue:
  * a wallet picker leading nowhere, a balance read for a token this flow will
- * never spend. See {@link OndoCheckoutErrorReason}.
+ * never spend. A market known to be closed while the user is still choosing a
+ * 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
@@ -5096,7 +6458,9 @@ interface UseOndoSellCheckoutViewModelResult {
  * about whether there is a flow rather than about how one went. A chain with
  * no Ondo integration contract is known before any step runs, and there is no
  * region to report it in that would not first have to render something untrue.
- * See {@link OndoCheckoutErrorReason}.
+ * A market known to be closed while the user is still on the first step 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, and so is
  * the wallet the flow opened on. The step machine holds a committed quote and
@@ -5204,6 +6568,12 @@ type LoadOndoTradingStatusState = {
     type: 'CONTENT';
     status: OndoTradingStatus;
 };
+/**
+ * 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.
+ */
+declare function isNotTradable(state: LoadOndoTradingStatusState): boolean;
 interface UseOndoTradingStatusOptions {
     /** Ondo's API symbol, e.g. `AAPLon`. */
     symbol: AssetSymbol;
@@ -5792,6 +7162,118 @@ interface UseSuperstateWalletViewModelResult {
  */
 declare function useSuperstateWalletViewModel({ stepInput, wallets, offerId, contractAddress, chain, onComplete, onEdit, }: UseSuperstateWalletViewModelOptions): UseSuperstateWalletViewModelResult;
 
+/**
+ * Where one claim run stands. `FAILED` keeps the phase it stopped in, so a
+ * progress list can mark the step that broke rather than only say that
+ * something did.
+ */
+type CentrifugeClaimState = {
+    type: 'IDLE';
+} | {
+    type: 'RUNNING';
+    phase: CentrifugeClaimPhase;
+} | {
+    type: 'FAILED';
+    phase: CentrifugeClaimPhase;
+    error: CentrifugeClaimError;
+} | {
+    type: 'SUCCEEDED';
+    success: Extract<CentrifugeClaimResult, {
+        type: 'success';
+    }>;
+};
+type CentrifugeClaimParams = Omit<ClaimCentrifugeVaultParams, 'centrifuge' | 'onProgress'>;
+interface UseCentrifugeClaimResult {
+    state: CentrifugeClaimState;
+    /**
+     * Runs a claim and resolves with its result, whatever became of the state:
+     * a claim abandoned with {@link reset} still mines, and the caller may want
+     * to refetch when it does.
+     */
+    claim: (params: CentrifugeClaimParams) => Promise<CentrifugeClaimResult>;
+    /** Back to `IDLE`. A run still in flight stops updating the state. */
+    reset: () => void;
+}
+/**
+ * Claims a filled Centrifuge position through `coinlist.centrifuge.claim`,
+ * tracking which phase it is in.
+ *
+ * Unmounting or resetting does not cancel a claim - nothing can recall a
+ * broadcast transaction - it only stops this state following it.
+ */
+declare function useCentrifugeClaim(): UseCentrifugeClaimResult;
+
+/** A vault on one chain, as the position endpoints key it. */
+type CentrifugePositionVault = {
+    chain: EthereumChain;
+    /** Share token symbol of the vault, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+};
+/**
+ * The state of the position reads.
+ *
+ * `CONTENT` holds every read that has ever answered, kept through later
+ * 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.
+ */
+type LoadCentrifugeVaultPositionsState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: CentrifugeLoadErrorReason;
+} | {
+    type: 'CONTENT';
+    legs: CentrifugeVaultLeg[];
+};
+interface UseCentrifugeVaultPositionsOptions {
+    /** The vaults to read, one per chain the offer runs on. */
+    vaults: CentrifugePositionVault[];
+    /** The wallets to read them for, in display order. */
+    walletAddresses: EvmWalletAddress[];
+    /**
+     * How often to re-read a position that still has something pending.
+     * Defaults to {@link CENTRIFUGE_POLL_INTERVAL_MS}.
+     */
+    pollIntervalMs?: number;
+    /**
+     * Reads pre-fetched on the server. When provided, the hook opens on them
+     * and skips the first fetch; polling and {@link UseCentrifugeVaultPositionsResult.refetch}
+     * still fetch.
+     */
+    data?: CentrifugeVaultLeg[];
+    /**
+     * Default `true`. When `false`: no requests, no timers, and an empty
+     * `CONTENT`.
+     */
+    enabled?: boolean;
+}
+interface UseCentrifugeVaultPositionsResult {
+    state: LoadCentrifugeVaultPositionsState;
+    /**
+     * Reads every position again: the retry after an `ERROR`, and what a claim
+     * calls once it mined so the claimed amount leaves the screen.
+     */
+    refetch: () => void;
+}
+/**
+ * Reads, and keeps reading, every wallet's position on every vault, on both
+ * sides of the trade.
+ *
+ * A fill lands on the fund's schedule with no signal, so polling is the only
+ * way a pending position is seen turning claimable. Each read is fetched once
+ * when the inputs change, when {@link UseCentrifugeVaultPositionsResult.refetch}
+ * is called and when the page becomes visible again. Between those, only the
+ * reads with something still pending are polled - a position with nothing
+ * pending cannot change on its own - and only while the page is visible.
+ *
+ * A read that fails keeps its last answer and is logged; one that has never
+ * answered is left out, and retried on the next full fetch rather than on
+ * the timer.
+ */
+declare function useCentrifugeVaultPositions(options: UseCentrifugeVaultPositionsOptions): UseCentrifugeVaultPositionsResult;
+
 type LoadOfferDetailsReason = 'not-authenticated' | 'generic-error';
 type LoadOfferDetailsState = {
     type: 'LOADING';
@@ -6219,6 +7701,116 @@ interface UseConnectWalletModalViewModelResult {
  */
 declare function useConnectWalletModalViewModel({ isOpen, onClose, offerId, optionId, wallet, onConnected, onRequestConnect, challengeType, statement, }: UseConnectWalletModalViewModelOptions): UseConnectWalletModalViewModelResult;
 
+/**
+ * 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.
+ */
+type LoadCentrifugeVaultStatusState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: CentrifugeLoadErrorReason;
+} | {
+    type: 'CONTENT';
+    status: CentrifugeVaultStatus;
+};
+/** A vault as the status endpoint keys it: one share token on one chain. */
+type CentrifugeStatusVault = {
+    /** Share token symbol of the vault, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+};
+interface UseCentrifugeVaultStatusesOptions {
+    /** The vaults to poll, typically one per chain an offer runs on. */
+    vaults: CentrifugeStatusVault[];
+    /** 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;
+}
+interface UseCentrifugeVaultStatusesResult {
+    /** One entry per vault asked for, in the order asked. */
+    statuses: {
+        vault: CentrifugeStatusVault;
+        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.
+ */
+declare function useCentrifugeVaultStatuses(options: UseCentrifugeVaultStatusesOptions): UseCentrifugeVaultStatusesResult;
+
+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;
+}
+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.
+ */
+declare function useCentrifugeVaultStatus(options: UseCentrifugeVaultStatusOptions): UseCentrifugeVaultStatusResult;
+
 interface UseErc20BalanceOptions {
     /**
      * The token to read, by contract address.
@@ -6589,4 +8181,15 @@ interface UseCountdownOptions {
  */
 declare function useCountdown({ until, tickMs, enabled, }: UseCountdownOptions): number | null;
 
-export { type AuthState, type AuthorizeWalletParams, 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 ClientAuthConfig, type ClientAuthNamespace, ClientAuthNamespaceImpl, type ClientAuthSession, type ClientCoinListTokenSaleNamespace, ClientCoinListTokenSaleNamespaceImpl, type ClientConfig, type ClientOndoNamespace, ClientOndoNamespaceImpl, type ClientRequirementsNamespace, ClientRequirementsNamespaceImpl, type ClientSuperstateSwapNamespace, ClientSuperstateSwapNamespaceImpl, type ClientSupportNamespace, ClientSupportNamespaceImpl, type CoinListClient, CoinListClientInitializationError, CoinListContext, CoinListContextProvider, type CoinListContextValue, CoinListProvider, type CoinListProviderProps, CoinListSignInButton, CoinListSignInCardContainer, type CoinListSignInCardContainerProps, type CoinListSignInCardUiEvent, type CoinListSignInCardUiState, CoinListSignInCardView, type CoinListSignInCardViewProps, CoinListStyleScope, type CoinListStyleScopeProps, type CoinListTokenSaleCheckoutConfig, type CompleteOAuthFailureReason, ConnectWallet, type ConnectWalletError, type ConnectWalletErrorCode, type ConnectWalletFlowError, type ConnectWalletFlowParams, type ConnectWalletFlowResult, ConnectWalletModalContainer, type ConnectWalletModalContainerProps, type ConnectWalletModalUiEvent, type ConnectWalletModalUiState, ConnectWalletModalView, type ConnectWalletModalViewProps, type ConnectWalletPhase, type ConnectWalletScreenUi, type ConnectWalletSignState, type ConnectWalletState, ConnectedWalletList, type ConnectedWalletListProps, type ConnectedWalletUi, ERC20_BALANCE_POLL_INTERVAL_MS, type Erc20AllowanceError, type Erc20AllowancePhase, type Erc20AllowanceResult, type Erc20ApprovalError, EvmWallet, type ExecuteOndoSwapParams, type ExecuteSwapParams, type ExecuteTokenSaleParams, IdentityVerificationContainer, type IdentityVerificationContainerProps, type IdentityVerificationUiEvent, type IdentityVerificationUiState, IdentityVerificationView, type IdentityVerificationViewProps, KycLevelName, type KycTokenErrorReason, type KycTokenState, 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, Logger, type LogoImageUi, OAUTH_CODE_VERIFIER_KEY, OAUTH_STATE_KEY, type OauthClientErrorReason, type OauthClientResult, OfferAssetCard, type OfferAssetCardProps, OfferAssetCardUi, OfferLogoUi, OfferSaleCard, type OfferSaleCardProps, OfferSaleCardUi, OffersAssetGrid, type OffersAssetGridProps, OffersGridContainer, type OffersGridContainerProps, type OffersGridData, type OffersGridUiEvent, type OffersGridUiState, OffersGridView, type OffersGridViewProps, type OndoBuyAmountConfirmed, type OndoBuyAmountStepInput, type OndoBuyAmountUiEvent, type OndoBuyAmountUiState, type OndoBuyAmountValidation, OndoBuyAmountView, type OndoBuyAmountViewProps, OndoBuyCheckoutContainer, type OndoBuyCheckoutContainerProps, type OndoBuyCheckoutUiEvent, type OndoBuyCheckoutUiState, OndoBuyCheckoutView, type OndoBuyCheckoutViewProps, type OndoBuyExecutionResult, OndoBuyOrderConfirmed, type OndoBuyOrderPlaced, type OndoBuyOrderTerms, type OndoBuyPreparationResult, type OndoBuyQuoteStatusUi, type OndoBuyReviewStepInput, type OndoBuyReviewUiEvent, type OndoBuyReviewUiState, OndoBuyReviewView, type OndoBuyReviewViewProps, type OndoBuyStep, type OndoCheckoutConfig, OndoCheckoutError, type OndoCheckoutErrorProps, type OndoCheckoutErrorReason, type OndoLoadErrorReason, type OndoOrderConfirmedProps, type OndoOrderConfirmedUiEvent, type OndoOrderConfirmedUiState, type OndoOrderPlaced, type OndoOrderPlacedCore, type OndoSellAmountConfirmed, type OndoSellAmountStepInput, type OndoSellAmountUiEvent, type OndoSellAmountUiState, type OndoSellAmountValidation, OndoSellAmountView, type OndoSellAmountViewProps, type OndoSellAsset, type OndoSellBalanceUi, OndoSellCheckoutContainer, type OndoSellCheckoutContainerProps, type OndoSellCheckoutUiEvent, type OndoSellCheckoutUiState, OndoSellCheckoutView, type OndoSellCheckoutViewProps, type OndoSellExecutionResult, OndoSellOrderConfirmed, type OndoSellOrderConfirmedProps, type OndoSellOrderConfirmedUiEvent, type OndoSellOrderConfirmedUiState, type OndoSellOrderPlaced, type OndoSellOrderTerms, type OndoSellOutcomeUi, type OndoSellPreparationResult, type OndoSellQuoteStatusUi, type OndoSellReviewStepInput, type OndoSellReviewUiEvent, type OndoSellReviewUiState, OndoSellReviewView, type OndoSellReviewViewProps, type OndoSellSourceWalletUi, type OndoSellStep, type OndoSidebarPriceUi, type OndoSidebarUiState, OndoSidebarView, type OndoSidebarViewProps, type OndoSwapExecutionError, type OndoSwapExecutionPhase, type OndoSwapExecutionResult, type OndoSwapPreparationError, type OndoSwapPreparationPhase, type OndoSwapPreparationResult, type OndoWalletSelectStepInput, type OndoWalletSelectUiEvent, type OndoWalletSelectUiState, OndoWalletSelectView, type OndoWalletSelectViewProps, PinoLoggerOptions, type PrepareOndoBuyParams, type PrepareOndoSellParams, type PrepareOndoSwapParamsCore, type RequiredCheckoutConfig, RequirementItem, type RequirementItemProps, RequirementItemUi, RequirementStatus, RequirementVariant, RequirementsChecklistContainer, type RequirementsChecklistContainerProps, type RequirementsChecklistItemUi, type RequirementsChecklistUiEvent, type RequirementsChecklistUiState, RequirementsChecklistView, type RequirementsChecklistViewProps, type RequirementsData, type RequirementsVerificationUi, type SignState, SlippagePicker, type SlippagePickerProps, type SubmitErc20ApprovalResult, type SuperstateAmountConfirmed, type SuperstateAmountStepInput, type SuperstateAmountUiEvent, type SuperstateAmountUiState, type SuperstateAmountValidation, SuperstateAmountView, type SuperstateAmountViewProps, type SuperstateCheckoutConfig, SuperstateOrderConfirmed, type SuperstateOrderConfirmedProps, type SuperstateOrderConfirmedUiEvent, type SuperstateOrderConfirmedUiState, type SuperstateOrderPlaced, type SuperstateReviewStepInput, type SuperstateReviewUiEvent, type SuperstateReviewUiState, SuperstateReviewView, type SuperstateReviewViewProps, type SuperstateSidebarPriceUi, type SuperstateSidebarUiState, SuperstateSidebarView, type SuperstateSidebarViewProps, type SuperstateSlippageOptionUi, type SuperstateSlippageUi, SuperstateSwapCheckoutContainer, type SuperstateSwapCheckoutContainerProps, type SuperstateSwapCheckoutRetryUiEvent, type SuperstateSwapCheckoutUiEvent, type SuperstateSwapCheckoutUiState, SuperstateSwapCheckoutView, type SuperstateSwapCheckoutViewProps, type SuperstateSwapLoadErrorReason, type SuperstateSwapStep, type SuperstateWalletStepInput, type SuperstateWalletUiEvent, type SuperstateWalletUiState, SuperstateWalletView, type SuperstateWalletViewProps, type SwapExecutionError, type SwapExecutionPhase, type SwapExecutionResult, type SwapOutputTokenState, type TaxDocumentAddressParts, type TaxDocumentFieldUi, type TaxDocumentFields, TaxDocumentModalContainer, type TaxDocumentModalContainerProps, type TaxDocumentModalUiEvent, type TaxDocumentModalUiState, TaxDocumentModalView, type TaxDocumentModalViewProps, type TaxDocumentScreenUi, type TaxDocumentState, type TokenSaleExecutionError, type TokenSaleExecutionPhase, type TokenSaleExecutionResult, USDC_ICON_URL, USDT_ICON_URL, type UseCheckoutOfferTokenMetadataOptions, type UseCheckoutOfferTokenMetadataResult, type UseCoinListResult, type UseCoinListSignInCardViewModelOptions, type UseCoinListSignInCardViewModelResult, type UseCompleteOAuthOptions, type UseConnectWalletModalViewModelOptions, type UseConnectWalletModalViewModelResult, type UseConnectWalletOptions, type UseConnectWalletResult, type UseCountdownOptions, type UseErc20BalanceOptions, type UseErc20BalanceResult, type UseErc20TokenBalancesOptions, type UseErc20TokenBalancesResult, type UseIdentityVerificationViewModelOptions, type UseIdentityVerificationViewModelResult, type UseKycTokenResult, type UseOfferDetailsOptions, type UseOfferDetailsResult, type UseOffersGridViewModelOptions, type UseOffersGridViewModelResult, type UseOffersOptions, type UseOffersResult, type UseOndoBuyAmountViewModelOptions, type UseOndoBuyAmountViewModelResult, type UseOndoBuyCheckoutViewModelOptions, type UseOndoBuyCheckoutViewModelResult, type UseOndoBuyReviewViewModelOptions, type UseOndoBuyReviewViewModelResult, type UseOndoBuyTransactionOptions, type UseOndoBuyTransactionResult, type UseOndoPriceOptions, type UseOndoPriceResult, type UseOndoSellAmountViewModelOptions, type UseOndoSellAmountViewModelResult, type UseOndoSellCheckoutViewModelOptions, type UseOndoSellCheckoutViewModelResult, type UseOndoSellReviewViewModelOptions, type UseOndoSellReviewViewModelResult, type UseOndoSellTransactionOptions, type UseOndoSellTransactionResult, type UseOndoSidebarViewModelOptions, type UseOndoSidebarViewModelResult, type UseOndoTradingStatusOptions, type UseOndoTradingStatusResult, type UseOndoWalletSelectViewModelOptions, type UseOndoWalletSelectViewModelResult, type UseOptionAddressesOptions, type UseOptionAddressesResult, type UseParticipationsOptions, type UseParticipationsResult, type UseRequirementsChecklistViewModelOptions, type UseRequirementsChecklistViewModelResult, type UseRequirementsOptions, type UseRequirementsResult, type UseSuperstateAmountViewModelOptions, type UseSuperstateAmountViewModelResult, type UseSuperstateReviewViewModelOptions, type UseSuperstateReviewViewModelResult, type UseSuperstateSidebarViewModelOptions, type UseSuperstateSidebarViewModelResult, type UseSuperstateSwapCheckoutViewModelOptions, type UseSuperstateSwapCheckoutViewModelResult, type UseSuperstateWalletViewModelOptions, type UseSuperstateWalletViewModelResult, type UseSwapOutputTokenOptions, type UseSwapOutputTokenResult, type UseSwapQuoteOptions, type UseSwapQuoteResult, type UseTaxDocumentModalViewModelOptions, type UseTaxDocumentModalViewModelResult, type UseTaxDocumentOptions, type UseTaxDocumentResult, type UseTokenMetadataOptions, type UseTokenMetadataResult, type UseTokenRegistryOptions, type UseTokenRegistryResult, VerificationOverlay, type VerificationOverlayProps, type WalletAuthorizationError, type WalletAuthorizationPhase, type WalletAuthorizationResult, WalletError, type WalletsStatus, authorizeWallet, classifyWalletError, connectExternalWalletFlow, createCoinListClient, defaultCheckoutConfig, ensureErc20Allowance, executeOndoSwap, executeSwap, executeTokenSale, formatCountdown, formatMonthYear, formatSaleCardCountdown, offerAssetIconUrl, offerIconUrl, offerTokenIdentifier, ondoLoadErrorReason, pinoClientLogger, prepareOndoBuy, prepareOndoSell, quoteIsStale, quoteOverAsks, stablecoinIconUrl, submitErc20Approval, tokenLogoSrcSet, tokenLogoUrl, tokenMetadataOf, useCheckoutOfferTokenMetadata, useCoinList, useCoinListSignInCardViewModel, useCompleteOAuth, useConnectWallet, useConnectWalletModalViewModel, useCountdown, useErc20Balance, useErc20TokenBalances, useIdentityVerificationViewModel, useKycToken, useOfferDetails, useOffers, useOffersGridViewModel, useOndoBuyAmountViewModel, useOndoBuyCheckoutViewModel, useOndoBuyReviewViewModel, useOndoBuyTransaction, useOndoPrice, useOndoSellAmountViewModel, useOndoSellCheckoutViewModel, useOndoSellReviewViewModel, useOndoSellTransaction, useOndoSidebarViewModel, useOndoTradingStatus, useOndoWalletSelectViewModel, useOptionAddresses, useParticipations, useRequirements, useRequirementsChecklistViewModel, useSuperstateAmountViewModel, useSuperstateReviewViewModel, useSuperstateSidebarViewModel, useSuperstateSwapCheckoutViewModel, useSuperstateWalletViewModel, useSwapOutputToken, useSwapQuote, useTaxDocument, useTaxDocumentModalViewModel, useTokenMetadata, useTokenRegistry, validateAmount, validateSellAmount, validateSuperstateAmount };
+/**
+ * Whether the page is visible right now: `false` while the tab is in the
+ * background or the window is minimised, per the Page Visibility API.
+ *
+ * For a poll that should stop costing requests nobody is looking at. Reports
+ * `true` during a server render and hydration, so a component renders as it
+ * would on screen and hydrates without a mismatch, then the real visibility
+ * straight after.
+ */
+declare function usePageVisible(): boolean;
+
+export { type AuthState, type AuthorizeWalletParams, type BuyCentrifugeParams, CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES, type CentrifugeBuyAmountConfirmed, type CentrifugeBuyAmountStepInput, type CentrifugeBuyAmountUiEvent, type CentrifugeBuyAmountUiState, type CentrifugeBuyAmountValidation, CentrifugeBuyAmountView, type CentrifugeBuyAmountViewProps, CentrifugeBuyCheckoutContainer, type CentrifugeBuyCheckoutContainerProps, type CentrifugeBuyCheckoutUiEvent, type CentrifugeBuyCheckoutUiState, CentrifugeBuyCheckoutView, type CentrifugeBuyCheckoutViewProps, type CentrifugeBuyError, CentrifugeBuyOrderPlaced, type CentrifugeBuyOrderPlacedProps, type CentrifugeBuyPhase, type CentrifugeBuyPlacementError, type CentrifugeBuyPlacementPhase, type CentrifugeBuyPlacementResult, type CentrifugeBuyPreparationError, type CentrifugeBuyPreparationPhase, type CentrifugeBuyPreparationResult, type CentrifugeBuyResult, type CentrifugeBuyReviewStepInput, type CentrifugeBuyReviewUiEvent, type CentrifugeBuyReviewUiState, CentrifugeBuyReviewView, type CentrifugeBuyReviewViewProps, type CentrifugeBuyStep, CentrifugeCheckoutError, type CentrifugeCheckoutErrorProps, 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 CentrifugePositionVault, type CentrifugeSidebarMinimumUi, type CentrifugeSidebarUiState, CentrifugeSidebarView, type CentrifugeSidebarViewProps, type CentrifugeStatusVault, type CentrifugeVaultCheckoutConfig, type CentrifugeVaultClaimConfig, CentrifugeVaultClaimContainer, type CentrifugeVaultClaimContainerProps, CentrifugeVaultClaimDialog, type CentrifugeVaultClaimDialogProps, CentrifugeVaultClaimRow, type CentrifugeVaultClaimRowProps, type CentrifugeVaultClaimUiEvent, type CentrifugeVaultClaimUiState, CentrifugeVaultClaimView, type CentrifugeVaultClaimViewProps, type CentrifugeVaultClaimed, type CentrifugeWalletSelectStepInput, type CentrifugeWalletSelectUiEvent, type CentrifugeWalletSelectUiState, CentrifugeWalletSelectView, type CentrifugeWalletSelectViewProps, 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 ClientAuthConfig, type ClientAuthNamespace, ClientAuthNamespaceImpl, type ClientAuthSession, type ClientCentrifugeNamespace, ClientCentrifugeNamespaceImpl, type ClientCoinListTokenSaleNamespace, ClientCoinListTokenSaleNamespaceImpl, type ClientConfig, type ClientOndoNamespace, ClientOndoNamespaceImpl, type ClientRequirementsNamespace, ClientRequirementsNamespaceImpl, type ClientSuperstateSwapNamespace, ClientSuperstateSwapNamespaceImpl, type ClientSupportNamespace, ClientSupportNamespaceImpl, type CoinListClient, CoinListClientInitializationError, CoinListContext, CoinListContextProvider, type CoinListContextValue, CoinListProvider, type CoinListProviderProps, CoinListSignInButton, CoinListSignInCardContainer, type CoinListSignInCardContainerProps, type CoinListSignInCardUiEvent, type CoinListSignInCardUiState, CoinListSignInCardView, type CoinListSignInCardViewProps, CoinListStyleScope, type CoinListStyleScopeProps, type CoinListTokenSaleCheckoutConfig, type CompleteOAuthFailureReason, ConnectWallet, type ConnectWalletError, type ConnectWalletErrorCode, type ConnectWalletFlowError, type ConnectWalletFlowParams, type ConnectWalletFlowResult, ConnectWalletModalContainer, type ConnectWalletModalContainerProps, type ConnectWalletModalUiEvent, type ConnectWalletModalUiState, ConnectWalletModalView, type ConnectWalletModalViewProps, type ConnectWalletPhase, type ConnectWalletScreenUi, type ConnectWalletSignState, type ConnectWalletState, ConnectedWalletList, type ConnectedWalletListProps, type ConnectedWalletUi, ERC20_BALANCE_POLL_INTERVAL_MS, type Erc20AllowanceError, type Erc20AllowancePhase, type Erc20AllowanceResult, type Erc20ApprovalError, EvmWallet, type ExecuteOndoSwapParams, type ExecuteSwapParams, type ExecuteTokenSaleParams, type ExternalWalletRequestUi, IdentityVerificationContainer, type IdentityVerificationContainerProps, type IdentityVerificationUiEvent, type IdentityVerificationUiState, IdentityVerificationView, type IdentityVerificationViewProps, KycLevelName, type KycTokenErrorReason, type KycTokenState, type LoadCentrifugeBuyTransactionState, type LoadCentrifugeVaultPositionsState, 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, Logger, type LogoImageUi, OAUTH_CODE_VERIFIER_KEY, OAUTH_STATE_KEY, type OauthClientErrorReason, type OauthClientResult, OfferAssetCard, type OfferAssetCardProps, OfferAssetCardUi, OfferLogoUi, OfferSaleCard, type OfferSaleCardProps, OfferSaleCardUi, OffersAssetGrid, type OffersAssetGridProps, OffersGridContainer, type OffersGridContainerProps, type OffersGridData, type OffersGridUiEvent, type OffersGridUiState, OffersGridView, type OffersGridViewProps, type OndoBuyAmountConfirmed, type OndoBuyAmountStepInput, type OndoBuyAmountUiEvent, type OndoBuyAmountUiState, type OndoBuyAmountValidation, OndoBuyAmountView, type OndoBuyAmountViewProps, OndoBuyCheckoutContainer, type OndoBuyCheckoutContainerProps, type OndoBuyCheckoutUiEvent, type OndoBuyCheckoutUiState, OndoBuyCheckoutView, type OndoBuyCheckoutViewProps, type OndoBuyExecutionResult, OndoBuyOrderConfirmed, type OndoBuyOrderPlaced, type OndoBuyOrderTerms, type OndoBuyPreparationResult, type OndoBuyQuoteStatusUi, type OndoBuyReviewStepInput, type OndoBuyReviewUiEvent, type OndoBuyReviewUiState, OndoBuyReviewView, type OndoBuyReviewViewProps, type OndoBuyStep, type OndoCheckoutConfig, OndoCheckoutError, type OndoCheckoutErrorProps, OndoCheckoutErrorReason, type OndoLoadErrorReason, type OndoOrderConfirmedProps, type OndoOrderConfirmedUiEvent, type OndoOrderConfirmedUiState, type OndoOrderPlaced, type OndoOrderPlacedCore, type OndoSellAmountConfirmed, type OndoSellAmountStepInput, type OndoSellAmountUiEvent, type OndoSellAmountUiState, type OndoSellAmountValidation, OndoSellAmountView, type OndoSellAmountViewProps, type OndoSellAsset, type OndoSellBalanceUi, OndoSellCheckoutContainer, type OndoSellCheckoutContainerProps, type OndoSellCheckoutUiEvent, type OndoSellCheckoutUiState, OndoSellCheckoutView, type OndoSellCheckoutViewProps, type OndoSellExecutionResult, OndoSellOrderConfirmed, type OndoSellOrderConfirmedProps, type OndoSellOrderConfirmedUiEvent, type OndoSellOrderConfirmedUiState, type OndoSellOrderPlaced, type OndoSellOrderTerms, type OndoSellOutcomeUi, type OndoSellPreparationResult, type OndoSellQuoteStatusUi, type OndoSellReviewStepInput, type OndoSellReviewUiEvent, type OndoSellReviewUiState, OndoSellReviewView, type OndoSellReviewViewProps, type OndoSellSourceWalletUi, type OndoSellStep, type OndoSidebarPriceUi, type OndoSidebarUiState, OndoSidebarView, type OndoSidebarViewProps, type OndoSwapExecutionError, type OndoSwapExecutionPhase, type OndoSwapExecutionResult, type OndoSwapPreparationError, type OndoSwapPreparationPhase, type OndoSwapPreparationResult, type OndoWalletSelectStepInput, type OndoWalletSelectUiEvent, type OndoWalletSelectUiState, OndoWalletSelectView, type OndoWalletSelectViewProps, PinoLoggerOptions, type PlaceCentrifugeRequestParams, type PrepareCentrifugeBuyParams, type PrepareOndoBuyParams, type PrepareOndoSellParams, type PrepareOndoSwapParamsCore, type RequiredCheckoutConfig, RequirementItem, type RequirementItemProps, RequirementItemUi, RequirementStatus, RequirementVariant, RequirementsChecklistContainer, type RequirementsChecklistContainerProps, type RequirementsChecklistItemUi, type RequirementsChecklistUiEvent, type RequirementsChecklistUiState, RequirementsChecklistView, type RequirementsChecklistViewProps, type RequirementsData, type RequirementsVerificationUi, type SignState, SlippagePicker, type SlippagePickerProps, type SubmitErc20ApprovalResult, type SuperstateAmountConfirmed, type SuperstateAmountStepInput, type SuperstateAmountUiEvent, type SuperstateAmountUiState, type SuperstateAmountValidation, SuperstateAmountView, type SuperstateAmountViewProps, type SuperstateCheckoutConfig, SuperstateOrderConfirmed, type SuperstateOrderConfirmedProps, type SuperstateOrderConfirmedUiEvent, type SuperstateOrderConfirmedUiState, type SuperstateOrderPlaced, type SuperstateReviewStepInput, type SuperstateReviewUiEvent, type SuperstateReviewUiState, SuperstateReviewView, type SuperstateReviewViewProps, type SuperstateSidebarPriceUi, type SuperstateSidebarUiState, SuperstateSidebarView, type SuperstateSidebarViewProps, type SuperstateSlippageOptionUi, type SuperstateSlippageUi, SuperstateSwapCheckoutContainer, type SuperstateSwapCheckoutContainerProps, type SuperstateSwapCheckoutRetryUiEvent, type SuperstateSwapCheckoutUiEvent, type SuperstateSwapCheckoutUiState, SuperstateSwapCheckoutView, type SuperstateSwapCheckoutViewProps, type SuperstateSwapLoadErrorReason, type SuperstateSwapStep, type SuperstateWalletStepInput, type SuperstateWalletUiEvent, type SuperstateWalletUiState, SuperstateWalletView, type SuperstateWalletViewProps, type SwapExecutionError, type SwapExecutionPhase, type SwapExecutionResult, type SwapOutputTokenState, type TaxDocumentAddressParts, type TaxDocumentFieldUi, type TaxDocumentFields, TaxDocumentModalContainer, type TaxDocumentModalContainerProps, type TaxDocumentModalUiEvent, type TaxDocumentModalUiState, TaxDocumentModalView, type TaxDocumentModalViewProps, type TaxDocumentScreenUi, type TaxDocumentState, type TokenSaleExecutionError, type TokenSaleExecutionPhase, type TokenSaleExecutionResult, USDC_ICON_URL, USDT_ICON_URL, type UseCentrifugeBuyAmountViewModelOptions, type UseCentrifugeBuyAmountViewModelResult, type UseCentrifugeBuyCheckoutViewModelOptions, type UseCentrifugeBuyCheckoutViewModelResult, type UseCentrifugeBuyReviewViewModelOptions, type UseCentrifugeBuyReviewViewModelResult, type UseCentrifugeBuyTransactionOptions, type UseCentrifugeBuyTransactionResult, type UseCentrifugeClaimResult, type UseCentrifugeSidebarViewModelOptions, type UseCentrifugeSidebarViewModelResult, type UseCentrifugeVaultClaimViewModelOptions, type UseCentrifugeVaultClaimViewModelResult, type UseCentrifugeVaultPositionsOptions, type UseCentrifugeVaultPositionsResult, type UseCentrifugeVaultStatusOptions, type UseCentrifugeVaultStatusResult, type UseCentrifugeVaultStatusesOptions, type UseCentrifugeVaultStatusesResult, type UseCentrifugeWalletSelectViewModelOptions, type UseCentrifugeWalletSelectViewModelResult, type UseCheckoutOfferTokenMetadataOptions, type UseCheckoutOfferTokenMetadataResult, type UseCoinListResult, type UseCoinListSignInCardViewModelOptions, type UseCoinListSignInCardViewModelResult, type UseCompleteOAuthOptions, type UseConnectWalletModalViewModelOptions, type UseConnectWalletModalViewModelResult, type UseConnectWalletOptions, type UseConnectWalletResult, type UseCountdownOptions, type UseErc20BalanceOptions, type UseErc20BalanceResult, type UseErc20TokenBalancesOptions, type UseErc20TokenBalancesResult, type UseIdentityVerificationViewModelOptions, type UseIdentityVerificationViewModelResult, type UseKycTokenResult, type UseOfferDetailsOptions, type UseOfferDetailsResult, type UseOffersGridViewModelOptions, type UseOffersGridViewModelResult, type UseOffersOptions, type UseOffersResult, type UseOndoBuyAmountViewModelOptions, type UseOndoBuyAmountViewModelResult, type UseOndoBuyCheckoutViewModelOptions, type UseOndoBuyCheckoutViewModelResult, type UseOndoBuyReviewViewModelOptions, type UseOndoBuyReviewViewModelResult, type UseOndoBuyTransactionOptions, type UseOndoBuyTransactionResult, type UseOndoPriceOptions, type UseOndoPriceResult, type UseOndoSellAmountViewModelOptions, type UseOndoSellAmountViewModelResult, type UseOndoSellCheckoutViewModelOptions, type UseOndoSellCheckoutViewModelResult, type UseOndoSellReviewViewModelOptions, type UseOndoSellReviewViewModelResult, type UseOndoSellTransactionOptions, type UseOndoSellTransactionResult, type UseOndoSidebarViewModelOptions, type UseOndoSidebarViewModelResult, type UseOndoTradingStatusOptions, type UseOndoTradingStatusResult, type UseOndoWalletSelectViewModelOptions, type UseOndoWalletSelectViewModelResult, type UseOptionAddressesOptions, type UseOptionAddressesResult, type UseParticipationsOptions, type UseParticipationsResult, type UseRequirementsChecklistViewModelOptions, type UseRequirementsChecklistViewModelResult, type UseRequirementsOptions, type UseRequirementsResult, type UseSuperstateAmountViewModelOptions, type UseSuperstateAmountViewModelResult, type UseSuperstateReviewViewModelOptions, type UseSuperstateReviewViewModelResult, type UseSuperstateSidebarViewModelOptions, type UseSuperstateSidebarViewModelResult, type UseSuperstateSwapCheckoutViewModelOptions, type UseSuperstateSwapCheckoutViewModelResult, type UseSuperstateWalletViewModelOptions, type UseSuperstateWalletViewModelResult, type UseSwapOutputTokenOptions, type UseSwapOutputTokenResult, type UseSwapQuoteOptions, type UseSwapQuoteResult, type UseTaxDocumentModalViewModelOptions, type UseTaxDocumentModalViewModelResult, type UseTaxDocumentOptions, type UseTaxDocumentResult, type UseTokenMetadataOptions, type UseTokenMetadataResult, type UseTokenRegistryOptions, type UseTokenRegistryResult, VerificationOverlay, type VerificationOverlayProps, type WalletAuthorizationError, type WalletAuthorizationPhase, type WalletAuthorizationResult, WalletError, WalletLabelResolver, WalletSelection, type WalletsStatus, authorizeWallet, buyCentrifuge, centrifugeLoadErrorReason, centrifugeVaultOrderReasonMessage, centrifugeVaultOrderingMessage, claimCentrifugeVault, classifyWalletError, connectExternalWalletFlow, createCoinListClient, defaultCheckoutConfig, ensureErc20Allowance, executeOndoSwap, executeSwap, executeTokenSale, formatCountdown, formatMonthYear, formatSaleCardCountdown, isNotTradable, offerAssetIconUrl, offerIconUrl, offerTokenIdentifier, ondoLoadErrorReason, pinoClientLogger, placeCentrifugeRequest, prepareCentrifugeBuy, prepareOndoBuy, prepareOndoSell, primaryCentrifugeVaultOrderReason, quoteIsStale, quoteOverAsks, stablecoinIconUrl, submitErc20Approval, toInputAssetUi, tokenLogoSrcSet, tokenLogoUrl, tokenMetadataOf, useCentrifugeBuyAmountViewModel, useCentrifugeBuyCheckoutViewModel, useCentrifugeBuyReviewViewModel, useCentrifugeBuyTransaction, useCentrifugeClaim, useCentrifugeSidebarViewModel, useCentrifugeVaultClaimViewModel, useCentrifugeVaultPositions, useCentrifugeVaultStatus, useCentrifugeVaultStatuses, useCentrifugeWalletSelectViewModel, useCheckoutOfferTokenMetadata, useCoinList, useCoinListSignInCardViewModel, useCompleteOAuth, useConnectWallet, useConnectWalletModalViewModel, useCountdown, useErc20Balance, useErc20TokenBalances, useIdentityVerificationViewModel, useKycToken, useOfferDetails, useOffers, useOffersGridViewModel, useOndoBuyAmountViewModel, useOndoBuyCheckoutViewModel, useOndoBuyReviewViewModel, useOndoBuyTransaction, useOndoPrice, useOndoSellAmountViewModel, useOndoSellCheckoutViewModel, useOndoSellReviewViewModel, useOndoSellTransaction, useOndoSidebarViewModel, useOndoTradingStatus, useOndoWalletSelectViewModel, useOptionAddresses, usePageVisible, useParticipations, useRequirements, useRequirementsChecklistViewModel, useSuperstateAmountViewModel, useSuperstateReviewViewModel, useSuperstateSidebarViewModel, useSuperstateSwapCheckoutViewModel, useSuperstateWalletViewModel, useSwapOutputToken, useSwapQuote, useTaxDocument, useTaxDocumentModalViewModel, useTokenMetadata, useTokenRegistry, validateAmount, validateCentrifugeBuyAmount, validateSellAmount, validateSuperstateAmount };