@coinlist-co/react 0.12.2-rc.31c2f50 → 0.12.2-rc.3de3751

package/dist/{chunk-NBO5E2RO.js → chunk-HMLWCXAP.js}

@@ -291,165 +291,74 @@ function isExpired({
   return now >= expiresAt - buffer;
 }
 
-// src/universal/core/shared/blockchain/erc20/abi.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "name",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "symbol",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    inputs: [
-      { name: "sender", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      { name: "owner", type: "address", indexed: true },
-      { name: "spender", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      { name: "from", type: "address", indexed: true },
-      { name: "to", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  }
-];
-
-// src/universal/api/pagination.ts
-async function fetchAllPages(fetchPage, baseParams) {
-  const items = [];
-  let cursor = null;
-  do {
-    const params = {
-      ...baseParams ?? {},
-      after: cursor ?? void 0
-    };
-    const page = await fetchPage(params);
-    items.push(...page.data);
-    cursor = page.startingAfter;
-  } while (cursor);
-  return items;
-}
+// src/universal/types/blockchain/ui.ts
+var FormattedAmountUi = (value) => value;
+var FormattedPercentUi = (value) => value;
+var TxExplorerUrl = (value) => value;
+var ShortenedWalletAddress = (value) => value;
+var FormattedAmountAssetUi = (value) => value;
+var AssetIconUrl = (value) => value;
 
-// 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
-  })
+// src/universal/core/shared/blockchain/chain.ts
+import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
+var VIEM_CHAINS = {
+  ethereum_mainnet: mainnet,
+  ethereum_sepolia: sepolia,
+  base_mainnet: base,
+  base_sepolia: baseSepolia
 };
-var PaginationParams = {
-  toQueryParams: (params) => {
-    const queryParams = {};
-    if (params.after) {
-      queryParams.starting_after = params.after;
-    }
-    if (params.before) {
-      queryParams.starting_before = params.before;
+function viemChain(chain) {
+  return VIEM_CHAINS[chain];
+}
+function getChainId(chain) {
+  return VIEM_CHAINS[chain].id;
+}
+function chainFromId(chainId) {
+  const chains = Object.keys(VIEM_CHAINS);
+  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
+  if (!chain) {
+    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
+  }
+  return chain;
+}
+function contractOn(contracts, chain) {
+  return contracts.find((contract) => contract.chain === chain)?.address ?? null;
+}
+function getNetworkName(chain) {
+  switch (chain) {
+    case "ethereum_mainnet":
+      return "Ethereum";
+    case "ethereum_sepolia":
+      return "Ethereum Sepolia";
+    case "base_mainnet":
+      return "Base";
+    case "base_sepolia":
+      return "Base Sepolia";
+    default: {
+      const _exhaustive = chain;
+      return _exhaustive;
     }
-    if (params.limit) {
-      queryParams.limit = params.limit;
+  }
+}
+function txExplorerUrl(chain, txHash) {
+  return TxExplorerUrl(`${explorerBaseUrl(chain)}/tx/${txHash}`);
+}
+function explorerBaseUrl(chain) {
+  switch (chain) {
+    case "ethereum_mainnet":
+      return "https://etherscan.io";
+    case "ethereum_sepolia":
+      return "https://sepolia.etherscan.io";
+    case "base_mainnet":
+      return "https://basescan.org";
+    case "base_sepolia":
+      return "https://sepolia-explorer.base.org";
+    default: {
+      const _exhaustive = chain;
+      return _exhaustive;
     }
-    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/blockchain/core.ts
 var ETHEREUM_CHAINS = {
@@ -513,8 +422,18 @@ var BlockchainAmount = Object.assign(
   {
     add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
     sub: (a, b) => combineAmounts(a, b, (x, y) => x - y),
-    mul: multiplyAmounts,
-    div: divideAmounts
+    /**
+     * `a * b`, in `a`'s decimals - a price times a quantity. Multiplies before
+     * it rescales, then truncates towards zero. The exact inverse of `div`.
+     */
+    mul: (a, b) => multiplyAmounts(a, b),
+    /**
+     * `a / b`, in `a`'s decimals - a price, a ratio. Rescales before it
+     * divides, then truncates towards zero.
+     *
+     * @throws MathError when `b` is zero.
+     */
+    div: (a, b) => divideAmounts(a, b)
   }
 );
 function multiplyAmounts(a, b) {
@@ -548,30 +467,120 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
-// src/universal/core/shared/utils/crypto.ts
-async function sha256(data) {
-  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-  const buffer = bytes.buffer.slice(
-    bytes.byteOffset,
-    bytes.byteOffset + bytes.byteLength
-  );
-  return crypto.subtle.digest("SHA-256", buffer);
-}
-function arrayBufferToBase64Url(buffer, padding = true) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
+// src/universal/core/shared/blockchain/math.ts
+import { parseUnits } from "viem";
+function blockchainAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals
+}) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
   }
-  let base64 = btoa(binary);
-  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
-  if (!padding) {
-    base64 = base64.replace(/=+$/, "");
+  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})`);
   }
-  return base64;
 }
-function generateSecureRandomBase64Url(byteLength) {
-  const bytes = new Uint8Array(byteLength);
+function positiveAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals,
+  reason
+}) {
+  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
+  if (amount.raw === 0n) {
+    throw new ValidationError(
+      `${label}: must be greater than zero ("${raw}") - ${reason}`
+    );
+  }
+  return amount;
+}
+function pricePerShare({
+  usd,
+  shares
+}) {
+  const price = BlockchainAmount.div(usd, shares);
+  return BlockchainAmount({
+    raw: assertPriceFits(price.raw),
+    decimals: price.decimals
+  });
+}
+function assertPriceFits(raw) {
+  if (raw > MAX_UINT_256) {
+    throw new MathError(`Price per share: out of uint256 bounds (${raw})`);
+  }
+  return raw;
+}
+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 = 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/crypto.ts
+async function sha256(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  return crypto.subtle.digest("SHA-256", buffer);
+}
+function arrayBufferToBase64Url(buffer, padding = true) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  let base64 = btoa(binary);
+  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+  if (!padding) {
+    base64 = base64.replace(/=+$/, "");
+  }
+  return base64;
+}
+function generateSecureRandomBase64Url(byteLength) {
+  const bytes = new Uint8Array(byteLength);
   crypto.getRandomValues(bytes);
   const buffer = bytes.buffer;
   return arrayBufferToBase64Url(buffer, false);
@@ -637,318 +646,286 @@ function requiredArray(value, field) {
   }
   return value;
 }
+function txFromWire(wire) {
+  return {
+    to: EvmContractAddress(wire.to),
+    data: HexEncodedTransactionData(wire.data)
+  };
+}
 
-// 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`)
+// src/universal/types/providers/centrifuge/centrifuge.ts
+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)
+    return {
+      ...parseTransactionCore(dto, "CentrifugeVaultBuyTransaction"),
+      spendInputAmount: positiveAmountFromRawOrThrow({
+        label: "spend_input_amount",
+        raw: dto.spend_input_amount,
+        decimals: AssetDecimals(dto.spend_input_decimals),
+        // Frontline refuses an `amount` of zero, so a zero here is a changed
+        // encoding, not a small deposit - and not calldata worth signing.
+        reason: "a deposit of nothing is not a request"
+      })
     };
-    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,
-    chain: Chain(dto.chain),
-    address: EvmContractAddress(dto.address)
-  }),
-  /**
-   * Maps an offer's token list, dropping every token on a chain this SDK does
-   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
-   * plain `.map` would throw out of `Offer.fromDto` and, through
-   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
-   * one Base token blanked production's offers list. Dropping costs that
-   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
-   * so nobody could have looked it up anyway.
-   *
-   * Same shape as `TokenMetadata.fromRegistryDto`.
-   */
-  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
+  }
 };
-
-// src/universal/types/trading.ts
-var Ticker = (value) => value;
-var Isin = (value) => value;
-
-// src/universal/types/offer-detail.ts
-var OfferOptionId = (value) => value;
-var OfferOptionSlug = (value) => value;
-var OfferSwapContract = {
+var CentrifugeVaultClaimTransaction = {
   fromDto: (dto) => ({
-    chain: Chain(dto.chain),
-    address: EvmContractAddress(dto.address)
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimTransaction"),
+    claimableShares: blockchainAmountFromRawOrThrow({
+      label: "claimable_shares",
+      raw: dto.claimable_shares,
+      decimals: AssetDecimals(dto.share_decimals)
+    })
   })
 };
-var OfferVaultContract = {
+var CentrifugeAssets = (amount) => amount;
+var CentrifugeShares = (amount) => amount;
+var CentrifugeDepositPosition = {
+  fromContract: (raw, context) => {
+    const assets = (label, value) => CentrifugeAssets(contractAmount(label, value, context.assetDecimals));
+    return {
+      chain: context.chain,
+      proxy: context.proxy,
+      walletAddress: context.walletAddress,
+      pending: assets("pendingDepositRequest", raw.pendingDepositRequest),
+      claimable: assets("claimableDepositRequest", raw.claimableDepositRequest)
+    };
+  }
+};
+var CentrifugeRedeemPosition = {
+  fromContract: (raw, context) => {
+    const shares = (label, value) => CentrifugeShares(contractAmount(label, value, context.shareDecimals));
+    return {
+      chain: context.chain,
+      proxy: context.proxy,
+      walletAddress: context.walletAddress,
+      pending: shares("pendingRedeemRequest", raw.pendingRedeemRequest),
+      claimable: shares("claimableRedeemRequest", raw.claimableRedeemRequest)
+    };
+  }
+};
+var CentrifugeVaultLeg = {
+  /** Whether the leg has anything queued or anything ready to claim. */
+  isActive: (leg) => leg.position.pending.raw > 0n || leg.position.claimable.raw > 0n
+};
+function contractAmount(label, value, decimals) {
+  return BlockchainAmount({ raw: parseUint256(value, label), decimals });
+}
+var CentrifugeVaultLegId = {
+  /** Addresses compare case-insensitively: a host may pass either case. */
+  of: (leg) => [
+    leg.direction,
+    leg.position.chain,
+    leg.position.walletAddress.toLowerCase()
+  ].join(":")
+};
+var CentrifugeVaultClaimProceedsTransaction = {
   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)
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    })
+  })
 };
-var OfferDetail = {
-  fromDto: (dto) => {
-    const fundingAssets = requiredArray(
-      dto.funding_assets,
-      "OfferDetail.funding_assets"
+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`
     );
-    const options = requiredArray(dto.options, "OfferDetail.options");
-    const terms = requiredArray(dto.terms, "OfferDetail.terms");
-    const links = requiredArray(dto.links, "OfferDetail.links");
-    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
-    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
-    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
-    const isin = notBlankStringOrNull(dto.isin);
-    const ticker = notBlankStringOrNull(dto.ticker);
-    const base2 = {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      name: dto.name,
-      asset: Asset.fromDto(dto.asset),
-      fundingAssets: fundingAssets.map(Asset.fromDto),
-      tokens: OfferToken.listFromDto(tokens),
-      about: notBlankStringOrNull(dto.about),
-      category: dto.category,
-      issuer: notBlankStringOrNull(dto.issuer),
-      isin: isin === null ? null : Isin(isin),
-      ticker: ticker === null ? null : Ticker(ticker),
-      instrumentType: notBlankStringOrNull(dto.instrument_type),
-      listingVenue: notBlankStringOrNull(dto.listing_venue),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      faqs: faqs.map(FaqItem.fromDto),
-      links: links.map(Link.fromDto),
-      milestones: milestones.map(Milestone.fromDto),
-      options: options.map(OfferOption.fromDto),
-      terms: terms.map(TermItem.fromDto)
-    };
-    switch (dto.type) {
-      case "coinlist::token_sale":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "OfferDetail"),
-          type: dto.type,
-          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
-        };
-      case "superstate::swap":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "OfferDetail"),
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url)
-        };
-      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
-      // on the wire, as in `Offer.fromDto`.
-      case "ondo::swap":
-        return {
-          ...base2,
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url),
-          swapContracts: requiredArray(
-            dto.swap_contracts,
-            "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");
-    }
-  }
-};
-var OfferOption = {
-  fromDto: (dto) => ({
-    id: OfferOptionId(dto.id),
-    slug: OfferOptionSlug(dto.slug),
-    bidIncrement: dto.bid_increment,
-    floorPriceUsd: dto.floor_price_usd,
-    minimumPurchaseUsd: dto.minimum_purchase_usd,
-    priceUsd: dto.price_usd,
-    saleAgreementUrl: notBlankStringOrNull(dto.sale_agreement_url),
-    totalTokenSupply: dto.total_token_supply
-  })
-};
-var FaqItem = {
-  fromDto: (dto) => ({
-    question: notBlankStringOrNull(dto.question),
-    answer: notBlankStringOrNull(dto.answer)
-  })
-};
-var Link = {
-  fromDto: (dto) => ({
-    label: notBlankStringOrNull(dto.label),
-    url: notBlankStringOrNull(dto.url)
-  })
-};
-var TermItem = {
-  fromDto: (dto) => ({
-    key: notBlankStringOrNull(dto.key),
-    value: notBlankStringOrNull(dto.value)
-  })
-};
-var Milestone = {
-  fromDto: (dto) => ({
-    name: notBlankStringOrNull(dto.name),
-    schedule: notBlankStringOrNull(dto.schedule),
-    status: dto.status
-  })
-};
-
-// src/universal/types/providers/coin-list/token-sale.ts
-var ParticipationId = (value) => value;
-var Blockchain = (value) => value;
-var WalletAddress = (value) => value;
-var ParticipationsPaginationParams = {
-  toQueryParams: (params) => {
-    const queryParams = PaginationParams.toQueryParams(params);
-    if (params.offerId) {
-      queryParams["filters[0][field]"] = "offer_id";
-      queryParams["filters[0][op]"] = "==";
-      queryParams["filters[0][value]"] = params.offerId;
-    }
-    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
-  })
-};
+  return { type: "blocked", reasons: [first, ...rest] };
+}
+function parseTransactionCore(dto, model) {
+  return {
+    tx: txFromWire(dto),
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
+}
 
-// src/universal/api/frontline/providers/coin-list/token-sale.ts
-async function fetchParticipations(api, offerId) {
-  return fetchAllPages(
-    (params) => fetchParticipationsPage(api, params),
-    { offerId }
+// src/universal/api/frontline/providers/shared/spend-scale.ts
+function assertSpendScaleAgrees({
+  published,
+  sized,
+  trade,
+  note
+}) {
+  if (published === sized.decimals) return;
+  const because = note === void 0 ? "" : ` - ${note}`;
+  throw new ValidationError(
+    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
   );
 }
-async function fetchParticipationsPage(api, params) {
-  const pageDto = await api.send({
+
+// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
+async function getCentrifugeVaultStatus(api, params) {
+  const dto = await api.send({
     method: "GET",
-    url: "/v1/participations",
-    queryParams: ParticipationsPaginationParams.toQueryParams(params),
+    url: "/v1/centrifuge/vault/status",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain
+    },
     attributes: Attributes.protected()
   });
-  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
+  return CentrifugeVaultStatus.fromDto(dto);
 }
-async function fetchParticipation(api, id) {
+async function buildCentrifugeVaultBuy(api, params) {
   const dto = await api.send({
-    method: "GET",
-    url: `/v1/participations/${id}`,
+    method: "POST",
+    url: "/v1/centrifuge/vault/invest",
+    body: {
+      ...walletFields(params),
+      amount: params.amount.raw.toString()
+    },
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "deposit"
+  });
+  return CentrifugeVaultBuyTransaction.fromDto(dto);
 }
-async function createParticipation(api, params) {
+async function createCentrifugeVaultClaim(api, params) {
   const dto = await api.send({
     method: "POST",
-    url: "/v1/participations",
-    body: CreateParticipationParams.toDto(params),
+    url: "/v1/centrifuge/vault/claim",
+    body: walletFields(params),
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  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/providers/checkout/centrifuge/blockchain/abi.ts
+var CENTRIFUGE_PROXY_ABI = [
+  {
+    type: "function",
+    name: "pendingDepositRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimableDepositRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingRedeemRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimableRedeemRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// src/universal/api/rpc/providers/centrifuge/position.ts
+async function readCentrifugeDepositPosition(clients, params) {
+  const client = clients(params.vault.chain);
+  const proxy = proxyOf(params);
+  const wallet = params.walletAddress;
+  const [pendingDepositRequest, claimableDepositRequest] = await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { ...proxy, functionName: "pendingDepositRequest", args: [wallet] },
+      { ...proxy, functionName: "claimableDepositRequest", args: [wallet] }
+    ]
+  });
+  return CentrifugeDepositPosition.fromContract(
+    { pendingDepositRequest, claimableDepositRequest },
+    contextOf(params)
+  );
+}
+async function readCentrifugeRedeemPosition(clients, params) {
+  const client = clients(params.vault.chain);
+  const proxy = proxyOf(params);
+  const wallet = params.walletAddress;
+  const [pendingRedeemRequest, claimableRedeemRequest] = await client.multicall(
+    {
+      allowFailure: false,
+      contracts: [
+        { ...proxy, functionName: "pendingRedeemRequest", args: [wallet] },
+        { ...proxy, functionName: "claimableRedeemRequest", args: [wallet] }
+      ]
+    }
+  );
+  return CentrifugeRedeemPosition.fromContract(
+    { pendingRedeemRequest, claimableRedeemRequest },
+    contextOf(params)
+  );
+}
+function proxyOf(params) {
+  return { address: params.vault.proxy, abi: CENTRIFUGE_PROXY_ABI };
+}
+function contextOf(params) {
+  return {
+    chain: params.vault.chain,
+    proxy: params.vault.proxy,
+    walletAddress: params.walletAddress,
+    assetDecimals: params.vault.funding.decimals,
+    shareDecimals: params.vault.share.decimals
+  };
 }
 
 // src/universal/core/shared/observability/log-cause.ts
@@ -1134,46 +1111,52 @@ var noopInternalLogger = {
   wrap: (_op, _params, run) => run()
 };
 
-// src/universal/core/checkout/coin-list/token-sale-namespace.ts
-var CoinListTokenSaleNamespaceImpl = class {
+// src/universal/core/providers/checkout/centrifuge/centrifuge-namespace.ts
+var CentrifugeNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "TOKEN_SALE");
+    this.log = internalLogger(ctx.logger, "CENTRIFUGE");
   }
-  async list(offerId) {
-    return this.log.wrap("list", offerId, async () => {
+  async getVaultStatus(params) {
+    return this.log.wrap("getVaultStatus", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchParticipations(this.ctx.api, offerId);
+      return getCentrifugeVaultStatus(this.ctx.api, params);
     });
   }
-  async listPage(params) {
-    return this.log.wrap("listPage", params, async () => {
+  async readDepositPosition(params) {
+    return this.log.wrap(
+      "readDepositPosition",
+      params,
+      () => readCentrifugeDepositPosition(this.ctx.rpc, params)
+    );
+  }
+  async readRedeemPosition(params) {
+    return this.log.wrap(
+      "readRedeemPosition",
+      params,
+      () => readCentrifugeRedeemPosition(this.ctx.rpc, params)
+    );
+  }
+  async createClaim(params) {
+    return this.log.wrap("createClaim", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchParticipationsPage(this.ctx.api, params);
+      return createCentrifugeVaultClaim(this.ctx.api, params);
     });
   }
-  async get(id) {
-    return this.log.wrap("get", id, async () => {
+  async createClaimProceeds(params) {
+    return this.log.wrap("createClaimProceeds", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchParticipation(this.ctx.api, id);
+      return createCentrifugeVaultClaimProceeds(this.ctx.api, params);
     });
   }
-  async createParticipation(params) {
-    return this.log.wrap("createParticipation", params, async () => {
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return createParticipation(this.ctx.api, params);
+      return buildCentrifugeVaultBuy(this.ctx.api, params);
     });
   }
 };
 
-// src/universal/types/blockchain/ui.ts
-var FormattedAmountUi = (value) => value;
-var FormattedPercentUi = (value) => value;
-var TxExplorerUrl = (value) => value;
-var ShortenedWalletAddress = (value) => value;
-var FormattedAmountAssetUi = (value) => value;
-var AssetIconUrl = (value) => value;
-
 // src/universal/core/shared/blockchain/formatters.ts
 import { formatUnits } from "viem";
 function shortenAddress(address) {
@@ -1282,123 +1265,432 @@ function formattedUsdPrice(amount, locale) {
   );
 }
 
-// src/universal/core/shared/blockchain/chain.ts
-import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
-var VIEM_CHAINS = {
-  ethereum_mainnet: mainnet,
-  ethereum_sepolia: sepolia,
-  base_mainnet: base,
-  base_sepolia: baseSepolia
+// 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
+  })
 };
-function viemChain(chain) {
-  return VIEM_CHAINS[chain];
-}
-function getChainId(chain) {
-  return VIEM_CHAINS[chain].id;
-}
-function chainFromId(chainId) {
-  const chains = Object.keys(VIEM_CHAINS);
-  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
-  if (!chain) {
-    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
+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;
   }
-  return chain;
-}
-function getNetworkName(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return "Ethereum";
-    case "ethereum_sepolia":
-      return "Ethereum Sepolia";
-    case "base_mainnet":
-      return "Base";
-    case "base_sepolia":
-      return "Base Sepolia";
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
+};
+
+// 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,
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Maps an offer's token list, dropping every token on a chain this SDK does
+   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
+   * plain `.map` would throw out of `Offer.fromDto` and, through
+   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
+   * one Base token blanked production's offers list. Dropping costs that
+   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
+   * so nobody could have looked it up anyway.
+   *
+   * Same shape as `TokenMetadata.fromRegistryDto`.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
+};
+
+// src/universal/types/trading.ts
+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;
+      }
     }
   }
-}
-function txExplorerUrl(chain, txHash) {
-  return TxExplorerUrl(`${explorerBaseUrl(chain)}/tx/${txHash}`);
-}
-function explorerBaseUrl(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return "https://etherscan.io";
-    case "ethereum_sepolia":
-      return "https://sepolia.etherscan.io";
-    case "base_mainnet":
-      return "https://basescan.org";
-    case "base_sepolia":
-      return "https://sepolia-explorer.base.org";
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
+};
+var OfferOptionId = (value) => value;
+var OfferOptionSlug = (value) => value;
+var OfferSwapContract = {
+  fromDto: (dto) => ({
+    chain: Chain(dto.chain),
+    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(
+      dto.funding_assets,
+      "OfferDetail.funding_assets"
+    );
+    const options = requiredArray(dto.options, "OfferDetail.options");
+    const terms = requiredArray(dto.terms, "OfferDetail.terms");
+    const links = requiredArray(dto.links, "OfferDetail.links");
+    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
+    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
+    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
+    const isin = notBlankStringOrNull(dto.isin);
+    const ticker = notBlankStringOrNull(dto.ticker);
+    const base2 = {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      name: dto.name,
+      asset: Asset.fromDto(dto.asset),
+      fundingAssets: fundingAssets.map(Asset.fromDto),
+      tokens: OfferToken.listFromDto(tokens),
+      about: notBlankStringOrNull(dto.about),
+      category: dto.category,
+      issuer: notBlankStringOrNull(dto.issuer),
+      isin: isin === null ? null : Isin(isin),
+      ticker: ticker === null ? null : Ticker(ticker),
+      instrumentType: notBlankStringOrNull(dto.instrument_type),
+      listingVenue: notBlankStringOrNull(dto.listing_venue),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      faqs: faqs.map(FaqItem.fromDto),
+      links: links.map(Link.fromDto),
+      milestones: milestones.map(Milestone.fromDto),
+      options: options.map(OfferOption.fromDto),
+      terms: terms.map(TermItem.fromDto)
+    };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire, as in `Offer.fromDto`.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          swapContracts: requiredArray(
+            dto.swap_contracts,
+            "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");
     }
   }
-}
+};
+var OfferOption = {
+  fromDto: (dto) => ({
+    id: OfferOptionId(dto.id),
+    slug: OfferOptionSlug(dto.slug),
+    bidIncrement: dto.bid_increment,
+    floorPriceUsd: dto.floor_price_usd,
+    minimumPurchaseUsd: dto.minimum_purchase_usd,
+    priceUsd: dto.price_usd,
+    saleAgreementUrl: notBlankStringOrNull(dto.sale_agreement_url),
+    totalTokenSupply: dto.total_token_supply
+  })
+};
+var FaqItem = {
+  fromDto: (dto) => ({
+    question: notBlankStringOrNull(dto.question),
+    answer: notBlankStringOrNull(dto.answer)
+  })
+};
+var Link = {
+  fromDto: (dto) => ({
+    label: notBlankStringOrNull(dto.label),
+    url: notBlankStringOrNull(dto.url)
+  })
+};
+var TermItem = {
+  fromDto: (dto) => ({
+    key: notBlankStringOrNull(dto.key),
+    value: notBlankStringOrNull(dto.value)
+  })
+};
+var Milestone = {
+  fromDto: (dto) => ({
+    name: notBlankStringOrNull(dto.name),
+    schedule: notBlankStringOrNull(dto.schedule),
+    status: dto.status
+  })
+};
 
-// src/universal/core/shared/blockchain/math.ts
-import { parseUnits } from "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}")`);
+// src/universal/types/providers/coin-list/token-sale.ts
+var ParticipationId = (value) => value;
+var ParticipationsPaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (params.offerId) {
+      queryParams["filters[0][field]"] = "offer_id";
+      queryParams["filters[0][op]"] = "==";
+      queryParams["filters[0][value]"] = params.offerId;
+    }
+    return queryParams;
   }
-  try {
-    return BlockchainAmount({ raw: assertUint256(value), decimals });
-  } catch {
-    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+};
+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: isChain(dto.chain) ? dto.chain : null,
+      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
+      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
+      walletAddress: walletAddress ? EvmWalletAddress(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/pagination.ts
+async function fetchAllPages(fetchPage, baseParams) {
+  const items = [];
+  let cursor = null;
+  do {
+    const params = {
+      ...baseParams ?? {},
+      after: cursor ?? void 0
+    };
+    const page = await fetchPage(params);
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
 }
-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" } };
+
+// 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/providers/checkout/coin-list/token-sale-namespace.ts
+var CoinListTokenSaleNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "TOKEN_SALE");
   }
-  if (trimmed === ".") {
-    return { valid: false, reason: { type: "invalid-format" } };
+  async list(offerId) {
+    return this.log.wrap("list", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipations(this.ctx.api, offerId);
+    });
   }
-  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
-  if (!/^\d+(\.\d+)?$/.test(normalised)) {
-    return { valid: false, reason: { type: "invalid-format" } };
+  async listPage(params) {
+    return this.log.wrap("listPage", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipationsPage(this.ctx.api, params);
+    });
   }
-  const [, fraction = ""] = normalised.split(".");
-  if (fraction.length > decimals) {
-    return {
-      valid: false,
-      reason: { type: "too-many-decimals", maxDecimals: decimals }
-    };
+  async get(id) {
+    return this.log.wrap("get", id, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipation(this.ctx.api, id);
+    });
   }
-  try {
-    const raw = 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" } };
+  async createParticipation(params) {
+    return this.log.wrap("createParticipation", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createParticipation(this.ctx.api, params);
+    });
   }
-}
+};
 
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
@@ -1454,7 +1746,7 @@ var OndoBuyTransaction = {
         raw: dto.notional_value,
         decimals: spendDecimals
       }),
-      receiveOutputAmount: parsePositiveAmount({
+      receiveOutputAmount: positiveAmountFromRawOrThrow({
         label: "receive_output_amount",
         raw: dto.receive_output_amount,
         decimals: outputDecimals,
@@ -1473,7 +1765,7 @@ var OndoSellTransaction = {
   fromDto: (dto) => {
     const spendDecimals = AssetDecimals(dto.spend_input_decimals);
     const outputDecimals = AssetDecimals(dto.receive_output_decimals);
-    const expectedQuantity = parsePositiveAmount({
+    const expectedQuantity = positiveAmountFromRawOrThrow({
       label: "expected_quantity",
       raw: dto.expected_quantity,
       decimals: outputDecimals,
@@ -1507,12 +1799,12 @@ var OndoSellTransaction = {
 };
 function parseSwapCore(dto, spendDecimals) {
   return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: parseExpiresAt(dto.expires_at),
-    spendInputAmount: parsePositiveAmount({
+    tx: txFromWire(dto),
+    // A transaction whose expiry cannot be read is not safely fillable - the
+    // deadline is encoded in the calldata either way, so broadcasting against
+    // an unknown one only spends gas on a revert.
+    expiresAt: requiredDate(dto.expires_at, "expires_at"),
+    spendInputAmount: positiveAmountFromRawOrThrow({
       label: "spend_input_amount",
       raw: dto.spend_input_amount,
       decimals: spendDecimals,
@@ -1530,7 +1822,7 @@ function parseSwapCore(dto, spendDecimals) {
   };
 }
 function parseMinimumQuantity(raw, decimals, expectedQuantity) {
-  const amount = parsePositiveAmount({
+  const amount = positiveAmountFromRawOrThrow({
     label: "minimum_quantity",
     raw,
     decimals,
@@ -1543,27 +1835,6 @@ function parseMinimumQuantity(raw, decimals, expectedQuantity) {
   }
   return amount;
 }
-function parsePositiveAmount({
-  label,
-  raw,
-  decimals,
-  reason
-}) {
-  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
-  if (amount.raw <= 0n) {
-    throw new ValidationError(
-      `${label}: must be greater than zero ("${raw}") - ${reason}`
-    );
-  }
-  return amount;
-}
-function parseExpiresAt(value) {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new ValidationError(`expires_at: not a date ("${value}")`);
-  }
-  return date;
-}
 
 // src/universal/api/frontline/providers/ondo/ondo.ts
 async function getOndoTradingStatus(api, params) {
@@ -1629,18 +1900,6 @@ function swapBody(params) {
     amount: params.amount.raw.toString()
   };
 }
-function assertSpendScaleAgrees({
-  published,
-  sized,
-  trade,
-  note
-}) {
-  if (published === sized.decimals) return;
-  const because = note === void 0 ? "" : ` - ${note}`;
-  throw new ValidationError(
-    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
-  );
-}
 function sizeParam(params) {
   const tokenAmount = "tokenAmount" in params ? params.tokenAmount : void 0;
   const notionalValue = "notionalValue" in params ? params.notionalValue : void 0;
@@ -1660,7 +1919,7 @@ function sizeParam(params) {
   return { notional_value: notionalValue };
 }
 
-// src/universal/core/checkout/ondo/ondo-namespace.ts
+// src/universal/core/providers/checkout/ondo/ondo-namespace.ts
 var OndoNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1692,7 +1951,101 @@ var OndoNamespaceImpl = class {
   }
 };
 
-// src/universal/core/checkout/superstate/blockchain/abi.ts
+// src/universal/types/providers/superstate/swap.ts
+var SwapPreview = {
+  /** Maps the contract's `Preview { input, fee, output }` struct. */
+  fromContract: (preview) => ({
+    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
+    fee: parseUint256(preview.fee, "SwapPreview.fee"),
+    outputAmount: parseUint256(preview.output, "SwapPreview.output")
+  })
+};
+var PauseFlags = (value) => value;
+var SwapStatus = {
+  /**
+   * Maps the contract's `Status { uint32 flags; State state }` struct, where
+   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
+   *
+   * `flags` is carried onto the `paused` arm only. On the other two the
+   * contract sets it to a self-identifying marker rather than to information -
+   * so repeating it would invite a caller to read meaning into a constant.
+   *
+   * @throws ValidationError on a `state` outside the enum. A contract that has
+   * grown a fourth state is one the SDK does not model, and guessing `active`
+   * would let a halted swap read as a live one.
+   */
+  fromContract: (status) => {
+    switch (status.state) {
+      case 0:
+        return { state: "active" };
+      case 1:
+        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
+      case 2:
+        return { state: "stopped" };
+      default:
+        throw new ValidationError(
+          `SwapStatus.state: unknown contract state (${status.state})`
+        );
+    }
+  }
+};
+var AllowWalletResponse = {
+  fromDto: (dto) => {
+    switch (dto.action) {
+      case "broadcast_transaction":
+        return {
+          action: "broadcast_transaction",
+          tx: txFromWire(dto)
+        };
+      case "none":
+        return {
+          action: "none",
+          alreadyAllowed: dto.already_allowed
+        };
+      default: {
+        const _exhaustive = dto;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/universal/core/providers/checkout/superstate/blockchain/quote.ts
+var SwapQuote = {
+  /**
+   * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
+   * input and fee are denominated in the input token; the output in the output
+   * token.
+   */
+  fromPreview: (preview, inputDecimals, outputDecimals) => ({
+    inputTokenAmount: BlockchainAmount({
+      raw: preview.inputAmount,
+      decimals: inputDecimals
+    }),
+    fee: BlockchainAmount({ raw: preview.fee, decimals: inputDecimals }),
+    outputTokenAmount: BlockchainAmount({
+      raw: preview.outputAmount,
+      decimals: outputDecimals
+    })
+  })
+};
+
+// src/universal/api/frontline/providers/superstate/swap.ts
+async function allowWallet(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
+    body: {
+      wallet_address: params.walletAddress,
+      chain: params.chain,
+      signature: params.signature
+    },
+    attributes: Attributes.protected()
+  });
+  return AllowWalletResponse.fromDto(dto);
+}
+
+// src/universal/core/providers/checkout/superstate/blockchain/abi.ts
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
@@ -2545,100 +2898,125 @@ var SUPERSTATE_SWAP_ABI = [
     type: "error",
     name: "SwapFailed",
     inputs: [
-      {
-        name: "user",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      }
-    ]
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  }
+];
+
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
   },
   {
-    type: "error",
-    name: "Unauthorized",
-    inputs: []
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
   }
 ];
 
-// src/universal/types/providers/superstate/swap.ts
-var SwapPreview = {
-  /** Maps the contract's `Preview { input, fee, output }` struct. */
-  fromContract: (preview) => ({
-    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
-    fee: parseUint256(preview.fee, "SwapPreview.fee"),
-    outputAmount: parseUint256(preview.output, "SwapPreview.output")
-  })
-};
-var PauseFlags = (value) => value;
-var SwapStatus = {
-  /**
-   * Maps the contract's `Status { uint32 flags; State state }` struct, where
-   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
-   *
-   * `flags` is carried onto the `paused` arm only. On the other two the
-   * contract sets it to a self-identifying marker rather than to information -
-   * so repeating it would invite a caller to read meaning into a constant.
-   *
-   * @throws ValidationError on a `state` outside the enum. A contract that has
-   * grown a fourth state is one the SDK does not model, and guessing `active`
-   * would let a halted swap read as a live one.
-   */
-  fromContract: (status) => {
-    switch (status.state) {
-      case 0:
-        return { state: "active" };
-      case 1:
-        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
-      case 2:
-        return { state: "stopped" };
-      default:
-        throw new ValidationError(
-          `SwapStatus.state: unknown contract state (${status.state})`
-        );
-    }
-  }
-};
-var AllowWalletResponse = {
-  fromDto: (dto) => {
-    switch (dto.action) {
-      case "broadcast_transaction":
-        return {
-          action: "broadcast_transaction",
-          to: EvmContractAddress(dto.to),
-          data: HexEncodedTransactionData(dto.data)
-        };
-      case "none":
-        return {
-          action: "none",
-          alreadyAllowed: dto.already_allowed
-        };
-      default: {
-        const _exhaustive = dto;
-        return _exhaustive;
-      }
-    }
-  }
-};
-
-// src/universal/api/frontline/providers/superstate/swap.ts
-async function allowWallet(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
-    body: {
-      wallet_address: params.walletAddress,
-      chain: params.chain,
-      signature: params.signature
-    },
-    attributes: Attributes.protected()
-  });
-  return AllowWalletResponse.fromDto(dto);
-}
-
 // src/universal/api/rpc/providers/superstate/swap.ts
 async function getSwapAuthorization(clients, params) {
   return clients(params.chain).readContract({
@@ -2688,7 +3066,7 @@ async function getSwapOutputToken(clients, params) {
   };
 }
 
-// src/universal/core/checkout/superstate/swap-namespace.ts
+// src/universal/core/providers/checkout/superstate/swap-namespace.ts
 var SuperstateSwapNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -2708,6 +3086,20 @@ var SuperstateSwapNamespaceImpl = class {
       async () => getSwapPreview(this.ctx.rpc, params)
     );
   }
+  async getQuote(params) {
+    return this.log.wrap("getQuote", params, async () => {
+      const { amount, outputTokenDecimals, ...ref } = params;
+      const preview = await getSwapPreview(this.ctx.rpc, {
+        ...ref,
+        amount: amount.raw
+      });
+      return SwapQuote.fromPreview(
+        preview,
+        amount.decimals,
+        outputTokenDecimals
+      );
+    });
+  }
   async getStatus(params) {
     return this.log.wrap(
       "getStatus",
@@ -2866,40 +3258,181 @@ var RequirementsNamespaceImpl = class {
       await this.ctx.ensureUserAuthenticated();
       return fetchOfferRequirements(
         this.ctx.api,
-        offerId,
-        void 0
+        offerId,
+        void 0
+      );
+    });
+  }
+  async statuses(offerId) {
+    return this.log.wrap("statuses", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchRequirementStatuses(this.ctx.api, offerId);
+    });
+  }
+  async createKycToken(params) {
+    return this.log.wrap("createKycToken", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createKycToken(
+        this.ctx.api,
+        params?.levelName,
+        params?.reset
+      );
+    });
+  }
+  async getPii() {
+    return this.log.wrap("getPii", void 0, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchPii(this.ctx.api);
+    });
+  }
+  async submitDocument(params) {
+    return this.log.wrap("submitDocument", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return submitDocument(
+        this.ctx.api,
+        params.documentType,
+        params.fields
+      );
+    });
+  }
+};
+
+// src/universal/types/offer-option-address.ts
+var OfferOptionAddressId = (value) => value;
+var OfferOptionAddress = {
+  /** Maps the API DTO into the SDK offer-option-address domain model. */
+  fromDto: (dto) => ({
+    id: OfferOptionAddressId(dto.id),
+    offerOptionId: OfferOptionId(dto.offer_option_id),
+    address: EvmWalletAddress(dto.address),
+    protocol: dto.protocol,
+    createdAt: new Date(dto.created_at)
+  })
+};
+var ConnectExternalWalletParams = {
+  /** Maps connect-wallet params into the API DTO payload. */
+  toDto: (params) => ({
+    offer_option_id: params.offerOptionId,
+    wallet_address: params.walletAddress,
+    chain: params.chain,
+    signature: params.signature
+  })
+};
+
+// src/universal/types/wallet-ownership-challenge.ts
+var WalletOwnershipChallenge = {
+  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
+  fromDto: (dto) => ({
+    message: dto.message,
+    expiresAt: new Date(dto.expires_at)
+  })
+};
+var CreateWalletOwnershipChallengeParams = {
+  /**
+   * Maps challenge-request params into the API DTO payload. The discriminated
+   * union guarantees SIWE fields are present exactly when `challengeType` is
+   * `siwe`, so the mapping narrows on the discriminant.
+   */
+  toDto: (params) => {
+    switch (params.challengeType) {
+      case "plain":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "plain"
+        };
+      case "siwe":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "siwe",
+          domain: params.domain,
+          uri: params.uri,
+          statement: params.statement
+        };
+      default: {
+        const _exhaustive = params;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/universal/api/frontline/wallet-connect.ts
+async function createWalletOwnershipChallenge(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/wallet-ownership",
+    body: CreateWalletOwnershipChallengeParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return WalletOwnershipChallenge.fromDto(dto);
+}
+async function connectExternalWallet(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${params.offerId}/addresses`,
+    body: ConnectExternalWalletParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+async function listOptionAddresses(api, offerId, offerOptionId) {
+  const { data } = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/addresses`,
+    queryParams: { offer_option_id: offerOptionId },
+    attributes: Attributes.protected()
+  });
+  return data.map(OfferOptionAddress.fromDto);
+}
+async function removeOptionAddress(api, offerId, addressId) {
+  const dto = await api.send({
+    method: "DELETE",
+    url: `/v1/offers/${offerId}/addresses/${addressId}`,
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+
+// src/universal/core/wallets/wallets-namespace.ts
+var WalletsNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "WALLETS");
+  }
+  async createOwnershipChallenge(params) {
+    return this.log.wrap("createOwnershipChallenge", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createWalletOwnershipChallenge(
+        this.ctx.api,
+        params
       );
     });
   }
-  async statuses(offerId) {
-    return this.log.wrap("statuses", offerId, async () => {
+  async connectExternal(params) {
+    return this.log.wrap("connectExternal", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchRequirementStatuses(this.ctx.api, offerId);
+      return connectExternalWallet(this.ctx.api, params);
     });
   }
-  async createKycToken(params) {
-    return this.log.wrap("createKycToken", params, async () => {
+  async list(params) {
+    return this.log.wrap("list", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return createKycToken(
+      return listOptionAddresses(
         this.ctx.api,
-        params?.levelName,
-        params?.reset
+        params.offerId,
+        params.offerOptionId
       );
     });
   }
-  async getPii() {
-    return this.log.wrap("getPii", void 0, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return fetchPii(this.ctx.api);
-    });
-  }
-  async submitDocument(params) {
-    return this.log.wrap("submitDocument", params, async () => {
+  async remove(params) {
+    return this.log.wrap("remove", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return submitDocument(
+      return removeOptionAddress(
         this.ctx.api,
-        params.documentType,
-        params.fields
+        params.offerId,
+        params.addressId
       );
     });
   }
@@ -3327,163 +3860,6 @@ var TokensNamespaceImpl = class {
   }
 };
 
-// src/universal/types/offer-option-address.ts
-var OfferOptionAddressId = (value) => value;
-var OfferOptionAddress = {
-  /** Maps the API DTO into the SDK offer-option-address domain model. */
-  fromDto: (dto) => ({
-    id: OfferOptionAddressId(dto.id),
-    offerOptionId: OfferOptionId(dto.offer_option_id),
-    address: EvmWalletAddress(dto.address),
-    protocol: dto.protocol,
-    createdAt: new Date(dto.created_at)
-  })
-};
-var ConnectExternalWalletParams = {
-  /** Maps connect-wallet params into the API DTO payload. */
-  toDto: (params) => ({
-    offer_option_id: params.offerOptionId,
-    wallet_address: params.walletAddress,
-    chain: params.chain,
-    signature: params.signature
-  })
-};
-
-// src/universal/types/wallet-ownership-challenge.ts
-var WalletOwnershipChallenge = {
-  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
-  fromDto: (dto) => ({
-    message: dto.message,
-    expiresAt: new Date(dto.expires_at)
-  })
-};
-var CreateWalletOwnershipChallengeParams = {
-  /**
-   * Maps challenge-request params into the API DTO payload. The discriminated
-   * union guarantees SIWE fields are present exactly when `challengeType` is
-   * `siwe`, so the mapping narrows on the discriminant.
-   */
-  toDto: (params) => {
-    switch (params.challengeType) {
-      case "plain":
-        return {
-          wallet_address: params.walletAddress,
-          chain: params.chain,
-          challenge_type: "plain"
-        };
-      case "siwe":
-        return {
-          wallet_address: params.walletAddress,
-          chain: params.chain,
-          challenge_type: "siwe",
-          domain: params.domain,
-          uri: params.uri,
-          statement: params.statement
-        };
-      default: {
-        const _exhaustive = params;
-        return _exhaustive;
-      }
-    }
-  }
-};
-
-// src/universal/api/frontline/wallet-connect.ts
-async function createWalletOwnershipChallenge(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/wallet-ownership",
-    body: CreateWalletOwnershipChallengeParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return WalletOwnershipChallenge.fromDto(dto);
-}
-async function connectExternalWallet(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: `/v1/offers/${params.offerId}/addresses`,
-    body: ConnectExternalWalletParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return OfferOptionAddress.fromDto(dto);
-}
-async function listOptionAddresses(api, offerId, offerOptionId) {
-  const { data } = await api.send({
-    method: "GET",
-    url: `/v1/offers/${offerId}/addresses`,
-    queryParams: { offer_option_id: offerOptionId },
-    attributes: Attributes.protected()
-  });
-  return data.map(OfferOptionAddress.fromDto);
-}
-async function removeOptionAddress(api, offerId, addressId) {
-  const dto = await api.send({
-    method: "DELETE",
-    url: `/v1/offers/${offerId}/addresses/${addressId}`,
-    attributes: Attributes.protected()
-  });
-  return OfferOptionAddress.fromDto(dto);
-}
-
-// src/universal/core/wallets/wallets-namespace.ts
-var WalletsNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "WALLETS");
-  }
-  async createOwnershipChallenge(params) {
-    return this.log.wrap("createOwnershipChallenge", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return createWalletOwnershipChallenge(
-        this.ctx.api,
-        params
-      );
-    });
-  }
-  async connectExternal(params) {
-    return this.log.wrap("connectExternal", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return connectExternalWallet(this.ctx.api, params);
-    });
-  }
-  async list(params) {
-    return this.log.wrap("list", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return listOptionAddresses(
-        this.ctx.api,
-        params.offerId,
-        params.offerOptionId
-      );
-    });
-  }
-  async remove(params) {
-    return this.log.wrap("remove", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return removeOptionAddress(
-        this.ctx.api,
-        params.offerId,
-        params.addressId
-      );
-    });
-  }
-};
-
-// src/universal/types/oauth-session.ts
-var ClientCredentialsOAuth = (value) => value;
-var OAuthRefreshToken = (value) => value;
-var OAuthSession = {
-  fromDto: (dto) => {
-    const expiresAt = new Date(Date.now() + dto.expires_in * 1e3);
-    return {
-      accessToken: {
-        value: dto.access_token,
-        expiresAt
-      },
-      ...dto.refresh_token != null && dto.refresh_token !== "" ? { refreshToken: OAuthRefreshToken(dto.refresh_token) } : void 0
-    };
-  }
-};
-
 // src/universal/api/frontline/offers.ts
 async function fetchOffers(api, clientCreds) {
   return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
@@ -3540,6 +3916,7 @@ export {
   ValidationError,
   InvariantError,
   MathError,
+  classifyLogCause,
   describeErrorUnredacted,
   internalLogger,
   HttpClient,
@@ -3548,13 +3925,18 @@ export {
   Seconds,
   isExpired,
   ERC20_ABI,
-  fetchAllPages,
-  Cursor,
-  PaginatedResponse,
-  PaginationParams,
-  AssetId,
-  AssetCode,
-  Asset,
+  FormattedAmountUi,
+  FormattedPercentUi,
+  TxExplorerUrl,
+  ShortenedWalletAddress,
+  FormattedAmountAssetUi,
+  AssetIconUrl,
+  viemChain,
+  getChainId,
+  chainFromId,
+  contractOn,
+  getNetworkName,
+  txExplorerUrl,
   ETHEREUM_CHAINS,
   EthereumChain,
   SOLANA_CHAINS,
@@ -3576,9 +3958,37 @@ export {
   StablecoinSymbol,
   KnownAssetSymbol,
   Bps,
-  requiredDate,
-  dateOrNull,
-  decimalOrNull,
+  blockchainAmountFromRawOrThrow,
+  positiveAmountFromRawOrThrow,
+  pricePerShare,
+  parseBlockchainAmount,
+  CentrifugeVaultStatus,
+  CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimTransaction,
+  CentrifugeAssets,
+  CentrifugeShares,
+  CentrifugeDepositPosition,
+  CentrifugeRedeemPosition,
+  CentrifugeVaultLeg,
+  CentrifugeVaultLegId,
+  CentrifugeVaultClaimProceedsTransaction,
+  CentrifugeNamespaceImpl,
+  shortenAddress,
+  formatAmount,
+  formatRawAmount,
+  formatCompactAmount,
+  formatBpsAsPercent,
+  usdAmount,
+  assetAmount,
+  NA_AMOUNT_ASSET_UI,
+  formatShareAmount,
+  formattedUsdPrice,
+  Cursor,
+  PaginatedResponse,
+  PaginationParams,
+  AssetId,
+  AssetCode,
+  Asset,
   OfferId,
   OfferSlug,
   isOfferType,
@@ -3587,6 +3997,7 @@ export {
   OfferToken,
   Ticker,
   Isin,
+  AsyncOfferDetail,
   OfferOptionId,
   OfferOptionSlug,
   OfferSwapContract,
@@ -3598,35 +4009,10 @@ export {
   TermItem,
   Milestone,
   ParticipationId,
-  Blockchain,
-  WalletAddress,
   ParticipationsPaginationParams,
   Participation,
   CreateParticipationParams,
   CoinListTokenSaleNamespaceImpl,
-  FormattedAmountUi,
-  FormattedPercentUi,
-  TxExplorerUrl,
-  ShortenedWalletAddress,
-  FormattedAmountAssetUi,
-  AssetIconUrl,
-  shortenAddress,
-  formatAmount,
-  formatRawAmount,
-  formatCompactAmount,
-  formatBpsAsPercent,
-  usdAmount,
-  assetAmount,
-  NA_AMOUNT_ASSET_UI,
-  formatShareAmount,
-  formattedUsdPrice,
-  viemChain,
-  getChainId,
-  chainFromId,
-  getNetworkName,
-  txExplorerUrl,
-  blockchainAmountFromRawOrThrow,
-  parseBlockchainAmount,
   OndoTradingStatus,
   OndoQuote,
   OndoBuyTransaction,
@@ -3637,10 +4023,8 @@ export {
   PauseFlags,
   SwapStatus,
   AllowWalletResponse,
+  SwapQuote,
   SuperstateSwapNamespaceImpl,
-  fetchOffers,
-  fetchOffersPage,
-  fetchOfferDetails,
   DocumentSubmission,
   KycToken,
   Iso2CountryCode,
@@ -3652,19 +4036,19 @@ export {
   RequirementStatusInfo,
   fetchOfferRequirements,
   RequirementsNamespaceImpl,
-  Erc20NamespaceImpl,
-  TokenLogoUrl,
-  TokenLogo,
-  TokenMetadata,
-  TokensNamespaceImpl,
   OfferOptionAddressId,
   OfferOptionAddress,
   ConnectExternalWalletParams,
   WalletOwnershipChallenge,
   CreateWalletOwnershipChallengeParams,
   WalletsNamespaceImpl,
-  ClientCredentialsOAuth,
-  OAuthRefreshToken,
-  OAuthSession
+  fetchOffers,
+  fetchOffersPage,
+  fetchOfferDetails,
+  Erc20NamespaceImpl,
+  TokenLogoUrl,
+  TokenLogo,
+  TokenMetadata,
+  TokensNamespaceImpl
 };
-//# sourceMappingURL=chunk-NBO5E2RO.js.map
+//# sourceMappingURL=chunk-HMLWCXAP.js.map