@coinlist-co/react 0.12.2-rc.31c2f50 → 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,
@@ -100,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,
@@ -119,6 +123,7 @@ __export(client_exports, {
   pinoClientLogger: () => pinoClientLogger,
   prepareOndoBuy: () => prepareOndoBuy,
   prepareOndoSell: () => prepareOndoSell,
+  primaryCentrifugeVaultOrderReason: () => primaryCentrifugeVaultOrderReason,
   quoteIsStale: () => quoteIsStale,
   quoteOverAsks: () => quoteOverAsks,
   stablecoinIconUrl: () => stablecoinIconUrl,
@@ -126,6 +131,8 @@ __export(client_exports, {
   tokenLogoSrcSet: () => tokenLogoSrcSet,
   tokenLogoUrl: () => tokenLogoUrl,
   tokenMetadataOf: () => tokenMetadataOf,
+  useCentrifugeQuote: () => useCentrifugeQuote,
+  useCentrifugeVaultStatus: () => useCentrifugeVaultStatus,
   useCheckoutOfferTokenMetadata: () => useCheckoutOfferTokenMetadata,
   useCoinList: () => useCoinList,
   useCoinListSignInCardViewModel: () => useCoinListSignInCardViewModel,
@@ -1562,49 +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/blockchain/math.ts
+var import_viem3 = require("viem");
 
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
@@ -1696,6 +1662,65 @@ 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;
@@ -1721,6 +1746,9 @@ function requiredDate(value, field) {
   }
   return date;
 }
+function dateOrNull(value, field) {
+  return value === null ? null : requiredDate(value, field);
+}
 function decimalOrNull(value) {
   return value === null ? null : DecimalString(value);
 }
@@ -1733,6 +1761,174 @@ function requiredArray(value, field) {
   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;
@@ -2201,7 +2397,7 @@ function isOndoNotTradableError(error) {
 }
 
 // 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;
@@ -2272,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;
@@ -2365,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) => {
@@ -5296,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
@@ -16845,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 () => {
@@ -16902,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 () => {
@@ -16989,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,
@@ -17059,6 +17400,9 @@ function formatMonthYear(date, locale) {
   USDT_ICON_URL,
   VerificationOverlay,
   authorizeWallet,
+  centrifugeLoadErrorReason,
+  centrifugeVaultOrderReasonMessage,
+  centrifugeVaultOrderingMessage,
   classifyWalletError,
   connectExternalWalletFlow,
   createCoinListClient,
@@ -17078,6 +17422,7 @@ function formatMonthYear(date, locale) {
   pinoClientLogger,
   prepareOndoBuy,
   prepareOndoSell,
+  primaryCentrifugeVaultOrderReason,
   quoteIsStale,
   quoteOverAsks,
   stablecoinIconUrl,
@@ -17085,6 +17430,8 @@ function formatMonthYear(date, locale) {
   tokenLogoSrcSet,
   tokenLogoUrl,
   tokenMetadataOf,
+  useCentrifugeQuote,
+  useCentrifugeVaultStatus,
   useCheckoutOfferTokenMetadata,
   useCoinList,
   useCoinListSignInCardViewModel,