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

package/dist/universal/index.cjs

@@ -27,11 +27,24 @@ __export(universal_exports, {
   AssetIconUrl: () => AssetIconUrl,
   AssetId: () => AssetId,
   AssetSymbol: () => AssetSymbol,
+  AsyncOfferDetail: () => AsyncOfferDetail,
   AuthorizationCode: () => AuthorizationCode,
   BPS_DENOM: () => BPS_DENOM,
   Blockchain: () => Blockchain,
   BlockchainAmount: () => BlockchainAmount,
   Bps: () => Bps,
+  CENTRIFUGE_INDICATIVE_QUOTE_AMOUNT: () => CENTRIFUGE_INDICATIVE_QUOTE_AMOUNT,
+  CENTRIFUGE_POLL_INTERVAL_MS: () => CENTRIFUGE_POLL_INTERVAL_MS,
+  CentrifugeNamespaceImpl: () => CentrifugeNamespaceImpl,
+  CentrifugeVaultBuyTransaction: () => CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimProceedsTransaction: () => CentrifugeVaultClaimProceedsTransaction,
+  CentrifugeVaultClaimTransaction: () => CentrifugeVaultClaimTransaction,
+  CentrifugeVaultLeg: () => CentrifugeVaultLeg,
+  CentrifugeVaultLegId: () => CentrifugeVaultLegId,
+  CentrifugeVaultPosition: () => CentrifugeVaultPosition,
+  CentrifugeVaultQuote: () => CentrifugeVaultQuote,
+  CentrifugeVaultRedeemPosition: () => CentrifugeVaultRedeemPosition,
+  CentrifugeVaultStatus: () => CentrifugeVaultStatus,
   Chain: () => Chain,
   ClientCredentialsOAuth: () => ClientCredentialsOAuth,
   ClientId: () => ClientId,
@@ -51,6 +64,7 @@ __export(universal_exports, {
   DocumentSubmission: () => DocumentSubmission,
   ERC20_ABI: () => ERC20_ABI,
   ETHEREUM_CHAINS: () => ETHEREUM_CHAINS,
+  EpochMillis: () => EpochMillis,
   Erc20NamespaceImpl: () => Erc20NamespaceImpl,
   EthereumChain: () => EthereumChain,
   EvmContractAddress: () => EvmContractAddress,
@@ -71,11 +85,13 @@ __export(universal_exports, {
   MAX_UINT_256: () => MAX_UINT_256,
   MathError: () => MathError,
   Milestone: () => Milestone,
+  Millis: () => Millis,
   NA_AMOUNT_ASSET_UI: () => NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError: () => NotAuthenticatedError,
   NotImplementedError: () => NotImplementedError,
   OAuthRefreshToken: () => OAuthRefreshToken,
   OAuthSession: () => OAuthSession,
+  ONDO_NOT_TRADABLE_CODE: () => ONDO_NOT_TRADABLE_CODE,
   ONDO_POLL_INTERVAL_MS: () => ONDO_POLL_INTERVAL_MS,
   ONDO_QUOTE_MAX_TTL_MS: () => ONDO_QUOTE_MAX_TTL_MS,
   ONDO_SETTLEMENT_ASSET: () => ONDO_SETTLEMENT_ASSET,
@@ -92,6 +108,7 @@ __export(universal_exports, {
   OfferSlug: () => OfferSlug,
   OfferSwapContract: () => OfferSwapContract,
   OfferToken: () => OfferToken,
+  OfferVaultContract: () => OfferVaultContract,
   OffersNamespaceImpl: () => OffersNamespaceImpl,
   OndoBuyTransaction: () => OndoBuyTransaction,
   OndoNamespaceImpl: () => OndoNamespaceImpl,
@@ -123,6 +140,7 @@ __export(universal_exports, {
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA: () => SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
   SWAP_LEVEL: () => SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS: () => SWAP_POLL_INTERVAL_MS,
+  Seconds: () => Seconds,
   ShortenedWalletAddress: () => ShortenedWalletAddress,
   SolanaChain: () => SolanaChain,
   StablecoinSymbol: () => StablecoinSymbol,
@@ -149,6 +167,7 @@ __export(universal_exports, {
   ValidationError: () => ValidationError,
   WalletAddress: () => WalletAddress,
   WalletOwnershipChallenge: () => WalletOwnershipChallenge,
+  WalletSelection: () => WalletSelection,
   WalletsNamespaceImpl: () => WalletsNamespaceImpl,
   apiErrorCode: () => apiErrorCode,
   applyBps: () => applyBps,
@@ -166,18 +185,22 @@ __export(universal_exports, {
   formatBpsAsPercent: () => formatBpsAsPercent,
   formatCompactAmount: () => formatCompactAmount,
   formatRawAmount: () => formatRawAmount,
+  formatShareAmount: () => formatShareAmount,
   formattedPricePerShare: () => formattedPricePerShare,
   formattedUsdPrice: () => formattedUsdPrice,
   generatePKCEParams: () => generatePKCEParams,
   getChainId: () => getChainId,
   getNetworkName: () => getNetworkName,
   isChain: () => isChain,
+  isExpired: () => isExpired,
   isOfferType: () => isOfferType,
+  isOndoNotTradableError: () => isOndoNotTradableError,
   isSwapAvailable: () => isSwapAvailable,
   offerDisplayTokens: () => offerDisplayTokens,
   ondoQuoteOfferDeadline: () => ondoQuoteOfferDeadline,
   parseBlockchainAmount: () => parseBlockchainAmount,
   parseUint256: () => parseUint256,
+  resolveCentrifugeVaults: () => resolveCentrifugeVaults,
   shortenAddress: () => shortenAddress,
   superstateSwapContractAddress: () => superstateSwapContractAddress,
   swapSpender: () => swapSpender,
@@ -187,6 +210,15 @@ __export(universal_exports, {
 });
 module.exports = __toCommonJS(universal_exports);
 
+// src/universal/api/internal-access-token-source.ts
+var SentWith = {
+  userToken: (token) => ({
+    type: "user-token",
+    token
+  }),
+  noUserToken: { type: "no-user-token" }
+};
+
 // src/universal/api/http-attributes.ts
 var empty = {};
 var concat = (left, right) => ({
@@ -214,6 +246,10 @@ var retryAttempt = (attempt) => ({
 var renewAttempted = (value) => ({
   renewAttempted: value
 });
+var notRetryable = () => ({ retryable: false });
+var sentWith = (token) => ({
+  sentWith: token
+});
 var requestId = (id) => ({ requestId: id });
 var getRequestId = (attrs) => attrs?.requestId ?? null;
 var isProtected = (attrs) => attrs?.protected === true;
@@ -221,6 +257,8 @@ var needUserAgent = (attrs) => attrs?.userAgent === true;
 var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
 var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
 var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
+var isRetryable = (attrs) => attrs?.retryable !== false;
+var getSentWith = (attrs) => attrs?.sentWith === void 0 ? SentWith.noUserToken : SentWith.userToken(attrs.sentWith);
 var getClientCredentials = (attrs) => attrs?.clientCredentials;
 var Attributes = {
   empty,
@@ -236,6 +274,10 @@ var Attributes = {
   getRetryAttempt,
   renewAttempted,
   wasRenewAttempted,
+  notRetryable,
+  isRetryable,
+  sentWith,
+  getSentWith,
   clientCredentials,
   getClientCredentials,
   requestId,
@@ -430,50 +472,6 @@ async function generatePKCEParams(config) {
   };
 }
 
-// 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/errors.ts
 var NotImplementedError = class extends Error {
   constructor(message = "Not implemented yet") {
@@ -506,39 +504,8 @@ var MathError = class extends Error {
   }
 };
 
-// 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_viem = require("viem");
 
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
@@ -637,73 +604,769 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
-// 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
+// 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_viem.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 isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
-var OfferEditorial = {
-  /**
-   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
-   * the same three checks name the payload that failed them.
-   */
-  fromDto: (dto, model) => ({
-    tagline: requiredString(dto.tagline, `${model}.tagline`),
-    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
-    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
+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")
   })
 };
-var Offer = {
+var CentrifugeVaultBuyTransaction = {
   fromDto: (dto) => {
-    const tokens = requiredArray(dto.tokens, "Offer.tokens");
-    const base2 = {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      tokens: OfferToken.listFromDto(tokens)
-    };
-    switch (dto.type) {
-      case "coinlist::token_sale":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "Offer"),
-          type: dto.type,
-          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
-        };
-      case "superstate::swap":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "Offer"),
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url)
-        };
-      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
-      // 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":
-        return {
-          ...base2,
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url)
-        };
-      default:
-        return unknownTypeError(dto, "Offer");
+    const spendInputAmount = blockchainAmountFromRawOrThrow({
+      label: "spend_input_amount",
+      raw: dto.spend_input_amount,
+      decimals: AssetDecimals(dto.spend_input_decimals)
+    });
+    if (spendInputAmount.raw <= 0n) {
+      throw new ValidationError(
+        `spend_input_amount: must be greater than zero ("${dto.spend_input_amount}") - a deposit of nothing is not a request`
+      );
     }
-  },
-  /**
-   * Maps a page of offers, dropping every offer whose `type` this SDK does not
-   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
-   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
-   * reject the whole page, so one offer of an unknown type would blank the
-   * grid for every offer beside it. A single offer fetched by id still
-   * throws, because there is nothing beside it to keep.
-   */
-  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
-};
+    return {
+      ...parseTransactionCore(dto, "CentrifugeVaultBuyTransaction"),
+      spendInputAmount,
+      estimatedShares: blockchainAmountFromRawOrThrow({
+        label: "estimated_shares",
+        raw: dto.estimated_shares,
+        decimals: AssetDecimals(dto.share_decimals)
+      })
+    };
+  }
+};
+var CentrifugeVaultClaimTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimTransaction"),
+    claimableShares: blockchainAmountFromRawOrThrow({
+      label: "claimable_shares",
+      raw: dto.claimable_shares,
+      decimals: AssetDecimals(dto.share_decimals)
+    })
+  })
+};
+var CentrifugeVaultPosition = {
+  fromDto: (dto) => {
+    const assetDecimals = AssetDecimals(dto.asset_decimals);
+    const shareDecimals = AssetDecimals(dto.share_decimals);
+    const asset = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: assetDecimals });
+    const shares = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: shareDecimals });
+    return {
+      chain: EthereumChain(dto.chain),
+      symbol: AssetSymbol(dto.symbol),
+      walletAddress: EvmWalletAddress(dto.wallet_address),
+      status: dto.status,
+      requested: asset("requested", dto.requested),
+      pending: asset("pending", dto.pending),
+      filledAssets: asset("filled_assets", dto.filled_assets),
+      earnedShares: shares("earned_shares", dto.earned_shares),
+      claimedShares: shares("claimed_shares", dto.claimed_shares),
+      claimableShares: shares("claimable_shares", dto.claimable_shares),
+      shareBalance: shares("share_balance", dto.share_balance),
+      averagePrice: decimalOrNull(dto.average_price),
+      frozen: dto.frozen,
+      asOf: requiredDate(dto.as_of, "CentrifugeVaultPosition.as_of")
+    };
+  }
+};
+var CentrifugeVaultRedeemPosition = {
+  fromDto: (dto) => ({
+    chain: EthereumChain(dto.chain),
+    symbol: AssetSymbol(dto.symbol),
+    walletAddress: EvmWalletAddress(dto.wallet_address),
+    status: dto.status,
+    pending: blockchainAmountFromRawOrThrow({
+      label: "pending",
+      raw: dto.pending,
+      decimals: AssetDecimals(dto.share_decimals)
+    }),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    }),
+    frozen: dto.frozen,
+    asOf: requiredDate(dto.as_of, "CentrifugeVaultRedeemPosition.as_of")
+  })
+};
+var CentrifugeVaultLeg = {
+  /**
+   * What a claim on the leg would collect: shares for `invest`, the funding
+   * token for `redeem`.
+   */
+  claimable: (leg) => {
+    switch (leg.direction) {
+      case "invest":
+        return leg.position.claimableShares;
+      case "redeem":
+        return leg.position.claimableAssets;
+      default: {
+        const exhaustive = leg;
+        return exhaustive;
+      }
+    }
+  },
+  /** Whether the leg has anything queued or anything ready to claim. */
+  isActive: (leg) => leg.position.pending.raw > 0n || CentrifugeVaultLeg.claimable(leg).raw > 0n
+};
+var CentrifugeVaultLegId = {
+  /** Addresses compare case-insensitively: frontline echoes them lower case. */
+  of: (leg) => [
+    leg.direction,
+    leg.position.chain,
+    leg.position.walletAddress.toLowerCase()
+  ].join(":")
+};
+var CentrifugeVaultClaimProceedsTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    })
+  })
+};
+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] };
+}
+function parseTransactionCore(dto, model) {
+  return {
+    tx: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
+}
+
+// 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);
+}
+async function buildCentrifugeVaultBuy(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/invest",
+    body: {
+      ...walletFields(params),
+      amount: params.amount.raw.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  if (dto.spend_input_decimals !== params.amount.decimals) {
+    throw new ValidationError(
+      `spend_input_decimals: the request was priced in ${dto.spend_input_decimals} decimals but the deposit was sized in ${params.amount.decimals}`
+    );
+  }
+  return CentrifugeVaultBuyTransaction.fromDto(dto);
+}
+async function getCentrifugeVaultPosition(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/position",
+    queryParams: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultPosition.fromDto(dto);
+}
+async function getCentrifugeVaultRedeemPosition(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/redeem-position",
+    queryParams: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultRedeemPosition.fromDto(dto);
+}
+async function createCentrifugeVaultClaim(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimTransaction.fromDto(dto);
+}
+async function createCentrifugeVaultClaimProceeds(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim-proceeds",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimProceedsTransaction.fromDto(dto);
+}
+function walletFields(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress
+  };
+}
+
+// src/universal/core/shared/observability/log-cause.ts
+var import_viem2 = require("viem");
+function classifyLogCause(error) {
+  if (error instanceof HttpError) {
+    return httpCause(error);
+  }
+  if (error instanceof ValidationError) {
+    return { type: "validation", message: error.message };
+  }
+  if (error instanceof InvariantError) {
+    return { type: "invariant", message: error.message };
+  }
+  if (error instanceof MathError) {
+    return { type: "math", message: error.message };
+  }
+  if (error instanceof NotAuthenticatedError) {
+    return { type: "not-authenticated" };
+  }
+  if (error instanceof NotImplementedError) {
+    return { type: "not-implemented" };
+  }
+  if (error instanceof import_viem2.BaseError) {
+    const http = error.walk((e) => e instanceof HttpError);
+    if (http instanceof HttpError) {
+      return httpCause(http);
+    }
+    return { type: "rpc", reason: rpcFailureReason(error) };
+  }
+  return { type: "generic-error", name: errorName(error) };
+}
+function rpcFailureReason(error) {
+  if (error.walk((e) => e instanceof import_viem2.ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof import_viem2.RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof import_viem2.HttpRequestError || e instanceof import_viem2.WebSocketRequestError || e instanceof import_viem2.SocketClosedError || e instanceof import_viem2.TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof import_viem2.ContractFunctionExecutionError) {
+    return "malformed-response";
+  }
+  return "unknown";
+}
+function describeErrorUnredacted(error) {
+  if (error instanceof HttpError) {
+    return describeHttpErrorRedacted(error);
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return `thrown non-error: ${stringifyUnredacted(error)}`;
+}
+function stringifyUnredacted(value) {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(
+      value,
+      (_key, item) => typeof item === "bigint" ? `${item}` : item
+    ) ?? String(value);
+  } catch (_) {
+    return "<unserializable>";
+  }
+}
+function describeHttpErrorRedacted(error) {
+  const code = apiErrorCode(error);
+  const status = error.response.status;
+  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : `non-error ${typeof error}`;
+}
+function httpCause(error) {
+  return {
+    type: "http",
+    requestId: error.requestId,
+    status: error.response.status,
+    code: apiErrorCode(error),
+    eventId: apiErrorEventId(error)
+  };
+}
+function apiErrorEventId(error) {
+  const body = error.response.body;
+  if (typeof body !== "object" || body === null) return null;
+  const eventId = body.event_id;
+  return typeof eventId === "string" ? eventId : null;
+}
+
+// src/universal/core/shared/observability/internal-logger.ts
+function internalLogger(logger, scope) {
+  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
+}
+var LEVEL_RANK = {
+  none: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function scopedLogger(logger, scope, bindings) {
+  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
+  const safe = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {},
+    ...event.cause === void 0 ? {} : { cause: event.cause }
+  });
+  const unredacted = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {}
+  });
+  const self = {
+    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
+    debug: (event) => {
+      if (admits("debug")) logger.debug(() => unredacted(event()));
+    },
+    info: (event) => {
+      if (admits("info")) logger.info(() => safe(event()));
+    },
+    warn: (event) => {
+      if (admits("warn")) logger.warn(() => safe(event()));
+    },
+    error: (event) => {
+      if (admits("error")) logger.error(() => safe(event()));
+    },
+    failure: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("error")) logger.error(() => safe(classified(event(), error)));
+    },
+    warning: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
+    },
+    wrap: async (op, params, run) => {
+      const opLog = self.child({ op });
+      opLog.debug(() => ({ msg: "call", fields: { params } }));
+      try {
+        return await run();
+      } catch (error) {
+        opLog.failure(() => ({ msg: "call failed" }), error);
+        throw error;
+      }
+    }
+  };
+  return self;
+}
+function verbatim(event, error) {
+  return {
+    msg: event.msg,
+    fields: { ...event.fields, error: describeErrorUnredacted(error) }
+  };
+}
+function classified(event, error) {
+  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+}
+var noopInternalLogger = {
+  child: () => noopInternalLogger,
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  failure: () => void 0,
+  warning: () => void 0,
+  wrap: (_op, _params, run) => run()
+};
+
+// 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);
+    });
+  }
+  async getPosition(params) {
+    return this.log.wrap("getPosition", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultPosition(this.ctx.api, params);
+    });
+  }
+  async getRedeemPosition(params) {
+    return this.log.wrap("getRedeemPosition", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
+    });
+  }
+  async createClaim(params) {
+    return this.log.wrap("createClaim", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaim(this.ctx.api, params);
+    });
+  }
+  async createClaimProceeds(params) {
+    return this.log.wrap("createClaimProceeds", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaimProceeds(this.ctx.api, params);
+    });
+  }
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildCentrifugeVaultBuy(this.ctx.api, params);
+    });
+  }
+};
+
+// src/universal/core/checkout/centrifuge/constants.ts
+var CENTRIFUGE_POLL_INTERVAL_MS = 15e3;
+var CENTRIFUGE_INDICATIVE_QUOTE_AMOUNT = BlockchainAmount({
+  raw: 100000000n,
+  decimals: STABLE_DECIMALS
+});
+
+// src/universal/core/checkout/centrifuge/vaults.ts
+function resolveCentrifugeVaults(offer, lookup) {
+  return offer.vaultContracts.map((contract) => {
+    const { chain } = contract;
+    if (!isEthereumChain(chain)) {
+      return { type: "unresolved", chain, missing: "evm-chain" };
+    }
+    const onChain = (role) => offer.tokens.filter(
+      (token) => token.role === role && token.chain === chain
+    );
+    const share = firstKnown(onChain("vault"), lookup);
+    if (share === null) {
+      return { type: "unresolved", chain, missing: "share-token" };
+    }
+    const funding = firstKnown(onChain("funding"), lookup);
+    if (funding === null) {
+      return { type: "unresolved", chain, missing: "funding-token" };
+    }
+    return {
+      type: "resolved",
+      vault: { chain, proxy: contract.address, share, funding }
+    };
+  });
+}
+function firstKnown(tokens, lookup) {
+  for (const token of tokens) {
+    const metadata = lookup(token);
+    if (metadata !== null) return metadata;
+  }
+  return null;
+}
+function isEthereumChain(chain) {
+  return chain in ETHEREUM_CHAINS;
+}
+
+// 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,
+  "centrifuge::vault": true
+};
+var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
+var OfferEditorial = {
+  /**
+   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+   * the same three checks name the payload that failed them.
+   */
+  fromDto: (dto, model) => ({
+    tagline: requiredString(dto.tagline, `${model}.tagline`),
+    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
+    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
+  })
+};
+var Offer = {
+  fromDto: (dto) => {
+    const tokens = requiredArray(dto.tokens, "Offer.tokens");
+    const base2 = {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      tokens: OfferToken.listFromDto(tokens)
+    };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // 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,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      default:
+        return unknownTypeError(dto, "Offer");
+    }
+  },
+  /**
+   * Maps a page of offers, dropping every offer whose `type` this SDK does not
+   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+   * reject the whole page, so one offer of an unknown type would blank the
+   * grid for every offer beside it. A single offer fetched by id still
+   * throws, because there is nothing beside it to keep.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
+};
 var OfferToken = {
   fromDto: (dto) => ({
     role: dto.role,
@@ -729,6 +1392,30 @@ var Ticker = (value) => value;
 var Isin = (value) => value;
 
 // src/universal/types/offer-detail.ts
+var 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) => {
+    switch (offer.type) {
+      case "centrifuge::vault":
+        return true;
+      case "ondo::swap":
+      case "superstate::swap":
+      case "coinlist::token_sale":
+        return false;
+      default: {
+        const exhaustive = offer;
+        return exhaustive;
+      }
+    }
+  }
+};
 var OfferOptionId = (value) => value;
 var OfferOptionSlug = (value) => value;
 var OfferSwapContract = {
@@ -737,6 +1424,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(
@@ -799,6 +1499,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");
     }
@@ -856,246 +1568,72 @@ var ParticipationsPaginationParams = {
     }
     return queryParams;
   }
-};
-var Participation = {
-  /** Maps API DTO shape into the SDK participation domain model. */
-  fromDto: (dto) => {
-    const walletAddress = notBlankStringOrNull(dto.wallet_address);
-    return {
-      id: ParticipationId(dto.id),
-      offerId: OfferId(dto.offer_id),
-      offerOptionId: OfferOptionId(dto.offer_option_id),
-      status: dto.status,
-      amount: dto.amount,
-      displayAmount: dto.amount_string,
-      asset: Asset.fromDto(dto.asset),
-      chain: Blockchain(dto.chain),
-      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
-      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
-      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
-    };
-  }
-};
-var CreateParticipationParams = {
-  /** Maps participation creation params into API DTO payload. */
-  toDto: (params) => ({
-    offer_id: params.offerId,
-    offer_option_id: params.offerOptionId,
-    chain: params.chain,
-    wallet_address: params.walletAddress,
-    amount: params.amount,
-    asset_id: params.assetId,
-    approval_transaction_hash: params.approvalTransactionHash
-  })
-};
-
-// src/universal/api/frontline/providers/coin-list/token-sale.ts
-async function fetchParticipations(api, offerId) {
-  return fetchAllPages(
-    (params) => fetchParticipationsPage(api, params),
-    { offerId }
-  );
-}
-async function fetchParticipationsPage(api, params) {
-  const pageDto = await api.send({
-    method: "GET",
-    url: "/v1/participations",
-    queryParams: ParticipationsPaginationParams.toQueryParams(params),
-    attributes: Attributes.protected()
-  });
-  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
-}
-async function fetchParticipation(api, id) {
-  const dto = await api.send({
-    method: "GET",
-    url: `/v1/participations/${id}`,
-    attributes: Attributes.protected()
-  });
-  return Participation.fromDto(dto);
-}
-async function createParticipation(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/participations",
-    body: CreateParticipationParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return Participation.fromDto(dto);
-}
-
-// src/universal/core/shared/observability/log-cause.ts
-var import_viem = require("viem");
-function classifyLogCause(error) {
-  if (error instanceof HttpError) {
-    return httpCause(error);
-  }
-  if (error instanceof ValidationError) {
-    return { type: "validation", message: error.message };
-  }
-  if (error instanceof InvariantError) {
-    return { type: "invariant", message: error.message };
-  }
-  if (error instanceof MathError) {
-    return { type: "math", message: error.message };
-  }
-  if (error instanceof NotAuthenticatedError) {
-    return { type: "not-authenticated" };
-  }
-  if (error instanceof NotImplementedError) {
-    return { type: "not-implemented" };
-  }
-  if (error instanceof import_viem.BaseError) {
-    const http = error.walk((e) => e instanceof HttpError);
-    if (http instanceof HttpError) {
-      return httpCause(http);
-    }
-    return { type: "rpc", reason: rpcFailureReason(error) };
-  }
-  return { type: "generic-error", name: errorName(error) };
-}
-function rpcFailureReason(error) {
-  if (error.walk((e) => e instanceof import_viem.ContractFunctionRevertedError)) {
-    return "reverted";
-  }
-  if (error.walk((e) => e instanceof import_viem.RpcError)) {
-    return "node-rejected";
-  }
-  if (error.walk(
-    (e) => e instanceof import_viem.HttpRequestError || e instanceof import_viem.WebSocketRequestError || e instanceof import_viem.SocketClosedError || e instanceof import_viem.TimeoutError
-  )) {
-    return "transport";
-  }
-  if (error instanceof import_viem.ContractFunctionExecutionError) {
-    return "malformed-response";
-  }
-  return "unknown";
-}
-function describeErrorUnredacted(error) {
-  if (error instanceof HttpError) {
-    return describeHttpErrorRedacted(error);
-  }
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  return `thrown non-error: ${stringifyUnredacted(error)}`;
-}
-function stringifyUnredacted(value) {
-  if (value === void 0) return "";
-  try {
-    return JSON.stringify(
-      value,
-      (_key, item) => typeof item === "bigint" ? `${item}` : item
-    ) ?? String(value);
-  } catch (_) {
-    return "<unserializable>";
+};
+var Participation = {
+  /** Maps API DTO shape into the SDK participation domain model. */
+  fromDto: (dto) => {
+    const walletAddress = notBlankStringOrNull(dto.wallet_address);
+    return {
+      id: ParticipationId(dto.id),
+      offerId: OfferId(dto.offer_id),
+      offerOptionId: OfferOptionId(dto.offer_option_id),
+      status: dto.status,
+      amount: dto.amount,
+      displayAmount: dto.amount_string,
+      asset: Asset.fromDto(dto.asset),
+      chain: Blockchain(dto.chain),
+      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
+      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
+      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
+    };
   }
-}
-function describeHttpErrorRedacted(error) {
-  const code = apiErrorCode(error);
-  const status = error.response.status;
-  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
-}
-function errorName(error) {
-  return error instanceof Error ? error.name : `non-error ${typeof error}`;
-}
-function httpCause(error) {
-  return {
-    type: "http",
-    requestId: error.requestId,
-    status: error.response.status,
-    code: apiErrorCode(error),
-    eventId: apiErrorEventId(error)
-  };
-}
-function apiErrorEventId(error) {
-  const body = error.response.body;
-  if (typeof body !== "object" || body === null) return null;
-  const eventId = body.event_id;
-  return typeof eventId === "string" ? eventId : null;
-}
+};
+var CreateParticipationParams = {
+  /** Maps participation creation params into API DTO payload. */
+  toDto: (params) => ({
+    offer_id: params.offerId,
+    offer_option_id: params.offerOptionId,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount,
+    asset_id: params.assetId,
+    approval_transaction_hash: params.approvalTransactionHash
+  })
+};
 
-// src/universal/core/shared/observability/internal-logger.ts
-function internalLogger(logger, scope) {
-  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
+// src/universal/api/frontline/providers/coin-list/token-sale.ts
+async function fetchParticipations(api, offerId) {
+  return fetchAllPages(
+    (params) => fetchParticipationsPage(api, params),
+    { offerId }
+  );
 }
-var LEVEL_RANK = {
-  none: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4
-};
-function scopedLogger(logger, scope, bindings) {
-  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
-  const safe = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {},
-    ...event.cause === void 0 ? {} : { cause: event.cause }
-  });
-  const unredacted = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {}
+async function fetchParticipationsPage(api, params) {
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/participations",
+    queryParams: ParticipationsPaginationParams.toQueryParams(params),
+    attributes: Attributes.protected()
   });
-  const self = {
-    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
-    debug: (event) => {
-      if (admits("debug")) logger.debug(() => unredacted(event()));
-    },
-    info: (event) => {
-      if (admits("info")) logger.info(() => safe(event()));
-    },
-    warn: (event) => {
-      if (admits("warn")) logger.warn(() => safe(event()));
-    },
-    error: (event) => {
-      if (admits("error")) logger.error(() => safe(event()));
-    },
-    failure: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("error")) logger.error(() => safe(classified(event(), error)));
-    },
-    warning: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
-    },
-    wrap: async (op, params, run) => {
-      const opLog = self.child({ op });
-      opLog.debug(() => ({ msg: "call", fields: { params } }));
-      try {
-        return await run();
-      } catch (error) {
-        opLog.failure(() => ({ msg: "call failed" }), error);
-        throw error;
-      }
-    }
-  };
-  return self;
+  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
 }
-function verbatim(event, error) {
-  return {
-    msg: event.msg,
-    fields: { ...event.fields, error: describeErrorUnredacted(error) }
-  };
+async function fetchParticipation(api, id) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/participations/${id}`,
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
 }
-function classified(event, error) {
-  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+async function createParticipation(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/participations",
+    body: CreateParticipationParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
 }
-var noopInternalLogger = {
-  child: () => noopInternalLogger,
-  debug: () => void 0,
-  info: () => void 0,
-  warn: () => void 0,
-  error: () => void 0,
-  failure: () => void 0,
-  warning: () => void 0,
-  wrap: (_op, _params, run) => run()
-};
 
 // src/universal/core/checkout/coin-list/token-sale-namespace.ts
 var CoinListTokenSaleNamespaceImpl = class {
@@ -1245,8 +1783,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_viem2 = require("viem");
+var import_viem3 = require("viem");
 
 // src/universal/types/blockchain/ui.ts
 var FormattedAmountUi = (value) => value;
@@ -1265,7 +1809,11 @@ function formatAmount(amount, locale, options) {
   const decimal = formatRawAmount(amount);
   let [integerPart, fractionPart = ""] = decimal.split(".");
   const maxFractionDigits = options?.maxFractionDigits;
-  const minFractionDigits = maxFractionDigits !== void 0 ? Math.min(maxFractionDigits, amount.decimals) : Math.min(2, amount.decimals);
+  const minFractionDigits = Math.min(
+    options?.minFractionDigits ?? (maxFractionDigits !== void 0 ? maxFractionDigits : 2),
+    maxFractionDigits ?? amount.decimals,
+    amount.decimals
+  );
   if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
     ({ integerPart, fractionPart } = roundFractionHalfUp(
       integerPart,
@@ -1273,7 +1821,8 @@ function formatAmount(amount, locale, options) {
       maxFractionDigits
     ));
   }
-  const fraction = minFractionDigits === 0 ? "" : fractionPart.padEnd(minFractionDigits, "0");
+  const trimmed = fractionPart.replace(/0+$/, "");
+  const fraction = trimmed.padEnd(minFractionDigits, "0");
   const integerFormatted = BigInt(integerPart).toLocaleString(locale);
   if (minFractionDigits === 0 && fraction === "") {
     return FormattedAmountUi(integerFormatted);
@@ -1312,7 +1861,7 @@ function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
   };
 }
 function formatRawAmount(amount) {
-  return (0, import_viem2.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem3.formatUnits)(amount.raw, amount.decimals);
 }
 function formatCompactAmount(amount, locale) {
   const value = Number(formatRawAmount(amount));
@@ -1342,6 +1891,14 @@ function assetAmount(amount, symbol) {
   return FormattedAmountAssetUi(`${amount} ${symbol}`);
 }
 var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
+var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
+var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
+function formatShareAmount(amount, locale) {
+  return formatAmount(amount, locale, {
+    maxFractionDigits: SHARE_MAX_FRACTION_DIGITS,
+    minFractionDigits: SHARE_MIN_FRACTION_DIGITS
+  });
+}
 var USD_FRACTION_DIGITS = AssetDecimals(2);
 function formattedUsdPrice(amount, locale) {
   if (!amount) return NA_AMOUNT_ASSET_UI;
@@ -1408,66 +1965,6 @@ function explorerBaseUrl(chain) {
   }
 }
 
-// src/universal/core/shared/blockchain/math.ts
-var import_viem3 = 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_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/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1483,7 +1980,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -3314,7 +3810,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"
   );
@@ -3355,11 +3853,18 @@ var HttpClient = class {
     );
     let response = await this.executeRequest(preparedRequest);
     for (const middleware of this.middleware.afterRequest ?? []) {
+      let retried = false;
       response = await middleware({
         request: preparedRequest,
         response,
-        retry: (nextRequest = preparedRequest) => this.runRequestWithAfterMiddleware(nextRequest)
+        retry: (nextRequest = preparedRequest) => {
+          retried = true;
+          return this.runRequestWithAfterMiddleware(nextRequest);
+        }
       });
+      if (retried) {
+        return response;
+      }
     }
     return response;
   }
@@ -3833,6 +4338,27 @@ var RedactedWalletError = {
   fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
 };
 
+// src/universal/types/blockchain/wallet-selection.ts
+var WalletSelection = {
+  /**
+   * Every wallet in display order - embedded first, then the external one -
+   * each address once. Addresses compare case-insensitively, so a host that
+   * hands the same wallet over as both embedded and external sees it once.
+   */
+  all: (selection) => {
+    const seen = /* @__PURE__ */ new Set();
+    return [
+      ...selection.embedded,
+      ...selection.external === null ? [] : [selection.external]
+    ].filter((wallet) => {
+      const key = wallet.address.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+};
+
 // src/universal/types/oauth-session.ts
 var ClientCredentialsOAuth = (value) => value;
 var OAuthRefreshToken = (value) => value;
@@ -3849,6 +4375,54 @@ var OAuthSession = {
   }
 };
 
+// src/universal/types/time.ts
+var MAX_EPOCH_MILLIS = 864e13;
+var 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) => {
+    if (!Number.isInteger(value) || Math.abs(value) > MAX_EPOCH_MILLIS) {
+      throw new ValidationError(
+        `EpochMillis must be an integer within \xB1${MAX_EPOCH_MILLIS}, got ${value}`
+      );
+    }
+    return value;
+  },
+  /** The wall clock. Code that needs the time takes a `TimeEff` instead. */
+  now: () => EpochMillis.of(Date.now()),
+  /** @throws {@link ValidationError} for an invalid `Date`. */
+  fromDate: (date) => EpochMillis.of(date.getTime()),
+  /** How long after `from` the instant `to` is; negative if it is before. */
+  elapsed: (from, to) => Millis.of(to - from),
+  plus: (at, duration) => EpochMillis.of(at + duration)
+};
+var Millis = {
+  of: (value) => value
+};
+var Seconds = {
+  /**
+   * @throws {@link ValidationError} unless `value` is a non-negative integer.
+   */
+  of: (value) => {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new ValidationError(
+        `Seconds must be a non-negative integer, got ${value}`
+      );
+    }
+    return value;
+  },
+  toMillis: (value) => Millis.of(value * 1e3)
+};
+function isExpired({
+  expiresAt,
+  now,
+  buffer = Millis.of(0)
+}) {
+  return now >= expiresAt - buffer;
+}
+
 // src/universal/types/user.ts
 var UserId = (value) => value;
 var UserEmail = (value) => value;
@@ -3867,11 +4441,24 @@ var User = {
   AssetIconUrl,
   AssetId,
   AssetSymbol,
+  AsyncOfferDetail,
   AuthorizationCode,
   BPS_DENOM,
   Blockchain,
   BlockchainAmount,
   Bps,
+  CENTRIFUGE_INDICATIVE_QUOTE_AMOUNT,
+  CENTRIFUGE_POLL_INTERVAL_MS,
+  CentrifugeNamespaceImpl,
+  CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimProceedsTransaction,
+  CentrifugeVaultClaimTransaction,
+  CentrifugeVaultLeg,
+  CentrifugeVaultLegId,
+  CentrifugeVaultPosition,
+  CentrifugeVaultQuote,
+  CentrifugeVaultRedeemPosition,
+  CentrifugeVaultStatus,
   Chain,
   ClientCredentialsOAuth,
   ClientId,
@@ -3891,6 +4478,7 @@ var User = {
   DocumentSubmission,
   ERC20_ABI,
   ETHEREUM_CHAINS,
+  EpochMillis,
   Erc20NamespaceImpl,
   EthereumChain,
   EvmContractAddress,
@@ -3911,11 +4499,13 @@ var User = {
   MAX_UINT_256,
   MathError,
   Milestone,
+  Millis,
   NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError,
   NotImplementedError,
   OAuthRefreshToken,
   OAuthSession,
+  ONDO_NOT_TRADABLE_CODE,
   ONDO_POLL_INTERVAL_MS,
   ONDO_QUOTE_MAX_TTL_MS,
   ONDO_SETTLEMENT_ASSET,
@@ -3932,6 +4522,7 @@ var User = {
   OfferSlug,
   OfferSwapContract,
   OfferToken,
+  OfferVaultContract,
   OffersNamespaceImpl,
   OndoBuyTransaction,
   OndoNamespaceImpl,
@@ -3963,6 +4554,7 @@ var User = {
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
   SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS,
+  Seconds,
   ShortenedWalletAddress,
   SolanaChain,
   StablecoinSymbol,
@@ -3989,6 +4581,7 @@ var User = {
   ValidationError,
   WalletAddress,
   WalletOwnershipChallenge,
+  WalletSelection,
   WalletsNamespaceImpl,
   apiErrorCode,
   applyBps,
@@ -4006,18 +4599,22 @@ var User = {
   formatBpsAsPercent,
   formatCompactAmount,
   formatRawAmount,
+  formatShareAmount,
   formattedPricePerShare,
   formattedUsdPrice,
   generatePKCEParams,
   getChainId,
   getNetworkName,
   isChain,
+  isExpired,
   isOfferType,
+  isOndoNotTradableError,
   isSwapAvailable,
   offerDisplayTokens,
   ondoQuoteOfferDeadline,
   parseBlockchainAmount,
   parseUint256,
+  resolveCentrifugeVaults,
   shortenAddress,
   superstateSwapContractAddress,
   swapSpender,