@coinlist-co/react 0.12.2-rc.7b430dd → 0.12.2-rc.818bed6

package/dist/{tokens-namespace-CIWBtgt2.d.ts → time-DJU6E8KK.d.ts}

@@ -412,7 +412,7 @@ type PinoLoggerOptions = {
  * - an operation, a flow, a hook - is a {@link LogBinding} and appears as its
  * own field.
  */
-type LogScope = 'HTTP' | 'RPC' | 'AUTH' | 'OFFERS' | 'REQUIREMENTS' | 'WALLETS' | 'ERC20' | 'TOKEN_SALE' | 'SUPERSTATE' | 'ONDO' | 'TOKENS' | 'SUPPORT' | 'HOOKS';
+type LogScope = 'HTTP' | 'RPC' | 'AUTH' | 'OFFERS' | 'REQUIREMENTS' | 'WALLETS' | 'ERC20' | 'TOKEN_SALE' | 'SUPERSTATE' | 'ONDO' | 'CENTRIFUGE' | 'TOKENS' | 'SUPPORT' | 'HOOKS';
 /**
  * Correlates every line one logical request produces. The first attempt, each
  * retry, and the re-send after a session renewal all carry the same id, so a
@@ -873,6 +873,19 @@ type HttpRequestAttributes = {
     /** Zero-based attempt index: 0 = first request, 1 = first retry, etc. */
     retryAttempt?: number;
     renewAttempted?: boolean;
+    /**
+     * `false` opts a request out of `requestRetryMiddleware`. For exchanges
+     * that must never be replayed: a refresh token is single-use, so re-sending
+     * one whose first attempt reached the server presents a token that has
+     * already been rotated away.
+     */
+    retryable?: boolean;
+    /**
+     * The user access token `attachSessionMiddleware` put on this request, so
+     * that a 401 can say *which* token was refused. Absent when the request
+     * went out with no user token.
+     */
+    sentWith?: OAuthAccessToken;
     clientCredentials?: ClientCredentialsOAuth;
 };
 
@@ -1061,6 +1074,45 @@ interface Config {
      * See {@link RpcConfig}.
      */
     readonly rpc?: RpcConfig;
+    /**
+     * Called when the SDK has **confirmed** that the user's CoinList session is
+     * gone - its refresh token expired or was revoked - so you can clear your
+     * own state and show a sign-in entry point.
+     *
+     * Confirmed, because the backend answers "rotated a moment ago by a
+     * concurrent request" and "dead" identically. A single rejection is only a
+     * suspicion: the SDK acts on it only once the same session is rejected again
+     * after a settle window, so a lost refresh race never signs a user out.
+     *
+     * Each environment reports what it confirmed itself, so it fires in the
+     * one that drove the confirmation:
+     *
+     * - **`CoinListClient`**: fires when the SDK moves from `'logged-in'` to
+     *   `'logged-out'` because your `getAccessToken` answered `null` (or the
+     *   very token the API just refused) twice, a second apart.
+     * - **`CoinListServer`**: fires when the same process sees a refresh token
+     *   rejected twice, 5 to 60 seconds apart, or an expired session that
+     *   carries no refresh token. The SDK clears the session from your
+     *   `SessionStore` just before. The browser's confirmation, through your
+     *   `getAccessToken` endpoint, comes a second after the first rejection, so
+     *   it does not reach this verdict: when the browser drives renewal, expect
+     *   the `CoinListClient` callback, and this one only if a later request
+     *   presents the dead session 5 to 60 seconds on.
+     *
+     * It never fires on `auth.logout()`, on a 5xx, a timeout or a network
+     * failure - those mean the SDK could not find out, not that the session
+     * ended. Per environment it fires at most once per session, within a
+     * 60-second memory: the server remembers a verdict for 60 seconds per
+     * process (per JavaScript module instance, so Next.js middleware and route
+     * handlers count separately). The same dead session presented again after
+     * that, or to another instance, can be reported again, so make your handler
+     * idempotent.
+     *
+     * It is called on the next microtask and not awaited. A rejection is
+     * logged and dropped, so it cannot fail or delay the request that
+     * discovered the expiry. A synchronous handler is written `async () => {}`.
+     */
+    readonly onSessionExpired?: () => Promise<void>;
 }
 
 /**
@@ -1127,6 +1179,49 @@ declare class Erc20NamespaceImpl implements Erc20Namespace {
     getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
 }
 
+type GetCentrifugeVaultStatusParams = {
+    /** Share token symbol of the vault, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    /**
+     * The chain whose proxy answers. Only chains this offer has a proxy on
+     * are accepted; the offer's `vault_contracts` lists them.
+     */
+    chain: EthereumChain;
+};
+type GetCentrifugeVaultQuoteParams = GetCentrifugeVaultStatusParams & {
+    /**
+     * Amount to price, in the base units of the funding token. Must be greater
+     * than zero. No fee is deducted; this product charges none.
+     *
+     * Sized by `amount` alone: the quote is a free read of one spend, not a
+     * dollar figure converted later.
+     */
+    amount: BlockchainAmount;
+};
+/**
+ * One wallet on one vault: what every position read and every claim is keyed
+ * by. There is no order id - a wallet has one pooled position per vault per
+ * direction.
+ */
+type CentrifugeWalletParams = GetCentrifugeVaultStatusParams & {
+    /**
+     * The wallet whose position is read, or claimed for. A claim must then be
+     * broadcast from this same wallet: the proxy credits the sender.
+     */
+    walletAddress: EvmWalletAddress;
+};
+/**
+ * What `POST /v1/centrifuge/vault/invest` is asked for: the wallet that will
+ * broadcast the request and fund it, plus the deposit.
+ *
+ * Built once, when the user confirms an amount. Broadcasting the result places
+ * a request; it does not buy shares.
+ */
+type BuildCentrifugeVaultBuyParams = CentrifugeWalletParams & {
+    /** How much of the funding token to deposit, in its base units. */
+    amount: BlockchainAmount;
+};
+
 /**
  * The logging surface SDK code uses. Never exported to hosts: they implement
  * {@link Logger}, which is deliberately smaller.
@@ -1205,256 +1300,618 @@ type InternalDebugEvent = {
 };
 
 /**
- * The product an offer is checked out through. The backend sends one compound
- * `{supplier}::{saleType}` string, verbatim as spelled below: a double colon
- * between the two halves, `snake_case` within each. CoinList's token sale is
- * `coinlist::token_sale`; there is no `coinlist::sale` and no
- * `coinlist_token_sale`.
+ * Wire shapes for frontline's `/v1/centrifuge/vault/*` endpoints, as published
+ * in frontline's OpenAPI schema (ENG-1936). Every uint256 crosses as a decimal
+ * string, every price as a decimal string, every timestamp as ISO 8601.
  *
- * Kept flat rather than split into a supplier and a sale type, because a flat
- * union makes a `switch` over it exhaustive: adding a provider without
- * handling it becomes a compile error.
+ * **A vault deposit does not settle in the transaction that places it.** The
+ * fund fulfils requests on its own epoch, in whole or in part, at a price set
+ * then, and the user claims the resulting shares in a second transaction. So
+ * every share figure before a fill is an estimate.
+ *
+ * The three GETs are free to poll. The two POSTs return calldata to broadcast:
+ * `invest` is signed for one wallet and called once on confirmation, `claim`
+ * collects everything claimable and carries no amount.
  */
-type OfferTypeDto = 'coinlist::token_sale' | 'superstate::swap' | 'ondo::swap';
 /**
- * One variant per {@link OfferTypeDto}, mirroring frontline#1365, which keys
- * `GET /v1/offers` on `type`. Read `type` first: it decides which of the
- * fields below mean anything.
+ * Why a deposit cannot be placed right now. A closed set, so a client can
+ * branch on every value. `vault_unlinked` is terminal for the offer's proxy on
+ * that chain; the rest clear on their own or by hand.
+ *
+ * `below_minimum` is the one reason that depends on an amount, so only a quote
+ * can report it - see {@link CentrifugeVaultReasonDto}.
  */
-type OfferDto = CoinListTokenSaleOfferDto | SuperstateSwapOfferDto | OndoSwapOfferDto;
-type OfferBaseDto = {
-    id: string;
-    slug: string;
-    ends_at: string | null;
-    tokens: OfferTokenDto[];
-};
+type CentrifugeOrderReasonDto = 'vault_unlinked' | 'vault_halted' | 'proxy_not_permissioned' | 'price_unavailable' | 'below_minimum';
+/** What a vault status can report: every reason but the amount-dependent one. */
+type CentrifugeVaultReasonDto = Exclude<CentrifugeOrderReasonDto, 'below_minimum'>;
 /**
- * A curated sale window and the hand-authored copy that goes with it. Required
- * on every variant that runs such a campaign, which is every one but Ondo.
+ * Where a wallet stands on a vault, derived from its amounts rather than
+ * stored. Not a lifecycle: a new request moves any of these back to `pending`
+ * while earlier shares stay claimed.
  */
-type OfferEditorialDto = {
-    tagline: string;
-    banner_url: string;
-    starts_at: string;
+type CentrifugePositionStatusDto = 'none' | 'pending' | 'partially_filled' | 'filled' | 'claimed';
+/** `GET /v1/centrifuge/vault/quote?symbol&chain&amount`. Indicative only. */
+type CentrifugeVaultQuoteDto = {
+    object: 'centrifuge_vault_quote';
+    /** The vault's share token symbol, e.g. `deJTRSY`. */
+    symbol: string;
+    chain: string;
+    /** The amount priced, echoed back, in `spend_input_decimals`. No fee. */
+    spend_input_amount: string;
+    spend_input_decimals: number;
+    /** An estimate, not a floor: the fill can price either side of it. */
+    estimated_shares: string;
+    share_decimals: number;
+    /** Funding token per whole share. Null when the vault has no price. */
+    indicative_price: string | null;
+    /** In `spend_input_decimals`. Null when the offer sets no minimum. */
+    minimum_input_amount: string | null;
+    can_order: boolean;
+    /** Empty exactly when `can_order` is true. */
+    reasons: CentrifugeOrderReasonDto[];
+};
+/**
+ * `GET /v1/centrifuge/vault/status?symbol&chain`. The vault's own state, read
+ * from the chain on every call; the gate to poll, because Centrifuge announces
+ * none of these changes.
+ */
+type CentrifugeVaultStatusDto = {
+    object: 'centrifuge_vault_status';
+    symbol: string;
+    chain: string;
+    /** Centrifuge's vault, read from the proxy. Fixed for the proxy's life. */
+    vault_address: string;
+    /** False is terminal for this proxy: a replacement has to be deployed. */
+    linked: boolean;
+    /** Whether the proxy is on the share token's memberlist. */
+    permissioned: boolean;
+    membership_valid_until: string | null;
+    /** Set by the proxy after a force-cancel; cleared only by hand. */
+    halted: boolean;
+    price_updated_at: string | null;
+    can_order: boolean;
+    reasons: CentrifugeVaultReasonDto[];
+    as_of: string;
+};
+/**
+ * What both POSTs return: calldata for the wallet to broadcast verbatim.
+ * Unlike Ondo's, `expires_at` is nullable - a claim carries no signature, so
+ * it is always null there.
+ */
+type CentrifugeBroadcastDto = {
+    action: 'broadcast_transaction';
+    /** The offer's proxy on the chain. Lower case: compare case-insensitively. */
+    to: string;
+    data: string;
+    expires_at: string | null;
 };
 /**
- * What an Ondo swap sends in place of {@link OfferEditorialDto}. It trades
- * continuously and runs no campaign, so the keys arrive as `null` and carry
- * nothing. Declared so a fixture can describe the real payload; no `fromDto`
- * reads them.
+ * `POST /v1/centrifuge/vault/invest` with `{ symbol, chain, wallet_address,
+ * amount }`. Broadcasting it places a request in the vault's queue and buys
+ * nothing yet.
  */
-type OfferNoEditorialDto = {
-    tagline: null;
-    banner_url: null;
-    starts_at: null;
-};
-type CoinListTokenSaleOfferDto = OfferBaseDto & OfferEditorialDto & {
-    type: 'coinlist::token_sale';
-    logo_url: string;
+type CentrifugeVaultBuyDto = CentrifugeBroadcastDto & {
+    /** Exactly what the approval has to cover: no fee comes off it. */
+    spend_input_amount: string;
+    spend_input_decimals: number;
+    /** Not a quantity purchased: the fill prices later. */
+    estimated_shares: string;
+    share_decimals: number;
 };
-type SuperstateSwapOfferDto = OfferBaseDto & OfferEditorialDto & {
-    type: 'superstate::swap';
-    /** Publishing a swap does not require anyone to upload artwork for it. */
-    logo_url: string | null;
+/**
+ * `GET /v1/centrifuge/vault/position?symbol&chain&wallet_address`. The six
+ * amounts are independent: a wallet can hold a pending request, a claimable
+ * balance and claimed shares at once. There is no per-fulfilment breakdown;
+ * settlement pools every fulfilment into one rate.
+ */
+type CentrifugeVaultPositionDto = {
+    object: 'centrifuge_vault_position';
+    symbol: string;
+    chain: string;
+    wallet_address: string;
+    status: CentrifugePositionStatusDto;
+    /** Funding token ever requested, in `asset_decimals`. */
+    requested: string;
+    /** Of that, still queued. */
+    pending: string;
+    /** Of that, fulfilled. */
+    filled_assets: string;
+    /** Shares the fulfilments earned, in `share_decimals`. Held by the proxy until claimed. */
+    earned_shares: string;
+    claimed_shares: string;
+    /** Non-zero means the claim endpoint will return calldata. */
+    claimable_shares: string;
+    /** Read from the share token; can exceed `claimed_shares`. */
+    share_balance: string;
+    asset_decimals: number;
+    share_decimals: number;
+    /** Null before the first claim. */
+    average_price: string | null;
+    /** Centrifuge froze the wallet on the share token; blocks claiming. */
+    frozen: boolean;
+    as_of: string;
 };
-type OndoSwapOfferDto = OfferBaseDto & OfferNoEditorialDto & {
-    type: 'ondo::swap';
-    /** Publishing a swap does not require anyone to upload artwork for it. */
-    logo_url: string | null;
+/**
+ * `POST /v1/centrifuge/vault/claim` with `{ symbol, chain, wallet_address }`.
+ * The wallet named must be the one that broadcasts: the proxy credits the
+ * sender.
+ */
+type CentrifugeVaultClaimDto = CentrifugeBroadcastDto & {
+    /** A floor: a fill landing before the broadcast raises it. */
+    claimable_shares: string;
+    share_decimals: number;
 };
-type OfferTokenDto = {
-    role: 'funding' | 'distribution' | 'swap';
+/**
+ * `GET /v1/centrifuge/vault/redeem-position?symbol&chain&wallet_address`. The
+ * redeem side of {@link CentrifugeVaultPositionDto}, with the units swapped:
+ * what is queued is shares, and what a fill makes claimable is the funding
+ * token.
+ *
+ * TODO(frontline, ENG-1909): guessed. Frontline publishes no redeem endpoint
+ * yet; this mirrors the invest position field for field so the SDK can be
+ * built against it. Replace with the published schema when it lands.
+ */
+type CentrifugeVaultRedeemPositionDto = {
+    object: 'centrifuge_vault_redeem_position';
+    symbol: string;
     chain: string;
-    address: string;
+    wallet_address: string;
+    status: CentrifugePositionStatusDto;
+    /** Shares still queued for redemption, in `share_decimals`. */
+    pending: string;
+    /**
+     * Funding token a claim would pay out now, in `asset_decimals`. An
+     * estimate: the vault holds the claimable amount in shares and prices it
+     * at the claim.
+     */
+    claimable_assets: string;
+    asset_decimals: number;
+    share_decimals: number;
+    /** Centrifuge froze the wallet on the share token. */
+    frozen: boolean;
+    as_of: string;
+};
+/**
+ * `POST /v1/centrifuge/vault/claim-proceeds` with `{ symbol, chain,
+ * wallet_address }`. Collects everything claimable on the redeem side; the
+ * proxy pays the sender.
+ *
+ * TODO(frontline, ENG-1909): guessed, as {@link CentrifugeVaultRedeemPositionDto}.
+ */
+type CentrifugeVaultClaimProceedsDto = CentrifugeBroadcastDto & {
+    /** An estimate read when the calldata was built, in `asset_decimals`. */
+    claimable_assets: string;
+    asset_decimals: number;
 };
 
-type OfferId = Newtype<string, 'OfferId'>;
-declare const OfferId: (value: string) => OfferId;
-type OfferSlug = Newtype<string, 'OfferSlug'>;
-declare const OfferSlug: (value: string) => OfferSlug;
-type OfferType = OfferTypeDto;
-declare const isOfferType: (value: string) => value is OfferType;
-type OfferBase = {
-    id: OfferId;
-    slug: OfferSlug;
-    endsAt: Date | null;
-    tokens: OfferToken[];
+/**
+ * Which leg of a vault trade: `invest` turns the funding token into shares,
+ * `redeem` turns shares back into the funding token. Each wallet holds one
+ * pooled position per vault per direction, and a claim settles one of them.
+ */
+type CentrifugeClaimDirection = 'invest' | 'redeem';
+/**
+ * Why a deposit cannot be placed on a vault right now. Kept verbatim from the
+ * wire: frontline publishes it as a closed set for clients to branch on.
+ */
+type CentrifugeOrderReason = CentrifugeOrderReasonDto;
+/** The reasons a vault status can report - all but `below_minimum`. */
+type CentrifugeVaultReason = CentrifugeVaultReasonDto;
+/**
+ * Where a wallet stands on a vault. Not a lifecycle - see
+ * {@link CentrifugeVaultPosition.status}.
+ */
+type CentrifugePositionStatus = CentrifugePositionStatusDto;
+/**
+ * Whether a deposit can be placed, as one union rather than the wire's
+ * `can_order` beside `reasons`: a blocked answer always says why, and an
+ * orderable one has nothing to say. The wire pair can contradict itself; this
+ * cannot, because `fromDto` refuses the payloads that do.
+ */
+type CentrifugeOrderability<R extends CentrifugeOrderReason> = {
+    type: 'orderable';
+} | {
+    type: 'blocked';
+    reasons: [R, ...R[]];
 };
-type CoinListTokenSaleOffer = OfferBase & OfferEditorial & {
-    type: 'coinlist::token_sale';
-    logoUrl: string;
+/**
+ * What a deposit of a given size would buy, and whether it can be placed.
+ *
+ * **Indicative only.** The price is read from the vault now and the fund
+ * prices the fulfilment on its own epoch, so neither {@link indicativePrice}
+ * nor {@link estimatedShares} is a commitment. Free to poll while the user
+ * sizes a deposit.
+ */
+type CentrifugeVaultQuote = {
+    chain: EthereumChain;
+    /** The vault's share token symbol, e.g. `deJTRSY`. */
+    symbol: AssetSymbol;
+    /** The amount priced, in the funding token's decimals. No fee is taken. */
+    spendInputAmount: BlockchainAmount;
+    /** Shares at the indicative price, in the share token's decimals. */
+    estimatedShares: BlockchainAmount;
+    /** Funding token per whole share. Null when the vault publishes no price. */
+    indicativePrice: DecimalString | null;
+    /** Null when the offer sets no minimum. Same decimals as the spend. */
+    minimumInputAmount: BlockchainAmount | null;
+    orderability: CentrifugeOrderability<CentrifugeOrderReason>;
 };
-type SuperstateSwapOffer = OfferBase & OfferEditorial & {
-    type: 'superstate::swap';
-    /** Null when nobody has uploaded artwork: a swap publishes without it. */
-    logoUrl: string | null;
+declare const CentrifugeVaultQuote: {
+    fromDto: (dto: CentrifugeVaultQuoteDto) => CentrifugeVaultQuote;
 };
-type OndoSwapOffer = OfferBase & {
-    type: 'ondo::swap';
-    /** Null when nobody has uploaded artwork: a swap publishes without it. */
-    logoUrl: string | null;
+/**
+ * A vault's own state, independent of any wallet or amount: the gate to poll.
+ * Centrifuge announces none of these changes, and an unlinked vault leaves the
+ * offer's proxy permanently dead, so a cached answer goes wrong silently.
+ */
+type CentrifugeVaultStatus = {
+    chain: EthereumChain;
+    symbol: AssetSymbol;
+    /** Centrifuge's vault behind the proxy. Fixed for the proxy's life. */
+    vaultAddress: EvmContractAddress;
+    /**
+     * Whether Centrifuge still links the vault to its pool. False is terminal
+     * for this proxy: no request or claim succeeds until a new one is deployed.
+     */
+    linked: boolean;
+    /**
+     * Whether the proxy is on the share token's memberlist. It holds shares for
+     * every wallet, so one expired entry stops the whole offer.
+     */
+    permissioned: boolean;
+    /** Watch it: {@link permissioned} goes false the moment it passes. */
+    membershipValidUntil: Date | null;
+    /** The proxy halted itself after a force-cancel; cleared only by hand. */
+    halted: boolean;
+    /** A stale value is the signal that a quote's price is old. */
+    priceUpdatedAt: Date | null;
+    orderability: CentrifugeOrderability<CentrifugeVaultReason>;
+    /** When the chain was read: how old everything above is. */
+    asOf: Date;
+};
+declare const CentrifugeVaultStatus: {
+    fromDto: (dto: CentrifugeVaultStatusDto) => CentrifugeVaultStatus;
 };
 /**
- * A curated sale window and the hand-authored copy that goes with it. Every
- * variant that runs such a campaign carries all three, validated; an Ondo swap
- * trades continuously, runs none, and carries none.
+ * What both vault transactions share: calldata to broadcast verbatim, and the
+ * deadline on it.
  */
-type OfferEditorial = {
-    tagline: string;
-    bannerUrl: string;
-    startsAt: Date;
+type CentrifugeVaultTransactionCore = {
+    /** The `to` is the offer's proxy: the spender the deposit was approved to. */
+    tx: Tx;
+    /**
+     * When the calldata stops being accepted, or null when it carries no
+     * deadline - always the case for a claim, which nobody signs.
+     */
+    expiresAt: Date | null;
 };
-declare const OfferEditorial: {
+/**
+ * A signed deposit request, ready to broadcast.
+ *
+ * **Broadcasting it buys nothing yet.** It places a request in the vault's
+ * queue; the fund fulfils it later at a price set then, and the user comes
+ * back to claim. {@link estimatedShares} is therefore never a quantity
+ * purchased. Single-use: built once on confirmation, never on a timer.
+ */
+type CentrifugeVaultBuyTransaction = CentrifugeVaultTransactionCore & {
+    /** Exactly what the approval has to cover: no fee comes off it. */
+    spendInputAmount: BlockchainAmount;
+    /** At the price read when the calldata was built. An estimate, not a floor. */
+    estimatedShares: BlockchainAmount;
+};
+declare const CentrifugeVaultBuyTransaction: {
+    fromDto: (dto: CentrifugeVaultBuyDto) => CentrifugeVaultBuyTransaction;
+};
+/**
+ * The claim that moves fulfilled shares from the proxy to the wallet: the
+ * second transaction every vault purchase needs. The wallet that broadcasts it
+ * is the one credited.
+ */
+type CentrifugeVaultClaimTransaction = CentrifugeVaultTransactionCore & {
     /**
-     * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
-     * the same three checks name the payload that failed them.
+     * Read when the calldata was built. A floor: a fill landing before the
+     * broadcast raises it, and the claim still collects everything.
      */
-    fromDto: (dto: OfferEditorialDto, model: string) => OfferEditorial;
+    claimableShares: BlockchainAmount;
+};
+declare const CentrifugeVaultClaimTransaction: {
+    fromDto: (dto: CentrifugeVaultClaimDto) => CentrifugeVaultClaimTransaction;
 };
 /**
- * An offer as `GET /v1/offers` lists it: a union on {@link OfferType}, each
- * variant carrying only the fields that mean something for it. Narrow on
- * `type` before reading anything beyond {@link OfferBase} - an Ondo swap has
- * no `startsAt` to read, and the compiler says so.
+ * One wallet's standing on one vault: what it put in, what has settled, and
+ * what it can claim. The endpoint a returning user lands on, and the one that
+ * says whether to offer the claim.
+ *
+ * The amounts are independent of each other: each piece of a request settles
+ * and is claimed on its own, so a wallet can be pending, claimable and claimed
+ * at once. There is no per-fulfilment breakdown; settlement pools every
+ * fulfilment into one {@link averagePrice}.
  */
-type Offer = CoinListTokenSaleOffer | SuperstateSwapOffer | OndoSwapOffer;
-declare const Offer: {
-    fromDto: (dto: OfferDto) => Offer;
+type CentrifugeVaultPosition = {
+    chain: EthereumChain;
+    symbol: AssetSymbol;
+    walletAddress: EvmWalletAddress;
     /**
-     * Maps a page of offers, dropping every offer whose `type` this SDK does not
-     * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
-     * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
-     * reject the whole page, so one offer of an unknown type would blank the
-     * grid for every offer beside it. A single offer fetched by id still
-     * throws, because there is nothing beside it to keep.
+     * Derived by frontline from the amounts. Not a lifecycle: a new request
+     * moves it back to `pending` while earlier shares stay claimed.
+     */
+    status: CentrifugePositionStatus;
+    /** Funding token ever requested. */
+    requested: BlockchainAmount;
+    /** Of {@link requested}, what is still queued. */
+    pending: BlockchainAmount;
+    /** Of {@link requested}, what has been fulfilled. */
+    filledAssets: BlockchainAmount;
+    /** Shares the fulfilments earned. Held by the proxy until claimed. */
+    earnedShares: BlockchainAmount;
+    claimedShares: BlockchainAmount;
+    /** Non-zero means a claim will return calldata. */
+    claimableShares: BlockchainAmount;
+    /**
+     * What the wallet holds on the share token. Can exceed
+     * {@link claimedShares}: shares acquired any other way count here.
+     */
+    shareBalance: BlockchainAmount;
+    /** Pooled rate over everything claimed. Null before the first claim. */
+    averagePrice: DecimalString | null;
+    /** Centrifuge froze this wallet on the share token. Blocks claiming. */
+    frozen: boolean;
+    asOf: Date;
+};
+declare const CentrifugeVaultPosition: {
+    fromDto: (dto: CentrifugeVaultPositionDto) => CentrifugeVaultPosition;
+};
+/**
+ * One wallet's standing on the redeem side of a vault: shares queued to sell,
+ * and the funding token a fill has made claimable. The mirror of
+ * {@link CentrifugeVaultPosition}, and as independent of it: a wallet can be
+ * investing and redeeming on the same vault at once.
+ *
+ * TODO(frontline, ENG-1909): built against a guessed wire shape - see
+ * `CentrifugeVaultRedeemPositionDto`.
+ */
+type CentrifugeVaultRedeemPosition = {
+    chain: EthereumChain;
+    symbol: AssetSymbol;
+    walletAddress: EvmWalletAddress;
+    status: CentrifugePositionStatus;
+    /** Shares still queued for redemption. */
+    pending: BlockchainAmount;
+    /**
+     * Funding token a claim would pay out now. An estimate: the vault prices the
+     * claimable shares at the claim. Non-zero means a claim returns calldata.
      */
-    listFromDto: (dtos: OfferDto[]) => Offer[];
+    claimableAssets: BlockchainAmount;
+    /** Centrifuge froze this wallet on the share token. Blocks claiming. */
+    frozen: boolean;
+    asOf: Date;
 };
-type TokenRole = 'funding' | 'distribution' | 'swap';
-type OfferToken = {
-    role: TokenRole;
-    chain: Chain;
-    address: EvmContractAddress;
+declare const CentrifugeVaultRedeemPosition: {
+    fromDto: (dto: CentrifugeVaultRedeemPositionDto) => CentrifugeVaultRedeemPosition;
 };
-declare const OfferToken: {
-    fromDto: (dto: OfferTokenDto) => OfferToken;
+/**
+ * One wallet's position on one leg of a vault trade, tagged with the leg. The
+ * two legs are read from two endpoints and settle in opposite units - the
+ * invest leg queues the funding token and pays out shares, the redeem leg the
+ * reverse - so the tag is what says which unit each figure is in.
+ */
+type CentrifugeVaultLeg = {
+    direction: 'invest';
+    position: CentrifugeVaultPosition;
+} | {
+    direction: 'redeem';
+    position: CentrifugeVaultRedeemPosition;
+};
+declare const CentrifugeVaultLeg: {
     /**
-     * Maps an offer's token list, dropping every token on a chain this SDK does
-     * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
-     * plain `.map` would throw out of `Offer.fromDto` and, through
-     * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
-     * one Base token blanked production's offers list. Dropping costs that
-     * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
-     * so nobody could have looked it up anyway.
-     *
-     * Same shape as `TokenMetadata.fromRegistryDto`.
+     * What a claim on the leg would collect: shares for `invest`, the funding
+     * token for `redeem`.
      */
-    listFromDto: (dtos: OfferTokenDto[]) => OfferToken[];
+    claimable: (leg: CentrifugeVaultLeg) => BlockchainAmount;
+    /** Whether the leg has anything queued or anything ready to claim. */
+    isActive: (leg: CentrifugeVaultLeg) => boolean;
 };
-
 /**
- * The cursor-paginated envelope every list endpoint returns.
+ * One wallet's position on one leg of one vault: what a claim targets. A
+ * wallet holds at most one per direction per chain, so the three together
+ * name it.
+ */
+type CentrifugeVaultLegId = Newtype<string, 'CentrifugeVaultLegId'>;
+declare const CentrifugeVaultLegId: {
+    /** Addresses compare case-insensitively: frontline echoes them lower case. */
+    of: (leg: CentrifugeVaultLeg) => CentrifugeVaultLegId;
+};
+/**
+ * The claim that pays a filled redemption out in the funding token: the
+ * second transaction every vault sale needs. The wallet that broadcasts it is
+ * the one paid.
  *
- * Generic in its item type, so each resource pairs it with its own item DTO
- * rather than declaring an envelope of its own.
+ * TODO(frontline, ENG-1909): built against a guessed wire shape - see
+ * `CentrifugeVaultClaimProceedsDto`.
  */
-interface PaginatedResponseDto<T> {
-    data: T[];
-    starting_after?: string;
-    starting_before?: string;
-}
+type CentrifugeVaultClaimProceedsTransaction = CentrifugeVaultTransactionCore & {
+    /** An estimate read when the calldata was built; the claim pays it all. */
+    claimableAssets: BlockchainAmount;
+};
+declare const CentrifugeVaultClaimProceedsTransaction: {
+    fromDto: (dto: CentrifugeVaultClaimProceedsDto) => CentrifugeVaultClaimProceedsTransaction;
+};
 
-type Cursor = Newtype<string, 'Cursor'>;
-declare const Cursor: (value: string) => Cursor;
-interface PaginatedResponse<T> {
-    data: T[];
-    startingAfter: Cursor | null;
-    startingBefore: Cursor | null;
-}
-declare const PaginatedResponse: {
-    fromDto: <A, B>(dto: PaginatedResponseDto<A>, itemMapper: (item: A) => B) => PaginatedResponse<B>;
+/**
+ * Centrifuge vault reads and claims: an indicative quote, the vault-wide
+ * ordering gate, each wallet's position per direction, and the calldata that
+ * claims a filled request.
+ *
+ * The reads are free to poll - none spends an attestation, so a client may
+ * call them while the user sizes a deposit or waits on a fill. The quote has
+ * no expiry: it is indicative, the fund prices fulfilment later, and a
+ * countdown would imply a commitment the API does not make.
+ *
+ * A vault trade settles in two legs: a request the fund fills on its own
+ * schedule, then a claim. There is no order id - each wallet has one pooled
+ * position per vault per direction - so the claims take a wallet, not an
+ * order, and collect everything claimable.
+ *
+ * The calldata builders are the exception: {@link CentrifugeNamespace.buildBuyTransaction}
+ * and the claims are each called once, when the user confirms, and never on a
+ * timer. Broadcasting the buy calldata places a request. It does not buy
+ * shares.
+ *
+ * Every method requires `AuthState === 'logged-in'` and throws
+ * {@link NotAuthenticatedError} otherwise.
+ */
+interface CentrifugeNamespace {
+    getQuote(params: GetCentrifugeVaultQuoteParams): Promise<CentrifugeVaultQuote>;
+    getVaultStatus(params: GetCentrifugeVaultStatusParams): Promise<CentrifugeVaultStatus>;
+    /** The wallet's invest position: funding queued, shares claimable. */
+    getPosition(params: CentrifugeWalletParams): Promise<CentrifugeVaultPosition>;
     /**
-     * For a mapper that decides the page as a whole - one that drops items it
-     * cannot map, such as `Offer.listFromDto` - rather than item by item. The
-     * cursors are the wire's either way: dropping an item changes what the
-     * page holds, not where the next page starts.
+     * The wallet's redeem position: shares queued, funding claimable.
+     *
+     * TODO(frontline, ENG-1909): built against a guessed endpoint.
      */
-    fromDtoPage: <A, B>(dto: PaginatedResponseDto<A>, pageMapper: (items: A[]) => B[]) => PaginatedResponse<B>;
+    getRedeemPosition(params: CentrifugeWalletParams): Promise<CentrifugeVaultRedeemPosition>;
+    /**
+     * Calldata claiming every claimable share. Broadcast it from
+     * `params.walletAddress`: the proxy credits the sender.
+     */
+    createClaim(params: CentrifugeWalletParams): Promise<CentrifugeVaultClaimTransaction>;
+    /**
+     * Calldata paying out every claimable redemption in the funding token.
+     * Broadcast it from `params.walletAddress`.
+     *
+     * TODO(frontline, ENG-1909): built against a guessed endpoint.
+     */
+    createClaimProceeds(params: CentrifugeWalletParams): Promise<CentrifugeVaultClaimProceedsTransaction>;
+    /**
+     * Builds the calldata that places a deposit request.
+     *
+     * Called once on confirmation. The reads above are the ones a checkout polls.
+     */
+    buildBuyTransaction(params: BuildCentrifugeVaultBuyParams): Promise<CentrifugeVaultBuyTransaction>;
+}
+declare class CentrifugeNamespaceImpl implements CentrifugeNamespace {
+    private readonly ctx;
+    protected readonly log: InternalLogger;
+    constructor(ctx: UniversalNamespaceContext);
+    getQuote(params: GetCentrifugeVaultQuoteParams): Promise<CentrifugeVaultQuote>;
+    getVaultStatus(params: GetCentrifugeVaultStatusParams): Promise<CentrifugeVaultStatus>;
+    getPosition(params: CentrifugeWalletParams): Promise<CentrifugeVaultPosition>;
+    getRedeemPosition(params: CentrifugeWalletParams): Promise<CentrifugeVaultRedeemPosition>;
+    createClaim(params: CentrifugeWalletParams): Promise<CentrifugeVaultClaimTransaction>;
+    createClaimProceeds(params: CentrifugeWalletParams): Promise<CentrifugeVaultClaimProceedsTransaction>;
+    buildBuyTransaction(params: BuildCentrifugeVaultBuyParams): Promise<CentrifugeVaultBuyTransaction>;
+}
+
+type AssetDto = {
+    code: string;
+    fractional_digits: number;
+    id: string;
+    name: string;
+};
+
+type AssetId = Newtype<string, 'AssetId'>;
+declare const AssetId: (value: string) => AssetId;
+type AssetCode = Newtype<string, 'AssetCode'>;
+declare const AssetCode: (value: string) => AssetCode;
+type Asset = {
+    id: AssetId;
+    code: AssetCode;
+    name: string;
+    fractionalDigits: number;
 };
+declare const Asset: {
+    fromDto: (dto: AssetDto) => Asset;
+};
+
 /**
- * Cursor-based pagination input used when requesting paginated API resources.
- * Set `after` or `before` to navigate relative to a known cursor, and `limit`
- * to control the maximum number of returned items.
+ * The product an offer is checked out through. The backend sends one compound
+ * `{supplier}::{saleType}` string, verbatim as spelled below: a double colon
+ * between the two halves, `snake_case` within each. CoinList's token sale is
+ * `coinlist::token_sale`; there is no `coinlist::sale` and no
+ * `coinlist_token_sale`.
+ *
+ * Kept flat rather than split into a supplier and a sale type, because a flat
+ * union makes a `switch` over it exhaustive: adding a provider without
+ * handling it becomes a compile error.
  */
-interface PaginationParams {
-    before?: Cursor;
-    after?: Cursor;
-    limit?: number;
-}
-declare const PaginationParams: {
-    toQueryParams: (params: PaginationParams) => Record<string, QueryParamValue>;
+type OfferTypeDto = 'coinlist::token_sale' | 'superstate::swap' | 'ondo::swap' | 'centrifuge::vault';
+/**
+ * One variant per {@link OfferTypeDto}, mirroring frontline#1365, which keys
+ * `GET /v1/offers` on `type`. Read `type` first: it decides which of the
+ * fields below mean anything.
+ */
+type OfferDto = CoinListTokenSaleOfferDto | SuperstateSwapOfferDto | OndoSwapOfferDto | CentrifugeVaultOfferDto;
+type OfferBaseDto = {
+    id: string;
+    slug: string;
+    ends_at: string | null;
+    tokens: OfferTokenDto[];
+};
+/**
+ * A curated sale window and the hand-authored copy that goes with it. Required
+ * on every variant that runs such a campaign, which is every one but Ondo.
+ */
+type OfferEditorialDto = {
+    tagline: string;
+    banner_url: string;
+    starts_at: string;
+};
+/**
+ * What an Ondo swap or a Centrifuge vault sends in place of
+ * {@link OfferEditorialDto}. Neither runs a campaign, so the keys arrive as
+ * `null` and carry nothing, and the backend may stop sending them at all.
+ * Declared so a fixture can describe the real payload; no `fromDto` reads
+ * them.
+ */
+type OfferNoEditorialDto = {
+    tagline?: null;
+    banner_url?: null;
+    starts_at?: null;
 };
-
-type AssetDto = {
-    code: string;
-    fractional_digits: number;
-    id: string;
-    name: string;
+type CoinListTokenSaleOfferDto = OfferBaseDto & OfferEditorialDto & {
+    type: 'coinlist::token_sale';
+    logo_url: string;
 };
-
-type AssetId = Newtype<string, 'AssetId'>;
-declare const AssetId: (value: string) => AssetId;
-type AssetCode = Newtype<string, 'AssetCode'>;
-declare const AssetCode: (value: string) => AssetCode;
-type Asset = {
-    id: AssetId;
-    code: AssetCode;
-    name: string;
-    fractionalDigits: number;
+type SuperstateSwapOfferDto = OfferBaseDto & OfferEditorialDto & {
+    type: 'superstate::swap';
+    /** Publishing a swap does not require anyone to upload artwork for it. */
+    logo_url: string | null;
 };
-declare const Asset: {
-    fromDto: (dto: AssetDto) => Asset;
+type OndoSwapOfferDto = OfferBaseDto & OfferNoEditorialDto & {
+    type: 'ondo::swap';
+    /** Publishing a swap does not require anyone to upload artwork for it. */
+    logo_url: string | null;
 };
-
-type ParticipationStatusDto = 'prepared' | 'pending' | 'submitted' | 'completed' | 'failed' | 'remit_submitted' | 'remitted' | 'remit_failed';
-type ParticipationDto = {
-    object: 'participation';
-    id: string;
-    offer_id: string;
-    offer_option_id: string;
-    status: ParticipationStatusDto;
-    amount: string;
-    amount_string: string;
-    asset: AssetDto;
-    chain: string;
-    inserted_at: string | null | undefined;
-    updated_at: string | null | undefined;
-    wallet_address: string | null | undefined;
+type CentrifugeVaultOfferDto = OfferBaseDto & OfferNoEditorialDto & {
+    type: 'centrifuge::vault';
+    /** Publishing a vault does not require anyone to upload artwork for it. */
+    logo_url: string | null;
 };
-type CreateParticipationDto = {
-    offer_id: string;
-    offer_option_id: string;
+type OfferTokenDto = {
+    /**
+     * `vault` is the share token a `centrifuge::vault` offer issues for
+     * deposits, as `swap` is the token a swap offer trades into.
+     */
+    role: 'funding' | 'distribution' | 'swap' | 'vault';
     chain: string;
-    wallet_address: string;
-    amount: string;
-    asset_id: string;
-    approval_transaction_hash: string | null | undefined;
+    address: string;
 };
 
 /**
  * One variant per `OfferTypeDto`, the same split as `OfferDto` with what
  * `GET /v1/offers/:id` adds on top. Read `type` first.
  */
-type OfferDetailDto = CoinListTokenSaleOfferDetailDto | SuperstateSwapOfferDetailDto | OndoSwapOfferDetailDto;
-type CoinListTokenSaleOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & {
+type OfferDetailDto = CoinListTokenSaleOfferDetailDto | SuperstateSwapOfferDetailDto | OndoSwapOfferDetailDto | CentrifugeVaultOfferDetailDto;
+type CoinListTokenSaleOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & OfferDetailNoVaultContractsDto & {
     type: 'coinlist::token_sale';
     logo_url: string;
 };
-type SuperstateSwapOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & {
+type SuperstateSwapOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & OfferDetailNoVaultContractsDto & {
     type: 'superstate::swap';
     logo_url: string | null;
 };
-type OndoSwapOfferDetailDto = OfferDetailBaseDto & OfferNoEditorialDto & {
+type OndoSwapOfferDetailDto = OfferDetailBaseDto & OfferNoEditorialDto & OfferDetailNoVaultContractsDto & {
     type: 'ondo::swap';
     logo_url: string | null;
     /**
@@ -1463,6 +1920,19 @@ type OndoSwapOfferDetailDto = OfferDetailBaseDto & OfferNoEditorialDto & {
      */
     swap_contracts: OfferDetailSwapContractDto[];
 };
+type CentrifugeVaultOfferDetailDto = OfferDetailBaseDto & OfferNoEditorialDto & OfferDetailNoSwapContractsDto & {
+    type: 'centrifuge::vault';
+    logo_url: string | null;
+    /**
+     * Every chain this vault takes deposits on, with the CoinList proxy each
+     * request goes through. `[]` is an answer - "deposits nowhere", which is
+     * every vault until a proxy is deployed - and a missing key is not.
+     */
+    vault_contracts: OfferDetailVaultContractDto[];
+};
+type OfferDetailNoVaultContractsDto = {
+    vault_contracts?: OfferDetailVaultContractDto[];
+};
 /**
  * An offer that does not settle through a CoinList swap contract sends `[]`
  * or no key at all, and either way there is nothing to read. Declared so a
@@ -1529,6 +1999,104 @@ type OfferDetailSwapContractDto = {
     chain: string;
     address: string;
 };
+type OfferDetailVaultContractDto = {
+    chain: string;
+    address: string;
+};
+
+type OfferId = Newtype<string, 'OfferId'>;
+declare const OfferId: (value: string) => OfferId;
+type OfferSlug = Newtype<string, 'OfferSlug'>;
+declare const OfferSlug: (value: string) => OfferSlug;
+type OfferType = OfferTypeDto;
+declare const isOfferType: (value: string) => value is OfferType;
+type OfferBase = {
+    id: OfferId;
+    slug: OfferSlug;
+    endsAt: Date | null;
+    tokens: OfferToken[];
+};
+type CoinListTokenSaleOffer = OfferBase & OfferEditorial & {
+    type: 'coinlist::token_sale';
+    logoUrl: string;
+};
+type SuperstateSwapOffer = OfferBase & OfferEditorial & {
+    type: 'superstate::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
+};
+type OndoSwapOffer = OfferBase & {
+    type: 'ondo::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
+};
+type CentrifugeVaultOffer = OfferBase & {
+    type: 'centrifuge::vault';
+    /** Null when nobody has uploaded artwork: a vault publishes without it. */
+    logoUrl: string | null;
+};
+/**
+ * A curated sale window and the hand-authored copy that goes with it. Every
+ * variant that runs such a campaign carries all three, validated; an Ondo swap
+ * trades continuously and a Centrifuge vault takes deposits continuously, so
+ * neither runs one and neither carries any.
+ */
+type OfferEditorial = {
+    tagline: string;
+    bannerUrl: string;
+    startsAt: Date;
+};
+declare const OfferEditorial: {
+    /**
+     * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+     * the same three checks name the payload that failed them.
+     */
+    fromDto: (dto: OfferEditorialDto, model: string) => OfferEditorial;
+};
+/**
+ * An offer as `GET /v1/offers` lists it: a union on {@link OfferType}, each
+ * variant carrying only the fields that mean something for it. Narrow on
+ * `type` before reading anything beyond {@link OfferBase} - an Ondo swap has
+ * no `startsAt` to read, and the compiler says so.
+ */
+type Offer = CoinListTokenSaleOffer | SuperstateSwapOffer | OndoSwapOffer | CentrifugeVaultOffer;
+declare const Offer: {
+    fromDto: (dto: OfferDto) => Offer;
+    /**
+     * Maps a page of offers, dropping every offer whose `type` this SDK does not
+     * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+     * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+     * reject the whole page, so one offer of an unknown type would blank the
+     * grid for every offer beside it. A single offer fetched by id still
+     * throws, because there is nothing beside it to keep.
+     */
+    listFromDto: (dtos: OfferDto[]) => Offer[];
+};
+/**
+ * `vault` is the share token a `centrifuge::vault` offer issues for deposits,
+ * as `swap` is the token a swap offer trades into.
+ */
+type TokenRole = 'funding' | 'distribution' | 'swap' | 'vault';
+type OfferToken = {
+    role: TokenRole;
+    chain: Chain;
+    address: EvmContractAddress;
+};
+declare const OfferToken: {
+    fromDto: (dto: OfferTokenDto) => OfferToken;
+    /**
+     * Maps an offer's token list, dropping every token on a chain this SDK does
+     * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
+     * plain `.map` would throw out of `Offer.fromDto` and, through
+     * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
+     * one Base token blanked production's offers list. Dropping costs that
+     * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
+     * so nobody could have looked it up anyway.
+     *
+     * Same shape as `TokenMetadata.fromRegistryDto`.
+     */
+    listFromDto: (dtos: OfferTokenDto[]) => OfferToken[];
+};
 
 type Ticker = Newtype<string, 'Ticker'>;
 declare const Ticker: (value: string) => Ticker;
@@ -1547,6 +2115,28 @@ type Isin = Newtype<string, 'Isin'>;
 declare const Isin: (value: string) => Isin;
 type OrderBookSide = 'buy' | 'sell';
 
+/** The `type` of every {@link AsyncOfferDetail}. */
+type AsyncOfferType = AsyncOfferDetail['type'];
+/**
+ * An offer whose trade settles later: the user places a request, the fund
+ * fills it on its own schedule, and the user comes back to claim the result.
+ * Only these have a second leg for `ClaimContainer` to show.
+ *
+ * A subset of {@link OfferDetail} picked by `type`, so it narrows like any
+ * other variant and a new async provider is one more member here.
+ */
+type AsyncOfferDetail = CentrifugeVaultOfferDetail;
+declare const AsyncOfferDetail: {
+    /**
+     * Narrows an offer fetched generically, e.g. on an offer page, to one with
+     * something to claim.
+     *
+     * An exhaustive `switch` rather than a list of async types, so a new offer
+     * type is a compile error here until someone decides whether it settles
+     * later.
+     */
+    is: (offer: OfferDetail) => offer is AsyncOfferDetail;
+};
 type CoinListTokenSaleOfferDetail = OfferDetailBase & OfferEditorial & {
     type: 'coinlist::token_sale';
     logoUrl: string;
@@ -1566,6 +2156,16 @@ type OndoSwapOfferDetail = OfferDetailBase & {
      */
     swapContracts: OfferSwapContract[];
 };
+type CentrifugeVaultOfferDetail = OfferDetailBase & {
+    type: 'centrifuge::vault';
+    /** Null when nobody has uploaded artwork: a vault publishes without it. */
+    logoUrl: string | null;
+    /**
+     * Every chain this vault takes deposits on, with the CoinList proxy each
+     * request goes through. Empty means it takes deposits nowhere yet.
+     */
+    vaultContracts: OfferVaultContract[];
+};
 type OfferDetailBase = {
     id: OfferId;
     slug: OfferSlug;
@@ -1643,13 +2243,38 @@ type OfferSwapContract = {
 declare const OfferSwapContract: {
     fromDto: (dto: OfferDetailSwapContractDto) => OfferSwapContract;
 };
+/**
+ * A chain a Centrifuge vault takes deposits on, with the CoinList proxy the
+ * request goes through. Not a token, so the token registry knows nothing about
+ * it: it is the spender the user approves the funding token to, and the `to`
+ * the buy and claim transactions are sent to.
+ *
+ * Its own type rather than an {@link OfferSwapContract}, although the shape is
+ * the same, because the meaning is not: a swap contract serves every Ondo
+ * asset on its chain, while a proxy belongs to one offer on one chain, so the
+ * same chain carries a different address on every vault.
+ */
+type OfferVaultContract = {
+    chain: Chain;
+    address: EvmContractAddress;
+};
+declare const OfferVaultContract: {
+    fromDto: (dto: OfferDetailVaultContractDto) => OfferVaultContract;
+    /**
+     * Drops every proxy on a chain this SDK does not name, as
+     * `OfferToken.listFromDto` does: frontline publishes the full offer-token
+     * chain list, which runs ahead of {@link Chain}, and one unmodelled chain
+     * should not throw away the proxies the SDK can use.
+     */
+    listFromDto: (dtos: OfferDetailVaultContractDto[]) => OfferVaultContract[];
+};
 /**
  * An offer as `GET /v1/offers/:id` serves it: the same union on `type` as
  * {@link Offer}, each variant carrying only the fields that mean something
  * for it. Narrow on `type` before reading anything beyond
  * {@link OfferDetailBase}.
  */
-type OfferDetail = CoinListTokenSaleOfferDetail | SuperstateSwapOfferDetail | OndoSwapOfferDetail;
+type OfferDetail = CoinListTokenSaleOfferDetail | SuperstateSwapOfferDetail | OndoSwapOfferDetail | CentrifugeVaultOfferDetail;
 declare const OfferDetail: {
     fromDto: (dto: OfferDetailDto) => OfferDetail;
 };
@@ -1696,6 +2321,74 @@ declare const Milestone: {
     fromDto: (dto: OfferDetailMilestoneDto) => Milestone;
 };
 
+/**
+ * The cursor-paginated envelope every list endpoint returns.
+ *
+ * Generic in its item type, so each resource pairs it with its own item DTO
+ * rather than declaring an envelope of its own.
+ */
+interface PaginatedResponseDto<T> {
+    data: T[];
+    starting_after?: string;
+    starting_before?: string;
+}
+
+type Cursor = Newtype<string, 'Cursor'>;
+declare const Cursor: (value: string) => Cursor;
+interface PaginatedResponse<T> {
+    data: T[];
+    startingAfter: Cursor | null;
+    startingBefore: Cursor | null;
+}
+declare const PaginatedResponse: {
+    fromDto: <A, B>(dto: PaginatedResponseDto<A>, itemMapper: (item: A) => B) => PaginatedResponse<B>;
+    /**
+     * For a mapper that decides the page as a whole - one that drops items it
+     * cannot map, such as `Offer.listFromDto` - rather than item by item. The
+     * cursors are the wire's either way: dropping an item changes what the
+     * page holds, not where the next page starts.
+     */
+    fromDtoPage: <A, B>(dto: PaginatedResponseDto<A>, pageMapper: (items: A[]) => B[]) => PaginatedResponse<B>;
+};
+/**
+ * Cursor-based pagination input used when requesting paginated API resources.
+ * Set `after` or `before` to navigate relative to a known cursor, and `limit`
+ * to control the maximum number of returned items.
+ */
+interface PaginationParams {
+    before?: Cursor;
+    after?: Cursor;
+    limit?: number;
+}
+declare const PaginationParams: {
+    toQueryParams: (params: PaginationParams) => Record<string, QueryParamValue>;
+};
+
+type ParticipationStatusDto = 'prepared' | 'pending' | 'submitted' | 'completed' | 'failed' | 'remit_submitted' | 'remitted' | 'remit_failed';
+type ParticipationDto = {
+    object: 'participation';
+    id: string;
+    offer_id: string;
+    offer_option_id: string;
+    status: ParticipationStatusDto;
+    amount: string;
+    amount_string: string;
+    asset: AssetDto;
+    chain: string;
+    inserted_at: string | null | undefined;
+    updated_at: string | null | undefined;
+    wallet_address: string | null | undefined;
+};
+type CreateParticipationDto = {
+    offer_id: string;
+    offer_option_id: string;
+    chain: string;
+    wallet_address: string;
+    amount: string;
+    asset_id: string;
+    approval_transaction_hash: string | null | undefined;
+};
+
 /** Unique identifier for a participation. */
 type ParticipationId = Newtype<string, 'ParticipationId'>;
 /** Casts a string into a typed {@link ParticipationId}. */
@@ -2436,6 +3129,17 @@ declare const OndoSellTransaction: {
  */
 interface OndoNamespace {
     getTradingStatus(params: GetOndoTradingStatusParams): Promise<OndoTradingStatus>;
+    /**
+     * An indicative price for `params`' size, from Ondo's live market.
+     *
+     * Ondo refuses to quote while the market is closed or paused, or the asset
+     * is paused or closed for the session - including for about a minute at
+     * every US session change, when `getTradingStatus` may still have reported
+     * the asset tradable. The request then rejects with a 409 carrying
+     * `code: "not_tradable"`; tell it apart from a failure with
+     * {@link isOndoNotTradableError}. Retrying before the market opens fails the
+     * same way.
+     */
     getQuote(params: GetOndoQuoteParams): Promise<OndoQuote>;
     /**
      * Builds a purchase for a specific wallet and deposit: spends an attestation
@@ -3298,4 +4002,51 @@ declare class TokensNamespaceImpl implements TokensNamespace {
     list(chain?: EthereumChain): Promise<TokenMetadata[]>;
 }
 
-export { OndoTradingStatus as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, TokenMetadata as D, type Erc20Namespace as E, type OfferType as F, type OndoSwapOfferDetail as G, type CoinListTokenSaleOfferDetail as H, type SuperstateSwapOfferDetail as I, Offer as J, RequirementStatusInfo as K, type Logger as L, type RequirementType as M, type RequirementStatusValue as N, OfferId as O, Participation as P, OfferOptionAddress as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, RequirementId as V, type WalletError as W, type KycLevelName as X, DocumentSubmission as Y, type WalletChallengeType as Z, type PinoLoggerOptions as _, EthereumChain as a, type GetTokenBalanceParams as a$, AssetDecimals as a0, type BuildOndoBuyParams as a1, type BuildOndoSellParams as a2, OndoQuote as a3, type OndoQuoteSize as a4, type TokenIdentifier as a5, OfferOptionAddressId as a6, TokenLogo as a7, type DebugEvent as a8, type FrontlineEventId as a9, type Newtype as aA, type AllowWalletParams as aB, AllowWalletResponse as aC, Asset as aD, AssetCode as aE, Blockchain as aF, type BuildOndoSwapParamsCore as aG, Chain as aH, ClientId as aI, CodeChallenge as aJ, type CoinListTokenSaleOffer as aK, ConnectExternalWalletParams as aL, type CreateKycTokenParams as aM, CreateParticipationParams as aN, CreateWalletOwnershipChallengeParams as aO, Cursor as aP, type DocumentFormType as aQ, type DocumentSubmissionStatus as aR, type DocumentType as aS, ETHEREUM_CHAINS as aT, Erc20NamespaceImpl as aU, FaqItem as aV, type GetOndoQuoteParams as aW, type GetOndoTradingStatusParams as aX, type GetSwapAuthorizationParams as aY, type GetSwapPreviewParams as aZ, type GetTokenAllowanceParams as a_, HttpError as aa, type HttpResponse as ab, KycToken as ac, type LogBinding as ad, type LogBindings as ae, type LogCause as af, type LogLevel as ag, type LogScope as ah, type LogValue as ai, type ProductionLogLevel as aj, RedactedWalletError as ak, type RequestId as al, type RpcFailureReason as am, type SafeEvent as an, type SafeFields as ao, type UnredactedFields as ap, OAuthSession as aq, ClientCredentialsOAuth as ar, ClientSecret as as, type Sender as at, PaginationParams as au, PaginatedResponse as av, DecimalString as aw, SwapStatus as ax, type Uint256 as ay, KnownAssetSymbol as az, EvmContractAddress as b, HexEncodedTransactionData as b0, Isin as b1, Iso2CountryCode as b2, Link as b3, type ListOptionAddressesParams as b4, MAX_ASSET_DECIMALS as b5, MAX_UINT_256 as b6, Milestone as b7, OAuthRefreshToken as b8, type OfferBase as b9, SOLANA_CHAINS as bA, STABLE_DECIMALS as bB, SolanaChain as bC, type SubmitDocumentParams as bD, type SuperstateSwapOffer as bE, type SwapContractRef as bF, SwapPreview as bG, TermItem as bH, Ticker as bI, type TokenLogoImage as bJ, TokenLogoUrl as bK, type TokenRole as bL, TokensNamespaceImpl as bM, type Tx as bN, WalletAddress as bO, WalletOwnershipChallenge as bP, type WalletProtocol as bQ, WalletsNamespaceImpl as bR, apiErrorCode as bS, assertUint256 as bT, isChain as bU, isOfferType as bV, parseUint256 as bW, type OfferDetailBase as ba, OfferEditorial as bb, OfferOption as bc, OfferOptionSlug as bd, OfferSlug as be, OfferToken as bf, OffersNamespaceImpl as bg, type OndoQuoteDuration as bh, type OndoSellOutcome as bi, type OndoSwapOffer as bj, PKCEState as bk, type PaginatedResponseDto as bl, ParticipationId as bm, type ParticipationStatus as bn, ParticipationsPaginationParams as bo, PauseFlags as bp, Pii as bq, PiiAddress as br, PiiJurisdiction as bs, type PiiKind as bt, type QueryParamValue as bu, type QueryParamValues as bv, RedirectUri as bw, type RemoveOptionAddressParams as bx, type RequirementActionNeededReason as by, type RpcConfig as bz, type CoinListTokenSaleNamespace as c, OfferOptionId as d, AssetId as e, CoinListTokenSaleNamespaceImpl as f, type OndoNamespace as g, AssetSymbol as h, OfferSwapContract as i, OndoBuyTransaction as j, OndoSellTransaction as k, type OndoSwapTransactionCore as l, type OrderBookSide as m, OndoNamespaceImpl as n, type WalletsNamespace as o, Bps as p, EvmWalletAddress as q, SuperstateSwapNamespaceImpl as r, Requirement as s, RequirementsNamespaceImpl as t, type Config as u, type OAuthAccessToken as v, type OffersNamespace as w, StablecoinSymbol as x, type Erc20Asset as y, OfferDetail as z };
+/**
+ * An instant: milliseconds since the Unix epoch, as `Date.now()` reads it.
+ * Distinct from {@link Millis}, a duration, so an instant cannot be passed
+ * where a timeout is expected or the other way round.
+ */
+type EpochMillis = Newtype<number, 'EpochMillis'>;
+declare const EpochMillis: {
+    /**
+     * @throws {@link ValidationError} unless `value` is an integer a `Date` can
+     * represent: at most {@link MAX_EPOCH_MILLIS} either side of the epoch.
+     */
+    of: (value: number) => EpochMillis;
+    /** The wall clock. Code that needs the time takes a `TimeEff` instead. */
+    now: () => EpochMillis;
+    /** @throws {@link ValidationError} for an invalid `Date`. */
+    fromDate: (date: Date) => EpochMillis;
+    /** How long after `from` the instant `to` is; negative if it is before. */
+    elapsed: (from: EpochMillis, to: EpochMillis) => Millis;
+    plus: (at: EpochMillis, duration: Millis) => EpochMillis;
+};
+/**
+ * A duration in milliseconds. May be negative: the gap between two instants
+ * read off a wall clock that stepped back in between.
+ */
+type Millis = Newtype<number, 'Millis'>;
+declare const Millis: {
+    of: (value: number) => Millis;
+};
+/** A duration in whole, non-negative seconds. */
+type Seconds = Newtype<number, 'Seconds'>;
+declare const Seconds: {
+    /**
+     * @throws {@link ValidationError} unless `value` is a non-negative integer.
+     */
+    of: (value: number) => Seconds;
+    toMillis: (value: Seconds) => Millis;
+};
+/**
+ * Whether `expiresAt` has passed at `now`, counting it as passed `buffer`
+ * early. The boundary instant itself counts as expired.
+ */
+declare function isExpired({ expiresAt, now, buffer, }: {
+    expiresAt: EpochMillis;
+    now: EpochMillis;
+    buffer?: Millis;
+}): boolean;
+
+export { AsyncOfferDetail as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, type OAuthAccessToken as D, type Erc20Namespace as E, type OffersNamespace as F, DecimalString as G, StablecoinSymbol as H, type Erc20Asset as I, OfferDetail as J, TokenMetadata as K, type Logger as L, type CentrifugeVaultOfferDetail as M, type OfferType as N, OfferVaultContract as O, Participation as P, type OndoSwapOfferDetail as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, type CoinListTokenSaleOfferDetail as V, type WalletError as W, type SuperstateSwapOfferDetail as X, CentrifugeVaultLegId as Y, Seconds as Z, type AsyncOfferType as _, EthereumChain as a, type CentrifugeVaultOffer as a$, Offer as a0, RequirementStatusInfo as a1, type RequirementType as a2, type RequirementStatusValue as a3, OfferOptionAddress as a4, RequirementId as a5, type KycLevelName as a6, DocumentSubmission as a7, type WalletChallengeType as a8, type PinoLoggerOptions as a9, type ProductionLogLevel as aA, RedactedWalletError as aB, type RequestId as aC, type RpcFailureReason as aD, type SafeEvent as aE, type SafeFields as aF, type UnredactedFields as aG, OAuthSession as aH, ClientCredentialsOAuth as aI, type Sender as aJ, PaginationParams as aK, PaginatedResponse as aL, ClientSecret as aM, OfferToken as aN, SwapStatus as aO, type Uint256 as aP, KnownAssetSymbol as aQ, type Newtype as aR, type AllowWalletParams as aS, AllowWalletResponse as aT, Asset as aU, AssetCode as aV, Blockchain as aW, type BuildOndoSwapParamsCore as aX, type CentrifugePositionStatus as aY, CentrifugeVaultClaimProceedsTransaction as aZ, CentrifugeVaultClaimTransaction as a_, AssetDecimals as aa, type BuildCentrifugeVaultBuyParams as ab, CentrifugeVaultQuote as ac, type CentrifugeOrderReason as ad, type CentrifugeOrderability as ae, OndoTradingStatus as af, type BuildOndoBuyParams as ag, type BuildOndoSellParams as ah, OndoQuote as ai, type OndoQuoteSize as aj, type TokenIdentifier as ak, CentrifugeVaultLeg as al, OfferOptionAddressId as am, CentrifugeVaultStatus as an, TokenLogo as ao, type DebugEvent as ap, type FrontlineEventId as aq, HttpError as ar, type HttpResponse as as, KycToken as at, type LogBinding as au, type LogBindings as av, type LogCause as aw, type LogLevel as ax, type LogScope as ay, type LogValue as az, EvmContractAddress as b, type RequirementActionNeededReason as b$, CentrifugeVaultPosition as b0, type CentrifugeVaultReason as b1, CentrifugeVaultRedeemPosition as b2, type CentrifugeVaultTransactionCore as b3, type CentrifugeWalletParams as b4, Chain as b5, ClientId as b6, CodeChallenge as b7, type CoinListTokenSaleOffer as b8, ConnectExternalWalletParams as b9, Milestone as bA, Millis as bB, OAuthRefreshToken as bC, type OfferBase as bD, type OfferDetailBase as bE, OfferEditorial as bF, OfferOption as bG, OfferOptionSlug as bH, OfferSlug as bI, OffersNamespaceImpl as bJ, type OndoQuoteDuration as bK, type OndoSellOutcome as bL, type OndoSwapOffer as bM, PKCEState as bN, type PaginatedResponseDto as bO, ParticipationId as bP, type ParticipationStatus as bQ, ParticipationsPaginationParams as bR, PauseFlags as bS, Pii as bT, PiiAddress as bU, PiiJurisdiction as bV, type PiiKind as bW, type QueryParamValue as bX, type QueryParamValues as bY, RedirectUri as bZ, type RemoveOptionAddressParams as b_, type CreateKycTokenParams as ba, CreateParticipationParams as bb, CreateWalletOwnershipChallengeParams as bc, Cursor as bd, type DocumentFormType as be, type DocumentSubmissionStatus as bf, type DocumentType as bg, ETHEREUM_CHAINS as bh, EpochMillis as bi, Erc20NamespaceImpl as bj, FaqItem as bk, type GetCentrifugeVaultQuoteParams as bl, type GetCentrifugeVaultStatusParams as bm, type GetOndoQuoteParams as bn, type GetOndoTradingStatusParams as bo, type GetSwapAuthorizationParams as bp, type GetSwapPreviewParams as bq, type GetTokenAllowanceParams as br, type GetTokenBalanceParams as bs, HexEncodedTransactionData as bt, Isin as bu, Iso2CountryCode as bv, Link as bw, type ListOptionAddressesParams as bx, MAX_ASSET_DECIMALS as by, MAX_UINT_256 as bz, type CentrifugeNamespace as c, type RpcConfig as c0, SOLANA_CHAINS as c1, STABLE_DECIMALS as c2, SolanaChain as c3, type SubmitDocumentParams as c4, type SuperstateSwapOffer as c5, type SwapContractRef as c6, SwapPreview as c7, TermItem as c8, Ticker as c9, type TokenLogoImage as ca, TokenLogoUrl as cb, type TokenRole as cc, TokensNamespaceImpl as cd, type Tx as ce, WalletAddress as cf, WalletOwnershipChallenge as cg, type WalletProtocol as ch, WalletsNamespaceImpl as ci, apiErrorCode as cj, assertUint256 as ck, isChain as cl, isExpired as cm, isOfferType as cn, parseUint256 as co, AssetSymbol as d, CentrifugeVaultBuyTransaction as e, type CentrifugeClaimDirection as f, CentrifugeNamespaceImpl as g, type CoinListTokenSaleNamespace as h, OfferId as i, OfferOptionId as j, AssetId as k, CoinListTokenSaleNamespaceImpl as l, type OndoNamespace as m, OfferSwapContract as n, OndoBuyTransaction as o, OndoSellTransaction as p, type OndoSwapTransactionCore as q, type OrderBookSide as r, OndoNamespaceImpl as s, type WalletsNamespace as t, Bps as u, EvmWalletAddress as v, SuperstateSwapNamespaceImpl as w, Requirement as x, RequirementsNamespaceImpl as y, type Config as z };