@coinlist-co/react 0.12.2-rc.0fda52c → 0.12.2-rc.4851c6a

package/dist/{chunk-BNMF2HMW.js → chunk-GOUUYOPZ.js}

@@ -291,166 +291,6 @@ 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/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/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -513,8 +353,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,6 +398,66 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
+// 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}")`);
+  }
+  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 = 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;
@@ -623,6 +533,12 @@ function requiredDate(value, field) {
   }
   return date;
 }
+function dateOrNull(value, field) {
+  return value === null ? null : requiredDate(value, field);
+}
+function decimalOrNull(value) {
+  return value === null ? null : DecimalString(value);
+}
 function requiredArray(value, field) {
   if (!Array.isArray(value)) {
     throw new ValidationError(
@@ -632,290 +548,240 @@ function requiredArray(value, field) {
   return 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
-};
-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)
+    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`
+      );
+    }
+    return {
+      ...parseTransactionCore(dto, "CentrifugeVaultBuyTransaction"),
+      spendInputAmount
     };
-    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");
-    }
-  },
-  /**
-   * 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 OfferDetail = {
+var CentrifugeVaultPosition = {
   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)
+    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")
     };
-    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)
-        };
-      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 = {
+var CentrifugeVaultRedeemPosition = {
   fromDto: (dto) => ({
-    question: notBlankStringOrNull(dto.question),
-    answer: notBlankStringOrNull(dto.answer)
+    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 Link = {
-  fromDto: (dto) => ({
-    label: notBlankStringOrNull(dto.label),
-    url: notBlankStringOrNull(dto.url)
-  })
+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 TermItem = {
-  fromDto: (dto) => ({
-    key: notBlankStringOrNull(dto.key),
-    value: notBlankStringOrNull(dto.value)
-  })
+var CentrifugeVaultLegId = {
+  /** Addresses compare case-insensitively: frontline echoes them lower case. */
+  of: (leg) => [
+    leg.direction,
+    leg.position.chain,
+    leg.position.walletAddress.toLowerCase()
+  ].join(":")
 };
-var Milestone = {
+var CentrifugeVaultClaimProceedsTransaction = {
   fromDto: (dto) => ({
-    name: notBlankStringOrNull(dto.name),
-    schedule: notBlankStringOrNull(dto.schedule),
-    status: dto.status
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    })
   })
 };
-
-// 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;
+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 queryParams;
+    return { type: "orderable" };
   }
-};
-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
-    };
+  if (first === void 0) {
+    throw new ValidationError(
+      `${model}.reasons: expected at least one when can_order is false`
+    );
   }
-};
-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 }
-  );
+  return { type: "blocked", reasons: [first, ...rest] };
 }
-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);
+function parseTransactionCore(dto, model) {
+  return {
+    tx: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
 }
-async function fetchParticipation(api, id) {
+
+// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
+async function getCentrifugeVaultStatus(api, params) {
   const dto = await api.send({
     method: "GET",
-    url: `/v1/participations/${id}`,
+    url: "/v1/centrifuge/vault/status",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain
+    },
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  return CentrifugeVaultStatus.fromDto(dto);
 }
-async function createParticipation(api, params) {
+async function buildCentrifugeVaultBuy(api, params) {
   const dto = await api.send({
     method: "POST",
-    url: "/v1/participations",
-    body: CreateParticipationParams.toDto(params),
+    url: "/v1/centrifuge/vault/invest",
+    body: {
+      ...walletFields(params),
+      amount: params.amount.raw.toString()
+    },
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  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
@@ -1101,34 +967,46 @@ var noopInternalLogger = {
   wrap: (_op, _params, run) => run()
 };
 
-// src/universal/core/checkout/coin-list/token-sale-namespace.ts
-var CoinListTokenSaleNamespaceImpl = class {
+// src/universal/core/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 getPosition(params) {
+    return this.log.wrap("getPosition", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchParticipationsPage(this.ctx.api, params);
+      return getCentrifugeVaultPosition(this.ctx.api, params);
     });
   }
-  async get(id) {
-    return this.log.wrap("get", id, async () => {
+  async getRedeemPosition(params) {
+    return this.log.wrap("getRedeemPosition", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchParticipation(this.ctx.api, id);
+      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
     });
   }
-  async createParticipation(params) {
-    return this.log.wrap("createParticipation", params, async () => {
+  async createClaim(params) {
+    return this.log.wrap("createClaim", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return createParticipation(this.ctx.api, params);
+      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);
     });
   }
 };
@@ -1249,6 +1127,435 @@ function formattedUsdPrice(amount, locale) {
   );
 }
 
+// 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;
+      }
+    }
+  }
+};
+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/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/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
+  })
+};
+
+// 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/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/checkout/coin-list/token-sale-namespace.ts
+var CoinListTokenSaleNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "TOKEN_SALE");
+  }
+  async list(offerId) {
+    return this.log.wrap("list", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipations(this.ctx.api, offerId);
+    });
+  }
+  async listPage(params) {
+    return this.log.wrap("listPage", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipationsPage(this.ctx.api, params);
+    });
+  }
+  async get(id) {
+    return this.log.wrap("get", id, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipation(this.ctx.api, id);
+    });
+  }
+  async createParticipation(params) {
+    return this.log.wrap("createParticipation", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createParticipation(this.ctx.api, params);
+    });
+  }
+};
+
 // src/universal/core/shared/blockchain/chain.ts
 import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
 var VIEM_CHAINS = {
@@ -1307,66 +1614,6 @@ function explorerBaseUrl(chain) {
   }
 }
 
-// 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}")`);
-  }
-  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 = 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) => {
@@ -1382,7 +1629,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -1660,6 +1906,101 @@ var OndoNamespaceImpl = class {
   }
 };
 
+// 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/core/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/checkout/superstate/blockchain/abi.ts
 var SUPERSTATE_SWAP_ABI = [
   {
@@ -2513,100 +2854,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({
@@ -2676,6 +3042,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",
@@ -2827,47 +3207,188 @@ async function fetchRequirementStatuses(api, offerId) {
 var RequirementsNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "REQUIREMENTS");
+    this.log = internalLogger(ctx.logger, "REQUIREMENTS");
+  }
+  async forOffer(offerId) {
+    return this.log.wrap("forOffer", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOfferRequirements(
+        this.ctx.api,
+        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 forOffer(offerId) {
-    return this.log.wrap("forOffer", offerId, async () => {
+  async createOwnershipChallenge(params) {
+    return this.log.wrap("createOwnershipChallenge", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return fetchOfferRequirements(
+      return createWalletOwnershipChallenge(
         this.ctx.api,
-        offerId,
-        void 0
+        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
       );
     });
   }
@@ -3295,163 +3816,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));
@@ -3516,13 +3880,6 @@ export {
   Seconds,
   isExpired,
   ERC20_ABI,
-  fetchAllPages,
-  Cursor,
-  PaginatedResponse,
-  PaginationParams,
-  AssetId,
-  AssetCode,
-  Asset,
   ETHEREUM_CHAINS,
   EthereumChain,
   SOLANA_CHAINS,
@@ -3544,6 +3901,36 @@ export {
   StablecoinSymbol,
   KnownAssetSymbol,
   Bps,
+  blockchainAmountFromRawOrThrow,
+  parseBlockchainAmount,
+  CentrifugeVaultStatus,
+  CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimTransaction,
+  CentrifugeVaultPosition,
+  CentrifugeVaultRedeemPosition,
+  CentrifugeVaultLeg,
+  CentrifugeVaultLegId,
+  CentrifugeVaultClaimProceedsTransaction,
+  CentrifugeNamespaceImpl,
+  FormattedAmountUi,
+  FormattedPercentUi,
+  TxExplorerUrl,
+  ShortenedWalletAddress,
+  FormattedAmountAssetUi,
+  AssetIconUrl,
+  shortenAddress,
+  formatAmount,
+  formatRawAmount,
+  formatCompactAmount,
+  formatBpsAsPercent,
+  usdAmount,
+  assetAmount,
+  NA_AMOUNT_ASSET_UI,
+  formatShareAmount,
+  formattedUsdPrice,
+  AssetId,
+  AssetCode,
+  Asset,
   OfferId,
   OfferSlug,
   isOfferType,
@@ -3552,15 +3939,20 @@ export {
   OfferToken,
   Ticker,
   Isin,
+  AsyncOfferDetail,
   OfferOptionId,
   OfferOptionSlug,
   OfferSwapContract,
+  OfferVaultContract,
   OfferDetail,
   OfferOption,
   FaqItem,
   Link,
   TermItem,
   Milestone,
+  Cursor,
+  PaginatedResponse,
+  PaginationParams,
   ParticipationId,
   Blockchain,
   WalletAddress,
@@ -3568,29 +3960,11 @@ export {
   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,
@@ -3601,10 +3975,8 @@ export {
   PauseFlags,
   SwapStatus,
   AllowWalletResponse,
+  SwapQuote,
   SuperstateSwapNamespaceImpl,
-  fetchOffers,
-  fetchOffersPage,
-  fetchOfferDetails,
   DocumentSubmission,
   KycToken,
   Iso2CountryCode,
@@ -3616,19 +3988,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-BNMF2HMW.js.map
+//# sourceMappingURL=chunk-GOUUYOPZ.js.map