@coinlist-co/react 0.12.2-rc.a59b344 → 0.12.2-rc.aa91ce3

package/dist/{tokens-namespace-D_XSpiS-.d.cts → time-DyjvzWso.d.cts}

@@ -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
@@ -821,16 +821,36 @@ type Erc20Asset = {
 type Bps = Newtype<bigint, 'Bps'>;
 declare const Bps: (value: bigint) => Bps;
 
-type GetTokenAllowanceParams = {
-    tokenAddress: EvmContractAddress;
-    owner: EvmWalletAddress;
-    spender: EvmContractAddress;
+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 GetTokenBalanceParams = {
-    tokenAddress: EvmContractAddress;
-    owner: EvmWalletAddress;
-    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;
 };
 
 /**
@@ -1148,37 +1168,6 @@ interface UniversalNamespaceContext {
     ensureUserAuthenticated(): Promise<void>;
 }
 
-/**
- * Generic ERC-20 reads shared across on-chain flows (swap, token sale): the
- * allowance an owner has granted a spender, and the raw token balance an owner
- * holds. These are plain token reads, not tied to any single product flow.
- *
- * Read from the chain rather than from a CoinList endpoint. By default that
- * goes through CoinList's authenticated JSON-RPC proxy, so a logged-out caller
- * gets the proxy's `401` - surfaced as a viem error wrapping the SDK's
- * `HttpError`, not as `NotAuthenticatedError`, since viem re-wraps whatever a
- * `Transport` throws. Point `Config.rpc` at your own node for this chain and no
- * CoinList session is involved at all. See {@link RpcConfig}.
- */
-interface Erc20Namespace {
-    /**
-     * Reads the ERC-20 allowance an `owner` has granted a `spender`, as a raw
-     * on-chain integer.
-     */
-    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
-    /**
-     * Reads the raw ERC-20 balance an `owner` holds of a token.
-     */
-    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
-}
-declare class Erc20NamespaceImpl implements Erc20Namespace {
-    private readonly ctx;
-    private readonly log;
-    constructor(ctx: UniversalNamespaceContext);
-    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
-    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
-}
-
 /**
  * The logging surface SDK code uses. Never exported to hosts: they implement
  * {@link Logger}, which is deliberately smaller.
@@ -1256,6 +1245,541 @@ type InternalDebugEvent = {
     readonly fields?: UnredactedFields;
 };
 
+/**
+ * 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.
+ *
+ * **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:
+ * `buy` is signed for one wallet and called once on confirmation, `claim`
+ * collects everything claimable and carries no amount.
+ */
+/**
+ * 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 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'>;
+/**
+ * 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 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;
+};
+/**
+ * `POST /v1/centrifuge/vault/buy` with `{ symbol, chain, wallet_address,
+ * amount }`. Broadcasting it places a request in the vault's queue and buys
+ * nothing yet.
+ */
+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;
+};
+/**
+ * `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;
+};
+/**
+ * `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;
+};
+/**
+ * `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;
+    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;
+};
+
+/**
+ * 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[]];
+};
+/**
+ * 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>;
+};
+declare const CentrifugeVaultQuote: {
+    fromDto: (dto: CentrifugeVaultQuoteDto) => CentrifugeVaultQuote;
+};
+/**
+ * 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;
+};
+/**
+ * What both vault transactions share: calldata to broadcast verbatim, and the
+ * deadline on it.
+ */
+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;
+};
+/**
+ * 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 & {
+    /**
+     * Read when the calldata was built. A floor: a fill landing before the
+     * broadcast raises it, and the claim still collects everything.
+     */
+    claimableShares: BlockchainAmount;
+};
+declare const CentrifugeVaultClaimTransaction: {
+    fromDto: (dto: CentrifugeVaultClaimDto) => CentrifugeVaultClaimTransaction;
+};
+/**
+ * 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 CentrifugeVaultPosition = {
+    chain: EthereumChain;
+    symbol: AssetSymbol;
+    walletAddress: EvmWalletAddress;
+    /**
+     * 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.
+     */
+    claimableAssets: BlockchainAmount;
+    /** Centrifuge froze this wallet on the share token. Blocks claiming. */
+    frozen: boolean;
+    asOf: Date;
+};
+declare const CentrifugeVaultRedeemPosition: {
+    fromDto: (dto: CentrifugeVaultRedeemPositionDto) => CentrifugeVaultRedeemPosition;
+};
+/**
+ * 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: {
+    /**
+     * What a claim on the leg would collect: shares for `invest`, the funding
+     * token for `redeem`.
+     */
+    claimable: (leg: CentrifugeVaultLeg) => BlockchainAmount;
+    /** Whether the leg has anything queued or anything ready to claim. */
+    isActive: (leg: CentrifugeVaultLeg) => boolean;
+};
+/**
+ * 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.
+ *
+ * TODO(frontline, ENG-1909): built against a guessed wire shape - see
+ * `CentrifugeVaultClaimProceedsDto`.
+ */
+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;
+};
+
+/**
+ * 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.
+ *
+ * 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>;
+    /**
+     * The wallet's redeem position: shares queued, funding claimable.
+     *
+     * TODO(frontline, ENG-1909): built against a guessed endpoint.
+     */
+    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>;
+}
+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>;
+}
+
+type GetTokenAllowanceParams = {
+    tokenAddress: EvmContractAddress;
+    owner: EvmWalletAddress;
+    spender: EvmContractAddress;
+    chain: EthereumChain;
+};
+type GetTokenBalanceParams = {
+    tokenAddress: EvmContractAddress;
+    owner: EvmWalletAddress;
+    chain: EthereumChain;
+};
+
+/**
+ * Generic ERC-20 reads shared across on-chain flows (swap, token sale): the
+ * allowance an owner has granted a spender, and the raw token balance an owner
+ * holds. These are plain token reads, not tied to any single product flow.
+ *
+ * Read from the chain rather than from a CoinList endpoint. By default that
+ * goes through CoinList's authenticated JSON-RPC proxy, so a logged-out caller
+ * gets the proxy's `401` - surfaced as a viem error wrapping the SDK's
+ * `HttpError`, not as `NotAuthenticatedError`, since viem re-wraps whatever a
+ * `Transport` throws. Point `Config.rpc` at your own node for this chain and no
+ * CoinList session is involved at all. See {@link RpcConfig}.
+ */
+interface Erc20Namespace {
+    /**
+     * Reads the ERC-20 allowance an `owner` has granted a `spender`, as a raw
+     * on-chain integer.
+     */
+    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
+    /**
+     * Reads the raw ERC-20 balance an `owner` holds of a token.
+     */
+    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
+}
+declare class Erc20NamespaceImpl implements Erc20Namespace {
+    private readonly ctx;
+    private readonly log;
+    constructor(ctx: UniversalNamespaceContext);
+    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
+    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
+}
+
 /**
  * The product an offer is checked out through. The backend sends one compound
  * `{supplier}::{saleType}` string, verbatim as spelled below: a double colon
@@ -1636,6 +2160,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;
@@ -3433,4 +3979,51 @@ declare class TokensNamespaceImpl implements TokensNamespace {
     list(chain?: EthereumChain): Promise<TokenMetadata[]>;
 }
 
-export { type PinoLoggerOptions as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, TokenMetadata as D, type Erc20Namespace as E, type CentrifugeVaultOfferDetail as F, type OfferType as G, type OndoSwapOfferDetail as H, type CoinListTokenSaleOfferDetail as I, type SuperstateSwapOfferDetail as J, Offer as K, type Logger as L, RequirementStatusInfo as M, type RequirementType as N, OfferId as O, Participation as P, type RequirementStatusValue as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, OfferOptionAddress as V, type WalletError as W, RequirementId as X, type KycLevelName as Y, DocumentSubmission as Z, type WalletChallengeType as _, EthereumChain as a, type GetSwapAuthorizationParams as a$, OndoTradingStatus as a0, AssetDecimals as a1, type BuildOndoBuyParams as a2, type BuildOndoSellParams as a3, OndoQuote as a4, type OndoQuoteSize as a5, type TokenIdentifier as a6, OfferOptionAddressId as a7, TokenLogo as a8, type DebugEvent as a9, KnownAssetSymbol as aA, type Tx as aB, type Newtype as aC, type AllowWalletParams as aD, AllowWalletResponse as aE, Asset as aF, AssetCode as aG, Blockchain as aH, type BuildOndoSwapParamsCore as aI, type CentrifugeVaultOffer as aJ, Chain as aK, ClientId as aL, CodeChallenge as aM, type CoinListTokenSaleOffer as aN, ConnectExternalWalletParams as aO, type CreateKycTokenParams as aP, CreateParticipationParams as aQ, CreateWalletOwnershipChallengeParams as aR, Cursor as aS, type DocumentFormType as aT, type DocumentSubmissionStatus as aU, type DocumentType as aV, ETHEREUM_CHAINS as aW, Erc20NamespaceImpl as aX, FaqItem as aY, type GetOndoQuoteParams as aZ, type GetOndoTradingStatusParams as a_, type FrontlineEventId as aa, HttpError as ab, type HttpResponse as ac, KycToken as ad, type LogBinding as ae, type LogBindings as af, type LogCause as ag, type LogLevel as ah, type LogScope as ai, type LogValue as aj, type ProductionLogLevel as ak, RedactedWalletError as al, type RequestId as am, type RpcFailureReason as an, type SafeEvent as ao, type SafeFields as ap, type UnredactedFields as aq, OAuthSession as ar, ClientCredentialsOAuth as as, type Sender as at, PaginationParams as au, PaginatedResponse as av, ClientSecret as aw, DecimalString as ax, SwapStatus as ay, type Uint256 as az, EvmContractAddress as b, type GetSwapPreviewParams as b0, type GetTokenAllowanceParams as b1, type GetTokenBalanceParams as b2, HexEncodedTransactionData as b3, Isin as b4, Iso2CountryCode as b5, Link as b6, type ListOptionAddressesParams as b7, MAX_ASSET_DECIMALS as b8, MAX_UINT_256 as b9, RedirectUri as bA, type RemoveOptionAddressParams as bB, type RequirementActionNeededReason as bC, type RpcConfig as bD, SOLANA_CHAINS as bE, STABLE_DECIMALS as bF, SolanaChain as bG, type SubmitDocumentParams as bH, type SuperstateSwapOffer as bI, type SwapContractRef as bJ, SwapPreview as bK, TermItem as bL, Ticker as bM, type TokenLogoImage as bN, TokenLogoUrl as bO, type TokenRole as bP, TokensNamespaceImpl as bQ, WalletAddress as bR, WalletOwnershipChallenge as bS, type WalletProtocol as bT, WalletsNamespaceImpl as bU, apiErrorCode as bV, assertUint256 as bW, isChain as bX, isOfferType as bY, parseUint256 as bZ, Milestone as ba, OAuthRefreshToken as bb, type OfferBase as bc, type OfferDetailBase as bd, OfferEditorial as be, OfferOption as bf, OfferOptionSlug as bg, OfferSlug as bh, OfferToken as bi, OfferVaultContract as bj, OffersNamespaceImpl as bk, type OndoQuoteDuration as bl, type OndoSellOutcome as bm, type OndoSwapOffer as bn, PKCEState as bo, type PaginatedResponseDto as bp, ParticipationId as bq, type ParticipationStatus as br, ParticipationsPaginationParams as bs, PauseFlags as bt, Pii as bu, PiiAddress as bv, PiiJurisdiction as bw, type PiiKind as bx, type QueryParamValue as by, type QueryParamValues 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 { type RequirementType as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, StablecoinSymbol as D, EthereumChain as E, type Erc20Asset as F, OfferDetail as G, TokenMetadata as H, type CentrifugeVaultOfferDetail as I, type OfferType as J, type OndoSwapOfferDetail as K, type Logger as L, type CoinListTokenSaleOfferDetail as M, type SuperstateSwapOfferDetail as N, OfferId as O, Participation as P, CentrifugeVaultLegId as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, Seconds as V, type WalletError as W, type AsyncOfferType as X, AsyncOfferDetail as Y, Offer as Z, RequirementStatusInfo as _, type CentrifugeNamespace as a, type CentrifugeVaultReason as a$, type RequirementStatusValue as a0, OfferOptionAddress as a1, RequirementId as a2, type KycLevelName as a3, DocumentSubmission as a4, type WalletChallengeType as a5, type PinoLoggerOptions as a6, type CentrifugeOrderReason as a7, type CentrifugeOrderability as a8, CentrifugeVaultQuote as a9, type SafeEvent as aA, type SafeFields as aB, type UnredactedFields as aC, OAuthSession as aD, ClientCredentialsOAuth as aE, type Sender as aF, PaginationParams as aG, PaginatedResponse as aH, ClientSecret as aI, OfferToken as aJ, DecimalString as aK, SwapStatus as aL, type Uint256 as aM, KnownAssetSymbol as aN, type Newtype as aO, type AllowWalletParams as aP, AllowWalletResponse as aQ, Asset as aR, AssetCode as aS, Blockchain as aT, type BuildOndoSwapParamsCore as aU, type CentrifugePositionStatus as aV, CentrifugeVaultBuyTransaction as aW, CentrifugeVaultClaimProceedsTransaction as aX, CentrifugeVaultClaimTransaction as aY, type CentrifugeVaultOffer as aZ, CentrifugeVaultPosition as a_, OndoTradingStatus as aa, AssetDecimals as ab, type BuildOndoBuyParams as ac, type BuildOndoSellParams as ad, OndoQuote as ae, type OndoQuoteSize as af, type TokenIdentifier as ag, CentrifugeVaultLeg as ah, OfferOptionAddressId as ai, CentrifugeVaultStatus as aj, TokenLogo as ak, type DebugEvent as al, type FrontlineEventId as am, HttpError as an, type HttpResponse as ao, KycToken as ap, type LogBinding as aq, type LogBindings as ar, type LogCause as as, type LogLevel as at, type LogScope as au, type LogValue as av, type ProductionLogLevel as aw, RedactedWalletError as ax, type RequestId as ay, type RpcFailureReason as az, AssetSymbol as b, type RpcConfig as b$, CentrifugeVaultRedeemPosition as b0, type CentrifugeVaultTransactionCore as b1, type CentrifugeWalletParams as b2, Chain as b3, ClientId as b4, CodeChallenge as b5, type CoinListTokenSaleOffer as b6, ConnectExternalWalletParams as b7, type CreateKycTokenParams as b8, CreateParticipationParams as b9, OAuthRefreshToken as bA, type OfferBase as bB, type OfferDetailBase as bC, OfferEditorial as bD, OfferOption as bE, OfferOptionSlug as bF, OfferSlug as bG, OfferVaultContract as bH, OffersNamespaceImpl as bI, type OndoQuoteDuration as bJ, type OndoSellOutcome as bK, type OndoSwapOffer as bL, PKCEState as bM, type PaginatedResponseDto as bN, ParticipationId as bO, type ParticipationStatus as bP, ParticipationsPaginationParams as bQ, PauseFlags as bR, Pii as bS, PiiAddress as bT, PiiJurisdiction as bU, type PiiKind as bV, type QueryParamValue as bW, type QueryParamValues as bX, RedirectUri as bY, type RemoveOptionAddressParams as bZ, type RequirementActionNeededReason as b_, CreateWalletOwnershipChallengeParams as ba, Cursor as bb, type DocumentFormType as bc, type DocumentSubmissionStatus as bd, type DocumentType as be, ETHEREUM_CHAINS as bf, EpochMillis as bg, Erc20NamespaceImpl as bh, FaqItem as bi, type GetCentrifugeVaultQuoteParams as bj, type GetCentrifugeVaultStatusParams as bk, type GetOndoQuoteParams as bl, type GetOndoTradingStatusParams as bm, type GetSwapAuthorizationParams as bn, type GetSwapPreviewParams as bo, type GetTokenAllowanceParams as bp, type GetTokenBalanceParams as bq, HexEncodedTransactionData as br, Isin as bs, Iso2CountryCode as bt, Link as bu, type ListOptionAddressesParams as bv, MAX_ASSET_DECIMALS as bw, MAX_UINT_256 as bx, Milestone as by, Millis as bz, type CentrifugeClaimDirection as c, SOLANA_CHAINS as c0, STABLE_DECIMALS as c1, SolanaChain as c2, type SubmitDocumentParams as c3, type SuperstateSwapOffer as c4, type SwapContractRef as c5, SwapPreview as c6, TermItem as c7, Ticker as c8, type TokenLogoImage as c9, TokenLogoUrl as ca, type TokenRole as cb, TokensNamespaceImpl as cc, type Tx as cd, WalletAddress as ce, WalletOwnershipChallenge as cf, type WalletProtocol as cg, WalletsNamespaceImpl as ch, apiErrorCode as ci, assertUint256 as cj, isChain as ck, isExpired as cl, isOfferType as cm, parseUint256 as cn, CentrifugeNamespaceImpl as d, type Erc20Namespace as e, EvmContractAddress as f, type CoinListTokenSaleNamespace as g, OfferOptionId as h, AssetId as i, CoinListTokenSaleNamespaceImpl as j, type OndoNamespace as k, OfferSwapContract as l, OndoBuyTransaction as m, OndoSellTransaction as n, type OndoSwapTransactionCore as o, type OrderBookSide as p, OndoNamespaceImpl as q, type WalletsNamespace as r, Bps as s, EvmWalletAddress as t, SuperstateSwapNamespaceImpl as u, Requirement as v, RequirementsNamespaceImpl as w, type Config as x, type OAuthAccessToken as y, type OffersNamespace as z };