@coinlist-co/react 0.12.2-rc.0fda52c → 0.12.2-rc.5f2ca48

package/dist/client/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client/index.ts
 var client_exports = {};
 __export(client_exports, {
+  CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES: () => CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES,
   ChecklistStatus: () => ChecklistStatus,
   CheckoutAssetUi: () => CheckoutAssetUi,
   CheckoutContainer: () => CheckoutContainer,
@@ -71,6 +72,7 @@ __export(client_exports, {
   OndoBuyOrderConfirmed: () => OndoBuyOrderConfirmed,
   OndoBuyReviewView: () => OndoBuyReviewView,
   OndoCheckoutError: () => OndoCheckoutError,
+  OndoCheckoutErrorReason: () => OndoCheckoutErrorReason,
   OndoSellAmountView: () => OndoSellAmountView,
   OndoSellCheckoutContainer: () => OndoSellCheckoutContainer,
   OndoSellCheckoutView: () => OndoSellCheckoutView,
@@ -99,6 +101,9 @@ __export(client_exports, {
   USDT_ICON_URL: () => USDT_ICON_URL,
   VerificationOverlay: () => VerificationOverlay,
   authorizeWallet: () => authorizeWallet,
+  centrifugeLoadErrorReason: () => centrifugeLoadErrorReason,
+  centrifugeVaultOrderReasonMessage: () => centrifugeVaultOrderReasonMessage,
+  centrifugeVaultOrderingMessage: () => centrifugeVaultOrderingMessage,
   classifyWalletError: () => classifyWalletError,
   connectExternalWalletFlow: () => connectExternalWalletFlow,
   createCoinListClient: () => createCoinListClient,
@@ -110,6 +115,7 @@ __export(client_exports, {
   formatCountdown: () => formatCountdown,
   formatMonthYear: () => formatMonthYear,
   formatSaleCardCountdown: () => formatSaleCardCountdown,
+  isNotTradable: () => isNotTradable,
   offerAssetIconUrl: () => offerAssetIconUrl,
   offerIconUrl: () => offerIconUrl,
   offerTokenIdentifier: () => offerTokenIdentifier,
@@ -117,6 +123,7 @@ __export(client_exports, {
   pinoClientLogger: () => pinoClientLogger,
   prepareOndoBuy: () => prepareOndoBuy,
   prepareOndoSell: () => prepareOndoSell,
+  primaryCentrifugeVaultOrderReason: () => primaryCentrifugeVaultOrderReason,
   quoteIsStale: () => quoteIsStale,
   quoteOverAsks: () => quoteOverAsks,
   stablecoinIconUrl: () => stablecoinIconUrl,
@@ -124,6 +131,8 @@ __export(client_exports, {
   tokenLogoSrcSet: () => tokenLogoSrcSet,
   tokenLogoUrl: () => tokenLogoUrl,
   tokenMetadataOf: () => tokenMetadataOf,
+  useCentrifugeQuote: () => useCentrifugeQuote,
+  useCentrifugeVaultStatus: () => useCentrifugeVaultStatus,
   useCheckoutOfferTokenMetadata: () => useCheckoutOfferTokenMetadata,
   useCoinList: () => useCoinList,
   useCoinListSignInCardViewModel: () => useCoinListSignInCardViewModel,
@@ -1560,83 +1569,8 @@ async function fetchAllPages(fetchPage, baseParams) {
   return items;
 }
 
-// src/universal/types/pagination.ts
-var Cursor = (value) => value;
-var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
-  /**
-   * 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: (dto, pageMapper) => ({
-    data: pageMapper(dto.data),
-    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
-    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
-  })
-};
-var PaginationParams = {
-  toQueryParams: (params) => {
-    const queryParams = {};
-    if (params.after) {
-      queryParams.starting_after = params.after;
-    }
-    if (params.before) {
-      queryParams.starting_before = params.before;
-    }
-    if (params.limit) {
-      queryParams.limit = params.limit;
-    }
-    return queryParams;
-  }
-};
-
-// src/universal/types/asset.ts
-var AssetId = (value) => value;
-var AssetCode = (value) => value;
-var Asset = {
-  fromDto: (dto) => ({
-    id: AssetId(dto.id),
-    code: AssetCode(dto.code),
-    name: dto.name,
-    fractionalDigits: dto.fractional_digits
-  })
-};
-
-// src/universal/core/shared/utils/wire.ts
-function unknownTypeError(dto, model) {
-  const type = dto.type;
-  throw new ValidationError(
-    `${model}.type: unknown type ${JSON.stringify(type)}`
-  );
-}
-function requiredString(value, field) {
-  const text = notBlankStringOrNull(value);
-  if (text === null) {
-    throw new ValidationError(
-      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
-    );
-  }
-  return text;
-}
-function requiredDate(value, field) {
-  const date = typeof value === "string" ? new Date(value) : null;
-  if (date === null || Number.isNaN(date.getTime())) {
-    throw new ValidationError(
-      `${field}: expected a date, got ${JSON.stringify(value)}`
-    );
-  }
-  return date;
-}
-function requiredArray(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ValidationError(
-      `${field}: expected an array, got ${typeof value}`
-    );
-  }
-  return value;
-}
+// src/universal/core/shared/blockchain/math.ts
+var import_viem3 = require("viem");
 
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
@@ -1728,13 +1662,281 @@ var AssetSymbol = (value) => value;
 var StablecoinSymbol = (value) => value;
 var Bps = (value) => value;
 
+// src/universal/core/shared/blockchain/math.ts
+function blockchainAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals
+}) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  let value;
+  try {
+    value = BigInt(trimmed);
+  } catch {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  try {
+    return BlockchainAmount({ raw: assertUint256(value), decimals });
+  } catch {
+    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+  }
+}
+function parseBlockchainAmount(amount, decimals) {
+  const trimmed = amount.trim();
+  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
+  if (trimmed.startsWith("-")) {
+    return { valid: false, reason: { type: "negative" } };
+  }
+  if (/[eE]/.test(trimmed)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  if (trimmed === ".") {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
+  if (!/^\d+(\.\d+)?$/.test(normalised)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const [, fraction = ""] = normalised.split(".");
+  if (fraction.length > decimals) {
+    return {
+      valid: false,
+      reason: { type: "too-many-decimals", maxDecimals: decimals }
+    };
+  }
+  try {
+    const raw = (0, import_viem3.parseUnits)(normalised, decimals);
+    if (raw > MAX_UINT_256) {
+      return { valid: false, reason: { type: "overflow" } };
+    }
+    return {
+      valid: true,
+      amount: BlockchainAmount({ raw, decimals })
+    };
+  } catch {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+}
+
+// src/universal/core/shared/utils/wire.ts
+function unknownTypeError(dto, model) {
+  const type = dto.type;
+  throw new ValidationError(
+    `${model}.type: unknown type ${JSON.stringify(type)}`
+  );
+}
+function requiredString(value, field) {
+  const text = notBlankStringOrNull(value);
+  if (text === null) {
+    throw new ValidationError(
+      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
+    );
+  }
+  return text;
+}
+function requiredDate(value, field) {
+  const date = typeof value === "string" ? new Date(value) : null;
+  if (date === null || Number.isNaN(date.getTime())) {
+    throw new ValidationError(
+      `${field}: expected a date, got ${JSON.stringify(value)}`
+    );
+  }
+  return date;
+}
+function dateOrNull(value, field) {
+  return value === null ? null : requiredDate(value, field);
+}
+function decimalOrNull(value) {
+  return value === null ? null : DecimalString(value);
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(
+      `${field}: expected an array, got ${typeof value}`
+    );
+  }
+  return value;
+}
+
+// src/universal/types/providers/centrifuge/centrifuge.ts
+var CentrifugeVaultQuote = {
+  fromDto: (dto) => {
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
+    const shareDecimals = AssetDecimals(dto.share_decimals);
+    return {
+      chain: EthereumChain(dto.chain),
+      symbol: AssetSymbol(dto.symbol),
+      spendInputAmount: blockchainAmountFromRawOrThrow({
+        label: "spend_input_amount",
+        raw: dto.spend_input_amount,
+        decimals: spendDecimals
+      }),
+      estimatedShares: blockchainAmountFromRawOrThrow({
+        label: "estimated_shares",
+        raw: dto.estimated_shares,
+        decimals: shareDecimals
+      }),
+      indicativePrice: decimalOrNull(dto.indicative_price),
+      minimumInputAmount: dto.minimum_input_amount === null ? null : blockchainAmountFromRawOrThrow({
+        label: "minimum_input_amount",
+        raw: dto.minimum_input_amount,
+        decimals: spendDecimals
+      }),
+      orderability: parseOrderability(
+        dto.can_order,
+        dto.reasons,
+        "CentrifugeVaultQuote"
+      )
+    };
+  }
+};
+var CentrifugeVaultStatus = {
+  fromDto: (dto) => ({
+    chain: EthereumChain(dto.chain),
+    symbol: AssetSymbol(dto.symbol),
+    vaultAddress: EvmContractAddress(dto.vault_address),
+    linked: dto.linked,
+    permissioned: dto.permissioned,
+    membershipValidUntil: dateOrNull(
+      dto.membership_valid_until,
+      "CentrifugeVaultStatus.membership_valid_until"
+    ),
+    halted: dto.halted,
+    priceUpdatedAt: dateOrNull(
+      dto.price_updated_at,
+      "CentrifugeVaultStatus.price_updated_at"
+    ),
+    orderability: parseOrderability(
+      dto.can_order,
+      dto.reasons,
+      "CentrifugeVaultStatus"
+    ),
+    asOf: requiredDate(dto.as_of, "CentrifugeVaultStatus.as_of")
+  })
+};
+function parseOrderability(canOrder, reasons, model) {
+  const [first, ...rest] = reasons;
+  if (canOrder) {
+    if (first !== void 0) {
+      throw new ValidationError(
+        `${model}.reasons: expected none when can_order is true, got ${JSON.stringify(reasons)}`
+      );
+    }
+    return { type: "orderable" };
+  }
+  if (first === void 0) {
+    throw new ValidationError(
+      `${model}.reasons: expected at least one when can_order is false`
+    );
+  }
+  return { type: "blocked", reasons: [first, ...rest] };
+}
+
+// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
+async function getCentrifugeVaultQuote(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/quote",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain,
+      amount: params.amount.raw.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultQuote.fromDto(dto);
+}
+async function getCentrifugeVaultStatus(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/status",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain
+    },
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultStatus.fromDto(dto);
+}
+
+// src/universal/core/checkout/centrifuge/centrifuge-namespace.ts
+var CentrifugeNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "CENTRIFUGE");
+  }
+  async getQuote(params) {
+    return this.log.wrap("getQuote", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultQuote(this.ctx.api, params);
+    });
+  }
+  async getVaultStatus(params) {
+    return this.log.wrap("getVaultStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultStatus(this.ctx.api, params);
+    });
+  }
+};
+
+// src/universal/core/checkout/centrifuge/constants.ts
+var CENTRIFUGE_POLL_INTERVAL_MS = 15e3;
+
+// src/universal/types/pagination.ts
+var Cursor = (value) => value;
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
+  /**
+   * 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: (dto, pageMapper) => ({
+    data: pageMapper(dto.data),
+    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
+    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
+  })
+};
+var PaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = {};
+    if (params.after) {
+      queryParams.starting_after = params.after;
+    }
+    if (params.before) {
+      queryParams.starting_before = params.before;
+    }
+    if (params.limit) {
+      queryParams.limit = params.limit;
+    }
+    return queryParams;
+  }
+};
+
+// src/universal/types/asset.ts
+var AssetId = (value) => value;
+var AssetCode = (value) => value;
+var Asset = {
+  fromDto: (dto) => ({
+    id: AssetId(dto.id),
+    code: AssetCode(dto.code),
+    name: dto.name,
+    fractionalDigits: dto.fractional_digits
+  })
+};
+
 // src/universal/types/offer.ts
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
 var OFFER_TYPES = {
   "coinlist::token_sale": true,
   "superstate::swap": true,
-  "ondo::swap": true
+  "ondo::swap": true,
+  "centrifuge::vault": true
 };
 var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
 var OfferEditorial = {
@@ -1776,6 +1978,7 @@ var Offer = {
       // on the wire: copying them would hand every consumer a `startsAt` that
       // is 1970 for one variant and a date for the others.
       case "ondo::swap":
+      case "centrifuge::vault":
         return {
           ...base2,
           type: dto.type,
@@ -1828,6 +2031,19 @@ var OfferSwapContract = {
     address: EvmContractAddress(dto.address)
   })
 };
+var OfferVaultContract = {
+  fromDto: (dto) => ({
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * 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) => dtos.filter((dto) => isChain(dto.chain)).map(OfferVaultContract.fromDto)
+};
 var OfferDetail = {
   fromDto: (dto) => {
     const fundingAssets = requiredArray(
@@ -1890,6 +2106,18 @@ var OfferDetail = {
             "OfferDetail.swap_contracts"
           ).map(OfferSwapContract.fromDto)
         };
+      // No editorial, as for Ondo. `[]` is fine and a missing key is not, for
+      // the same reason as `swap_contracts`: this is the spender a user
+      // approves.
+      case "centrifuge::vault":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          vaultContracts: OfferVaultContract.listFromDto(
+            requiredArray(dto.vault_contracts, "OfferDetail.vault_contracts")
+          )
+        };
       default:
         return unknownTypeError(dto, "OfferDetail");
     }
@@ -2162,8 +2390,14 @@ function assertPriceFits(raw) {
   }
 }
 
+// src/universal/core/checkout/ondo/not-tradable.ts
+var ONDO_NOT_TRADABLE_CODE = "not_tradable";
+function isOndoNotTradableError(error) {
+  return apiErrorCode(error) === ONDO_NOT_TRADABLE_CODE;
+}
+
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 
 // src/universal/types/blockchain/ui.ts
 var FormattedAmountUi = (value) => value;
@@ -2234,7 +2468,7 @@ function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
   };
 }
 function formatRawAmount(amount) {
-  return (0, import_viem3.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem4.formatUnits)(amount.raw, amount.decimals);
 }
 function formatBpsAsPercent(bps, locale) {
   const whole = bps / 100n;
@@ -2327,66 +2561,6 @@ function explorerBaseUrl(chain) {
   }
 }
 
-// src/universal/core/shared/blockchain/math.ts
-var import_viem4 = require("viem");
-function blockchainAmountFromRawOrThrow({
-  label,
-  raw,
-  decimals
-}) {
-  const trimmed = raw.trim();
-  if (trimmed === "") {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  let value;
-  try {
-    value = BigInt(trimmed);
-  } catch {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  try {
-    return BlockchainAmount({ raw: assertUint256(value), decimals });
-  } catch {
-    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
-  }
-}
-function parseBlockchainAmount(amount, decimals) {
-  const trimmed = amount.trim();
-  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
-  if (trimmed.startsWith("-")) {
-    return { valid: false, reason: { type: "negative" } };
-  }
-  if (/[eE]/.test(trimmed)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  if (trimmed === ".") {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
-  if (!/^\d+(\.\d+)?$/.test(normalised)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const [, fraction = ""] = normalised.split(".");
-  if (fraction.length > decimals) {
-    return {
-      valid: false,
-      reason: { type: "too-many-decimals", maxDecimals: decimals }
-    };
-  }
-  try {
-    const raw = (0, import_viem4.parseUnits)(normalised, decimals);
-    if (raw > MAX_UINT_256) {
-      return { valid: false, reason: { type: "overflow" } };
-    }
-    return {
-      valid: true,
-      amount: BlockchainAmount({ raw, decimals })
-    };
-  } catch {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-}
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -2402,7 +2576,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -4133,7 +4306,9 @@ var TokenRegistrySnapshot = {
   }
 };
 function offerDisplayTokens(offer) {
-  const swaps = offer.tokens.filter((token) => token.role === "swap");
+  const swaps = offer.tokens.filter(
+    (token) => token.role === "swap" || token.role === "vault"
+  );
   const distributions = offer.tokens.filter(
     (token) => token.role === "distribution"
   );
@@ -5257,6 +5432,7 @@ var CoinListClientImpl = class {
       this.wallets
     );
     this.ondo = new ClientOndoNamespaceImpl(ctx, this.erc20);
+    this.centrifuge = new CentrifugeNamespaceImpl(ctx);
     this.tokens = new TokensNamespaceImpl(
       config.tokensBaseUrl ?? NABU_BASE_URL,
       logger
@@ -7115,6 +7291,8 @@ function InfoIcon() {
 var import_jsx_runtime26 = require("react/jsx-runtime");
 var UNSUPPORTED_CHAIN_TITLE = "Not available on this network";
 var UNSUPPORTED_CHAIN_DESCRIPTION = "Ondo orders cannot be placed on the selected network.";
+var NOT_TRADABLE_TITLE = "Trading is closed right now";
+var NOT_TRADABLE_DESCRIPTION = "This asset cannot be traded at the moment. Come back when the market opens.";
 function OndoCheckoutError({
   reason,
   className
@@ -7156,6 +7334,8 @@ function title(reason) {
   switch (reason) {
     case "unsupported-chain":
       return UNSUPPORTED_CHAIN_TITLE;
+    case "not-tradable":
+      return NOT_TRADABLE_TITLE;
     default: {
       const exhaustive = reason;
       return exhaustive;
@@ -7166,6 +7346,8 @@ function description(reason) {
   switch (reason) {
     case "unsupported-chain":
       return UNSUPPORTED_CHAIN_DESCRIPTION;
+    case "not-tradable":
+      return NOT_TRADABLE_DESCRIPTION;
     default: {
       const exhaustive = reason;
       return exhaustive;
@@ -8294,7 +8476,9 @@ var import_react15 = require("react");
 
 // src/client/hooks/checkout/ondo/shared/data/ondo-load-error.ts
 function ondoLoadErrorReason(error) {
-  return error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+  if (error instanceof NotAuthenticatedError) return "not-authenticated";
+  if (isOndoNotTradableError(error)) return "not-tradable";
+  return "generic-error";
 }
 
 // src/client/hooks/checkout/ondo/buy/data/useOndoBuyTransaction.ts
@@ -8599,6 +8783,8 @@ function refreshErrorMessage(reason) {
   switch (reason) {
     case "not-authenticated":
       return "Sign in to refresh this quote.";
+    case "not-tradable":
+      return "Trading is paused for this asset. Try again when the market opens.";
     case "generic-error":
       return "Could not refresh the quote.";
     default: {
@@ -8726,6 +8912,9 @@ function quoteSizeFromKey(key) {
 
 // src/client/hooks/checkout/ondo/shared/data/useOndoTradingStatus.ts
 var import_react19 = require("react");
+function isNotTradable(state) {
+  return state.type === "CONTENT" && state.status.type === "not-tradable";
+}
 var LOADING2 = { type: "LOADING" };
 function useOndoTradingStatus(options) {
   const {
@@ -8795,6 +8984,30 @@ function useOndoTradingStatus(options) {
   return { state };
 }
 
+// src/client/hooks/checkout/ondo/shared/ondo-checkout-error.types.ts
+var OndoCheckoutErrorReason = {
+  /**
+   * Which reason, if any, replaces the whole checkout. `null` means the steps
+   * render.
+   *
+   * `unsupported-chain` wins because it is settled at mount: no market state
+   * can make a chain with no contract tradable. `not-tradable` needs both a
+   * market *known* to be closed and a user still at the start of the flow,
+   * with no order confirmation on screen. Past the first step a pause belongs
+   * to the step it interrupts, and a just-placed order's dialog must not be
+   * hidden by a market that closed after it filled.
+   */
+  of: ({
+    swappableHere,
+    notTradable,
+    atEntry
+  }) => {
+    if (!swappableHere) return "unsupported-chain";
+    if (notTradable && atEntry) return "not-tradable";
+    return null;
+  }
+};
+
 // src/client/hooks/checkout/ondo/shared/sidebar/useOndoSidebarViewModel.ts
 var MARKET_OPEN = "Market open";
 var MARKET_CLOSED2 = "Market closed";
@@ -9113,18 +9326,19 @@ function useOndoBuyCheckoutViewModel({
   const [orderConfirmed, setOrderConfirmed] = (0, import_react22.useState)(null);
   const swappableHere = swapSpender(offer.swapContracts, chain) !== null;
   const live = enabled && swappableHere;
-  const { state: priceState } = useOndoPrice({
+  const { state: tradingStatusState } = useOndoTradingStatus({
     symbol: ondoSymbol,
     side: "buy",
-    size: priceSize(step),
     pollIntervalMs: ONDO_POLL_INTERVAL_MS,
     enabled: live
   });
-  const { state: tradingStatusState } = useOndoTradingStatus({
+  const notTradable = isNotTradable(tradingStatusState);
+  const { state: priceState } = useOndoPrice({
     symbol: ondoSymbol,
     side: "buy",
+    size: priceSize(step),
     pollIntervalMs: ONDO_POLL_INTERVAL_MS,
-    enabled: live
+    enabled: live && !notTradable
   });
   const { state: outputTokenMetadataState } = useCheckoutOfferTokenMetadata({
     offer,
@@ -9202,7 +9416,12 @@ function useOndoBuyCheckoutViewModel({
     priceState,
     tradingStatusState
   });
-  const state = !swappableHere ? { type: "error", reason: "unsupported-chain" } : {
+  const errorReason = OndoCheckoutErrorReason.of({
+    swappableHere,
+    notTradable,
+    atEntry: step.type === "wallet" && orderConfirmed === null
+  });
+  const state = errorReason !== null ? { type: "error", reason: errorReason } : {
     type: "content",
     wallet: walletState,
     amount: amountState,
@@ -10659,6 +10878,8 @@ function refreshErrorMessage2(reason) {
   switch (reason) {
     case "not-authenticated":
       return "Sign in to refresh this quote.";
+    case "not-tradable":
+      return "Trading is paused for this asset. Try again when the market opens.";
     case "generic-error":
       return "Could not refresh the quote.";
     default: {
@@ -10712,18 +10933,19 @@ function useOndoSellCheckoutViewModel({
   const [orderConfirmed, setOrderConfirmed] = (0, import_react27.useState)(null);
   const swappableHere = swapSpender(offer.swapContracts, chain) !== null;
   const live = enabled && swappableHere;
-  const { state: priceState } = useOndoPrice({
+  const { state: tradingStatusState } = useOndoTradingStatus({
     symbol: ondoSymbol,
     side: "sell",
-    size: priceSize2(step),
     pollIntervalMs: ONDO_POLL_INTERVAL_MS,
     enabled: live
   });
-  const { state: tradingStatusState } = useOndoTradingStatus({
+  const notTradable = isNotTradable(tradingStatusState);
+  const { state: priceState } = useOndoPrice({
     symbol: ondoSymbol,
     side: "sell",
+    size: priceSize2(step),
     pollIntervalMs: ONDO_POLL_INTERVAL_MS,
-    enabled: live
+    enabled: live && !notTradable
   });
   const { state: inputTokenMetadataState } = useCheckoutOfferTokenMetadata({
     offer,
@@ -10801,7 +11023,14 @@ function useOndoSellCheckoutViewModel({
     priceState,
     tradingStatusState
   });
-  const state = !swappableHere ? { type: "error", reason: "unsupported-chain" } : {
+  const errorReason = OndoCheckoutErrorReason.of({
+    swappableHere,
+    notTradable,
+    // The step the flow opened on, which for a preselected wallet is the
+    // amount rather than a wallet step it never had.
+    atEntry: step.type === initialStep.type && orderConfirmed === null
+  });
+  const state = errorReason !== null ? { type: "error", reason: errorReason } : {
     type: "content",
     wallet: hasWalletStep ? walletState : null,
     amount: amountState,
@@ -13338,7 +13567,8 @@ function CheckoutContainer({
         className
       }
     ),
-    tokenSale: (tokenSaleOffer) => config["coinlist::token_sale"].render(tokenSaleOffer)
+    tokenSale: (tokenSaleOffer) => config["coinlist::token_sale"].render(tokenSaleOffer),
+    centrifugeVault: (vaultOffer) => config["centrifuge::vault"].render(vaultOffer)
   });
 }
 function OndoCheckoutContainer({
@@ -13386,6 +13616,8 @@ function renderOffer(offer, branches) {
       return branches.superstate(offer);
     case "coinlist::token_sale":
       return branches.tokenSale(offer);
+    case "centrifuge::vault":
+      return branches.centrifugeVault(offer);
     default: {
       const exhaustive = offer;
       return exhaustive;
@@ -13987,6 +14219,7 @@ function saleWindow(offer) {
     case "superstate::swap":
       return { tagline: offer.tagline, startsAt: offer.startsAt };
     case "ondo::swap":
+    case "centrifuge::vault":
       return { tagline: null, startsAt: null };
     default: {
       const exhaustive = offer;
@@ -16749,17 +16982,220 @@ function useCompleteOAuth(options) {
   }, [coinlist, log]);
 }
 
-// src/client/hooks/checkout/coin-list/token-sale/data/useParticipations.ts
+// src/client/hooks/checkout/centrifuge/shared/centrifuge-order-reason.ts
+var CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES = {
+  vault_unlinked: "This vault is no longer available on this network.",
+  vault_halted: "Investing in this vault is paused.",
+  proxy_not_permissioned: "This vault cannot accept investments right now.",
+  price_unavailable: "A price is not available for this vault right now.",
+  below_minimum: "Enter at least the minimum amount to invest."
+};
+var ORDER_REASON_SEVERITY = {
+  vault_unlinked: 0,
+  vault_halted: 1,
+  proxy_not_permissioned: 2,
+  price_unavailable: 3,
+  below_minimum: 4
+};
+function centrifugeVaultOrderReasonMessage(reason) {
+  return CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES[reason];
+}
+function primaryCentrifugeVaultOrderReason(reasons) {
+  if (reasons.length === 0) return null;
+  return reasons.reduce(
+    (best, reason) => ORDER_REASON_SEVERITY[reason] < ORDER_REASON_SEVERITY[best] ? reason : best
+  );
+}
+function centrifugeVaultOrderingMessage(orderability) {
+  if (orderability.type === "orderable") return null;
+  const reason = primaryCentrifugeVaultOrderReason(orderability.reasons);
+  return reason === null ? null : centrifugeVaultOrderReasonMessage(reason);
+}
+
+// src/client/hooks/checkout/centrifuge/shared/data/centrifuge-load-error.ts
+function centrifugeLoadErrorReason(error) {
+  return error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+}
+
+// src/client/hooks/checkout/centrifuge/shared/data/useCentrifugeQuote.ts
 var import_react51 = require("react");
+var LOADING3 = { type: "LOADING" };
+function useCentrifugeQuote(options) {
+  const {
+    symbol,
+    chain,
+    amount,
+    pollIntervalMs = CENTRIFUGE_POLL_INTERVAL_MS,
+    data,
+    enabled
+  } = options;
+  const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useCentrifugeQuote");
+  const [state, setState] = (0, import_react51.useState)(
+    () => data === void 0 ? LOADING3 : { type: "CONTENT", quote: data, isRefreshing: false }
+  );
+  const fetchIdRef = (0, import_react51.useRef)(0);
+  const isFetchingRef = (0, import_react51.useRef)(false);
+  const hasQuoteRef = (0, import_react51.useRef)(data !== void 0);
+  (0, import_react51.useEffect)(() => {
+    if (!isReady || !enabled) return;
+    const currentFetchId = ++fetchIdRef.current;
+    isFetchingRef.current = false;
+    const load = async () => {
+      if (isFetchingRef.current) return;
+      isFetchingRef.current = true;
+      setState(
+        (previous) => previous.type === "CONTENT" ? { ...previous, isRefreshing: true } : previous
+      );
+      try {
+        const quote = await coinlist.centrifuge.getQuote({
+          symbol,
+          chain,
+          // Rebuilt from primitives the effect depends on, so an inline
+          // `amount` from the checkout viewmodel does not restart the poll.
+          amount: BlockchainAmount({
+            raw: amount.raw,
+            decimals: amount.decimals
+          })
+        });
+        if (currentFetchId !== fetchIdRef.current) return;
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT" }
+        }));
+        hasQuoteRef.current = true;
+        setState({ type: "CONTENT", quote, isRefreshing: false });
+      } catch (error) {
+        if (currentFetchId !== fetchIdRef.current) return;
+        const reason = centrifugeLoadErrorReason(error);
+        if (hasQuoteRef.current) {
+          log.warning(
+            () => ({
+              msg: "poll failed; keeping the last quote",
+              fields: { reason }
+            }),
+            error
+          );
+        } else {
+          log.failure(
+            () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+            error
+          );
+        }
+        setState(
+          (previous) => previous.type === "CONTENT" ? { ...previous, isRefreshing: false } : { type: "ERROR", reason }
+        );
+      } finally {
+        if (currentFetchId === fetchIdRef.current) {
+          isFetchingRef.current = false;
+        }
+      }
+    };
+    load();
+    const interval = setInterval(load, pollIntervalMs);
+    return () => {
+      clearInterval(interval);
+      ++fetchIdRef.current;
+    };
+  }, [
+    coinlist,
+    isReady,
+    enabled,
+    symbol,
+    chain,
+    amount.raw,
+    amount.decimals,
+    pollIntervalMs,
+    log
+  ]);
+  return { state };
+}
+
+// src/client/hooks/checkout/centrifuge/shared/data/useCentrifugeVaultStatus.ts
+var import_react52 = require("react");
+var LOADING4 = { type: "LOADING" };
+function useCentrifugeVaultStatus(options) {
+  const {
+    symbol,
+    chain,
+    pollIntervalMs = CENTRIFUGE_POLL_INTERVAL_MS,
+    data,
+    enabled
+  } = options;
+  const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useCentrifugeVaultStatus");
+  const [state, setState] = (0, import_react52.useState)(
+    () => data === void 0 ? LOADING4 : { type: "CONTENT", status: data }
+  );
+  const fetchIdRef = (0, import_react52.useRef)(0);
+  const isFetchingRef = (0, import_react52.useRef)(false);
+  const hasStatusRef = (0, import_react52.useRef)(data !== void 0);
+  (0, import_react52.useEffect)(() => {
+    if (!isReady || !enabled) return;
+    const currentFetchId = ++fetchIdRef.current;
+    isFetchingRef.current = false;
+    const load = async () => {
+      if (isFetchingRef.current) return;
+      isFetchingRef.current = true;
+      try {
+        const status = await coinlist.centrifuge.getVaultStatus({
+          symbol,
+          chain
+        });
+        if (currentFetchId !== fetchIdRef.current) return;
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", orderability: status.orderability.type }
+        }));
+        hasStatusRef.current = true;
+        setState({ type: "CONTENT", status });
+      } catch (error) {
+        if (currentFetchId !== fetchIdRef.current) return;
+        const reason = centrifugeLoadErrorReason(error);
+        if (hasStatusRef.current) {
+          log.warning(
+            () => ({
+              msg: "poll failed; keeping the last status",
+              fields: { reason }
+            }),
+            error
+          );
+        } else {
+          log.failure(
+            () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+            error
+          );
+        }
+        setState(
+          (previous) => previous.type === "CONTENT" ? previous : { type: "ERROR", reason }
+        );
+      } finally {
+        if (currentFetchId === fetchIdRef.current) {
+          isFetchingRef.current = false;
+        }
+      }
+    };
+    load();
+    const interval = setInterval(load, pollIntervalMs);
+    return () => {
+      clearInterval(interval);
+      ++fetchIdRef.current;
+    };
+  }, [coinlist, isReady, enabled, symbol, chain, pollIntervalMs, log]);
+  return { state };
+}
+
+// src/client/hooks/checkout/coin-list/token-sale/data/useParticipations.ts
+var import_react53 = require("react");
 var LOADING_STATE9 = { type: "LOADING" };
 function useParticipations(offerId, options = {}) {
   const { coinlist, isReady } = useCoinList();
   const log = useLogger("useParticipations");
   const { data, enabled = true } = options;
-  const [participationsState, setParticipationsState] = (0, import_react51.useState)(
+  const [participationsState, setParticipationsState] = (0, import_react53.useState)(
     data !== void 0 ? { type: "CONTENT", participations: data } : LOADING_STATE9
   );
-  (0, import_react51.useEffect)(() => {
+  (0, import_react53.useEffect)(() => {
     let isCancelled = false;
     if (!enabled) {
       return () => {
@@ -16806,16 +17242,16 @@ function useParticipations(offerId, options = {}) {
 }
 
 // src/client/hooks/offers/data/useOfferDetails.ts
-var import_react52 = require("react");
+var import_react54 = require("react");
 var LOADING_STATE10 = { type: "LOADING" };
 function useOfferDetails(offerId, options = {}) {
   const { coinlist, isReady } = useCoinList();
   const log = useLogger("useOfferDetails");
   const { data, enabled = true } = options;
-  const [offerDetailsState, setOfferDetailsState] = (0, import_react52.useState)(
+  const [offerDetailsState, setOfferDetailsState] = (0, import_react54.useState)(
     data !== void 0 ? { type: "CONTENT", offerDetail: data } : LOADING_STATE10
   );
-  (0, import_react52.useEffect)(() => {
+  (0, import_react54.useEffect)(() => {
     let isCancelled = false;
     if (!enabled) {
       return () => {
@@ -16893,6 +17329,7 @@ function formatMonthYear(date, locale) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CENTRIFUGE_VAULT_ORDER_REASON_MESSAGES,
   ChecklistStatus,
   CheckoutAssetUi,
   CheckoutContainer,
@@ -16934,6 +17371,7 @@ function formatMonthYear(date, locale) {
   OndoBuyOrderConfirmed,
   OndoBuyReviewView,
   OndoCheckoutError,
+  OndoCheckoutErrorReason,
   OndoSellAmountView,
   OndoSellCheckoutContainer,
   OndoSellCheckoutView,
@@ -16962,6 +17400,9 @@ function formatMonthYear(date, locale) {
   USDT_ICON_URL,
   VerificationOverlay,
   authorizeWallet,
+  centrifugeLoadErrorReason,
+  centrifugeVaultOrderReasonMessage,
+  centrifugeVaultOrderingMessage,
   classifyWalletError,
   connectExternalWalletFlow,
   createCoinListClient,
@@ -16973,6 +17414,7 @@ function formatMonthYear(date, locale) {
   formatCountdown,
   formatMonthYear,
   formatSaleCardCountdown,
+  isNotTradable,
   offerAssetIconUrl,
   offerIconUrl,
   offerTokenIdentifier,
@@ -16980,6 +17422,7 @@ function formatMonthYear(date, locale) {
   pinoClientLogger,
   prepareOndoBuy,
   prepareOndoSell,
+  primaryCentrifugeVaultOrderReason,
   quoteIsStale,
   quoteOverAsks,
   stablecoinIconUrl,
@@ -16987,6 +17430,8 @@ function formatMonthYear(date, locale) {
   tokenLogoSrcSet,
   tokenLogoUrl,
   tokenMetadataOf,
+  useCentrifugeQuote,
+  useCentrifugeVaultStatus,
   useCheckoutOfferTokenMetadata,
   useCoinList,
   useCoinListSignInCardViewModel,