@coinlist-co/react 0.12.2-rc.bc20f5b → 0.12.2-rc.e1f6c82

package/dist/universal/index.cjs

@@ -1,4562 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/universal/index.ts
-var universal_exports = {};
-__export(universal_exports, {
-  AllowWalletResponse: () => AllowWalletResponse,
-  Asset: () => Asset,
-  AssetCode: () => AssetCode,
-  AssetDecimals: () => AssetDecimals,
-  AssetIconUrl: () => AssetIconUrl,
-  AssetId: () => AssetId,
-  AssetSymbol: () => AssetSymbol,
-  AsyncOfferDetail: () => AsyncOfferDetail,
-  AuthorizationCode: () => AuthorizationCode,
-  BPS_DENOM: () => BPS_DENOM,
-  Blockchain: () => Blockchain,
-  BlockchainAmount: () => BlockchainAmount,
-  Bps: () => Bps,
-  CENTRIFUGE_POLL_INTERVAL_MS: () => CENTRIFUGE_POLL_INTERVAL_MS,
-  CentrifugeNamespaceImpl: () => CentrifugeNamespaceImpl,
-  CentrifugeVaultBuyTransaction: () => CentrifugeVaultBuyTransaction,
-  CentrifugeVaultClaimProceedsTransaction: () => CentrifugeVaultClaimProceedsTransaction,
-  CentrifugeVaultClaimTransaction: () => CentrifugeVaultClaimTransaction,
-  CentrifugeVaultLeg: () => CentrifugeVaultLeg,
-  CentrifugeVaultLegId: () => CentrifugeVaultLegId,
-  CentrifugeVaultPosition: () => CentrifugeVaultPosition,
-  CentrifugeVaultRedeemPosition: () => CentrifugeVaultRedeemPosition,
-  CentrifugeVaultStatus: () => CentrifugeVaultStatus,
-  Chain: () => Chain,
-  ClientCredentialsOAuth: () => ClientCredentialsOAuth,
-  ClientId: () => ClientId,
-  ClientSecret: () => ClientSecret,
-  CodeChallenge: () => CodeChallenge,
-  CodeVerifier: () => CodeVerifier,
-  CoinListTokenSaleNamespaceImpl: () => CoinListTokenSaleNamespaceImpl,
-  ConnectExternalWalletParams: () => ConnectExternalWalletParams,
-  CreateParticipationParams: () => CreateParticipationParams,
-  CreateWalletOwnershipChallengeParams: () => CreateWalletOwnershipChallengeParams,
-  Cursor: () => Cursor,
-  DEFAULT_AMOUNT_TO_COMPUTE_PRICE: () => DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
-  DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE: () => DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
-  DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE: () => DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE,
-  DEFAULT_SLIPPAGE_BPS: () => DEFAULT_SLIPPAGE_BPS,
-  DecimalString: () => DecimalString,
-  DocumentSubmission: () => DocumentSubmission,
-  ERC20_ABI: () => ERC20_ABI,
-  ETHEREUM_CHAINS: () => ETHEREUM_CHAINS,
-  EpochMillis: () => EpochMillis,
-  Erc20NamespaceImpl: () => Erc20NamespaceImpl,
-  EthereumChain: () => EthereumChain,
-  EvmContractAddress: () => EvmContractAddress,
-  EvmWalletAddress: () => EvmWalletAddress,
-  FaqItem: () => FaqItem,
-  FormattedAmountAssetUi: () => FormattedAmountAssetUi,
-  FormattedAmountUi: () => FormattedAmountUi,
-  FormattedPercentUi: () => FormattedPercentUi,
-  HexEncodedTransactionData: () => HexEncodedTransactionData,
-  HttpError: () => HttpError,
-  InvariantError: () => InvariantError,
-  Isin: () => Isin,
-  Iso2CountryCode: () => Iso2CountryCode,
-  KnownAssetSymbol: () => KnownAssetSymbol,
-  KycToken: () => KycToken,
-  Link: () => Link,
-  MAX_ASSET_DECIMALS: () => MAX_ASSET_DECIMALS,
-  MAX_UINT_256: () => MAX_UINT_256,
-  MathError: () => MathError,
-  Milestone: () => Milestone,
-  Millis: () => Millis,
-  NA_AMOUNT_ASSET_UI: () => NA_AMOUNT_ASSET_UI,
-  NotAuthenticatedError: () => NotAuthenticatedError,
-  NotImplementedError: () => NotImplementedError,
-  OAuthRefreshToken: () => OAuthRefreshToken,
-  OAuthSession: () => OAuthSession,
-  ONDO_NOT_TRADABLE_CODE: () => ONDO_NOT_TRADABLE_CODE,
-  ONDO_POLL_INTERVAL_MS: () => ONDO_POLL_INTERVAL_MS,
-  ONDO_QUOTE_MAX_TTL_MS: () => ONDO_QUOTE_MAX_TTL_MS,
-  ONDO_SETTLEMENT_ASSET: () => ONDO_SETTLEMENT_ASSET,
-  ONDO_SUPPORTED_INPUT_ASSETS: () => ONDO_SUPPORTED_INPUT_ASSETS,
-  Offer: () => Offer,
-  OfferDetail: () => OfferDetail,
-  OfferEditorial: () => OfferEditorial,
-  OfferId: () => OfferId,
-  OfferOption: () => OfferOption,
-  OfferOptionAddress: () => OfferOptionAddress,
-  OfferOptionAddressId: () => OfferOptionAddressId,
-  OfferOptionId: () => OfferOptionId,
-  OfferOptionSlug: () => OfferOptionSlug,
-  OfferSlug: () => OfferSlug,
-  OfferSwapContract: () => OfferSwapContract,
-  OfferToken: () => OfferToken,
-  OfferVaultContract: () => OfferVaultContract,
-  OffersNamespaceImpl: () => OffersNamespaceImpl,
-  OndoBuyTransaction: () => OndoBuyTransaction,
-  OndoNamespaceImpl: () => OndoNamespaceImpl,
-  OndoQuote: () => OndoQuote,
-  OndoSellTransaction: () => OndoSellTransaction,
-  OndoTradingStatus: () => OndoTradingStatus,
-  PKCEState: () => PKCEState,
-  PaginatedResponse: () => PaginatedResponse,
-  PaginationParams: () => PaginationParams,
-  Participation: () => Participation,
-  ParticipationId: () => ParticipationId,
-  ParticipationsPaginationParams: () => ParticipationsPaginationParams,
-  PauseFlags: () => PauseFlags,
-  Pii: () => Pii,
-  PiiAddress: () => PiiAddress,
-  PiiJurisdiction: () => PiiJurisdiction,
-  RedactedWalletError: () => RedactedWalletError,
-  RedirectUri: () => RedirectUri,
-  Requirement: () => Requirement,
-  RequirementId: () => RequirementId,
-  RequirementStatusInfo: () => RequirementStatusInfo,
-  RequirementsNamespaceImpl: () => RequirementsNamespaceImpl,
-  SLIPPAGE_OPTIONS_BPS: () => SLIPPAGE_OPTIONS_BPS,
-  SOLANA_CHAINS: () => SOLANA_CHAINS,
-  STABLE_DECIMALS: () => STABLE_DECIMALS,
-  SUPERSTATE_ISSUER_NAME: () => SUPERSTATE_ISSUER_NAME,
-  SUPERSTATE_SUPPORTED_INPUT_ASSETS: () => SUPERSTATE_SUPPORTED_INPUT_ASSETS,
-  SUPERSTATE_SWAP_ABI: () => SUPERSTATE_SWAP_ABI,
-  SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA: () => SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
-  SWAP_LEVEL: () => SWAP_LEVEL,
-  SWAP_POLL_INTERVAL_MS: () => SWAP_POLL_INTERVAL_MS,
-  Seconds: () => Seconds,
-  ShortenedWalletAddress: () => ShortenedWalletAddress,
-  SolanaChain: () => SolanaChain,
-  StablecoinSymbol: () => StablecoinSymbol,
-  SuperstateSwapNamespaceImpl: () => SuperstateSwapNamespaceImpl,
-  SwapPreview: () => SwapPreview,
-  SwapQuote: () => SwapQuote,
-  SwapStatus: () => SwapStatus,
-  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
-  TermItem: () => TermItem,
-  Ticker: () => Ticker,
-  TokenLogo: () => TokenLogo,
-  TokenLogoUrl: () => TokenLogoUrl,
-  TokenMetadata: () => TokenMetadata,
-  TokenRegistrySnapshot: () => TokenRegistrySnapshot,
-  TokensNamespaceImpl: () => TokensNamespaceImpl,
-  TxExplorerUrl: () => TxExplorerUrl,
-  USDC: () => USDC,
-  USDC_SYMBOL: () => USDC_SYMBOL,
-  USDT: () => USDT,
-  USDT_SYMBOL: () => USDT_SYMBOL,
-  User: () => User,
-  UserEmail: () => UserEmail,
-  UserId: () => UserId,
-  ValidationError: () => ValidationError,
-  WalletAddress: () => WalletAddress,
-  WalletOwnershipChallenge: () => WalletOwnershipChallenge,
-  WalletSelection: () => WalletSelection,
-  WalletsNamespaceImpl: () => WalletsNamespaceImpl,
-  apiErrorCode: () => apiErrorCode,
-  applyBps: () => applyBps,
-  assertUint256: () => assertUint256,
-  assetAmount: () => assetAmount,
-  blockchainAmountFromRawOrThrow: () => blockchainAmountFromRawOrThrow,
-  chainFromId: () => chainFromId,
-  computeOndoBuyPrice: () => computeOndoBuyPrice,
-  computeOndoSellPrice: () => computeOndoSellPrice,
-  computePrice: () => computePrice,
-  computeSlip: () => computeSlip,
-  decodeSwappedOutputAmount: () => decodeSwappedOutputAmount,
-  fetchAllPages: () => fetchAllPages,
-  formatAmount: () => formatAmount,
-  formatBpsAsPercent: () => formatBpsAsPercent,
-  formatCompactAmount: () => formatCompactAmount,
-  formatRawAmount: () => formatRawAmount,
-  formatShareAmount: () => formatShareAmount,
-  formattedPricePerShare: () => formattedPricePerShare,
-  formattedUsdPrice: () => formattedUsdPrice,
-  generatePKCEParams: () => generatePKCEParams,
-  getChainId: () => getChainId,
-  getNetworkName: () => getNetworkName,
-  isChain: () => isChain,
-  isExpired: () => isExpired,
-  isOfferType: () => isOfferType,
-  isOndoNotTradableError: () => isOndoNotTradableError,
-  isSwapAvailable: () => isSwapAvailable,
-  offerDisplayTokens: () => offerDisplayTokens,
-  ondoQuoteOfferDeadline: () => ondoQuoteOfferDeadline,
-  parseBlockchainAmount: () => parseBlockchainAmount,
-  parseUint256: () => parseUint256,
-  resolveCentrifugeVaults: () => resolveCentrifugeVaults,
-  shortenAddress: () => shortenAddress,
-  superstateSwapContractAddress: () => superstateSwapContractAddress,
-  swapSpender: () => swapSpender,
-  txExplorerUrl: () => txExplorerUrl,
-  usdAmount: () => usdAmount,
-  viemChain: () => viemChain
-});
-module.exports = __toCommonJS(universal_exports);
-
-// src/universal/api/internal-access-token-source.ts
-var SentWith = {
-  userToken: (token) => ({
-    type: "user-token",
-    token
-  }),
-  noUserToken: { type: "no-user-token" }
-};
-
-// src/universal/api/http-attributes.ts
-var empty = {};
-var concat = (left, right) => ({
-  ...left,
-  ...right
-});
-var concatAll = (...items) => {
-  let result = empty;
-  for (const item of items) {
-    result = concat(result, item);
-  }
-  return result;
-};
-var protectedRequest = () => ({ protected: true });
-var userAgent = () => ({ userAgent: true });
-var idempotencyKey = () => ({
-  idempotencyKey: true
-});
-var clientCredentials = (credentials) => ({
-  clientCredentials: credentials
-});
-var retryAttempt = (attempt) => ({
-  retryAttempt: attempt
-});
-var renewAttempted = (value) => ({
-  renewAttempted: value
-});
-var notRetryable = () => ({ retryable: false });
-var sentWith = (token) => ({
-  sentWith: token
-});
-var requestId = (id) => ({ requestId: id });
-var getRequestId = (attrs) => attrs?.requestId ?? null;
-var isProtected = (attrs) => attrs?.protected === true;
-var needUserAgent = (attrs) => attrs?.userAgent === true;
-var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
-var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
-var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
-var isRetryable = (attrs) => attrs?.retryable !== false;
-var getSentWith = (attrs) => attrs?.sentWith === void 0 ? SentWith.noUserToken : SentWith.userToken(attrs.sentWith);
-var getClientCredentials = (attrs) => attrs?.clientCredentials;
-var Attributes = {
-  empty,
-  concat,
-  concatAll,
-  protected: protectedRequest,
-  isProtected,
-  userAgent,
-  needUserAgent,
-  idempotencyKey,
-  isIdempotent,
-  retryAttempt,
-  getRetryAttempt,
-  renewAttempted,
-  wasRenewAttempted,
-  notRetryable,
-  isRetryable,
-  sentWith,
-  getSentWith,
-  clientCredentials,
-  getClientCredentials,
-  requestId,
-  getRequestId
-};
-
-// src/universal/api/http.ts
-var HttpError = class extends Error {
-  constructor(response) {
-    super(`Request failed with ${response.status} status`);
-    this.name = "HttpError";
-    this.response = response;
-  }
-  /**
-   * Correlates this failure with the `[HTTP]` log lines for the same request,
-   * which carry the method, the URL, the duration and every retry. `null` when
-   * the response did not come from an {@link HttpClient}.
-   *
-   * Worth quoting in a bug report: it is what makes a log excerpt readable.
-   */
-  get requestId() {
-    return this.response.requestId ?? null;
-  }
-};
-function apiErrorCode(error) {
-  if (!(error instanceof HttpError)) return null;
-  const body = error.response.body;
-  if (typeof body !== "object" || body === null) return null;
-  const code = body.code;
-  return typeof code === "string" ? code : null;
-}
-async function makeRequest(request) {
-  const headers = {
-    Accept: "application/json",
-    ...request.method === "POST" && request.body !== void 0 ? { "Content-Type": "application/json" } : {},
-    ...request.headers ?? {}
-  };
-  const init = {
-    method: request.method,
-    headers,
-    ...request.redirect !== void 0 ? { redirect: request.redirect } : {}
-  };
-  if (request.method === "POST" && request.body !== void 0) {
-    init.body = JSON.stringify(request.body);
-  }
-  const response = await fetch(
-    buildUrlWithQueryParams(request.url, request.queryParams),
-    init
-  );
-  const responseHeaders = headersToRecord(response.headers);
-  if (response.status === 204 || response.status === 205) {
-    return {
-      status: response.status,
-      body: null,
-      headers: responseHeaders
-    };
-  }
-  if (response.status >= 300 && response.status < 400) {
-    await response.text();
-    return {
-      status: response.status,
-      body: null,
-      headers: responseHeaders
-    };
-  }
-  const text = await response.text();
-  let body;
-  try {
-    body = text ? JSON.parse(text) : null;
-  } catch (_) {
-    throw new HttpError({
-      status: response.status,
-      headers: responseHeaders,
-      body: text
-    });
-  }
-  return {
-    status: response.status,
-    body,
-    headers: responseHeaders
-  };
-}
-function buildUrlWithQueryParams(url, queryParams) {
-  if (!queryParams) {
-    return url;
-  }
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(queryParams)) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item === void 0 || item === null) {
-          continue;
-        }
-        searchParams.append(key, String(item));
-      }
-      continue;
-    }
-    searchParams.append(key, String(value));
-  }
-  const queryString = searchParams.toString();
-  if (!queryString) {
-    return url;
-  }
-  return url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
-}
-function headersToRecord(headers) {
-  const record = {};
-  headers.forEach((value, key) => {
-    record[key.toLowerCase()] = value;
-  });
-  return record;
-}
-
-// 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/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);
-}
-function notBlankStringOrNull(value) {
-  if (value?.trim()) {
-    return value;
-  } else {
-    return null;
-  }
-}
-
-// src/universal/types/oauth.ts
-var AuthorizationCode = (value) => value;
-var CodeVerifier = (value) => value;
-var CodeChallenge = (value) => value;
-var PKCEState = (value) => value;
-var RedirectUri = (value) => value;
-var ClientId = (value) => value;
-var ClientSecret = (value) => value;
-
-// src/universal/core/auth/pkce.ts
-async function generatePKCEParams(config) {
-  const state = generateSecureRandomBase64Url(32);
-  const codeVerifier = generateSecureRandomBase64Url(32);
-  const codeChallengeRaw = await sha256(codeVerifier);
-  const codeChallenge = arrayBufferToBase64Url(codeChallengeRaw, false);
-  return {
-    clientId: config.clientId,
-    responseType: "code",
-    redirectUri: config.redirectUri,
-    codeChallenge: CodeChallenge(codeChallenge),
-    codeChallengeMethod: "S256",
-    state: PKCEState(state),
-    codeVerifier: CodeVerifier(codeVerifier)
-  };
-}
-
-// src/universal/types/errors.ts
-var NotImplementedError = class extends Error {
-  constructor(message = "Not implemented yet") {
-    super(message);
-    this.name = "NotImplementedError";
-  }
-};
-var NotAuthenticatedError = class extends Error {
-  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
-    super(message);
-    this.name = "NotAuthenticatedError";
-  }
-};
-var ValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ValidationError";
-  }
-};
-var InvariantError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvariantError";
-  }
-};
-var MathError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MathError";
-  }
-};
-
-// src/universal/core/shared/blockchain/math.ts
-var import_viem = require("viem");
-
-// src/universal/types/blockchain/core.ts
-var ETHEREUM_CHAINS = {
-  ethereum_mainnet: true,
-  ethereum_sepolia: true,
-  base_mainnet: true,
-  base_sepolia: true
-};
-var EthereumChain = (value) => {
-  if (!Object.keys(ETHEREUM_CHAINS).includes(value)) {
-    throw new ValidationError(`Unsupported Ethereum chain: "${value}"`);
-  }
-  return value;
-};
-var SOLANA_CHAINS = {
-  solana_mainnet: true,
-  solana_devnet: true
-};
-var SolanaChain = (value) => {
-  if (!Object.keys(SOLANA_CHAINS).includes(value)) {
-    throw new ValidationError(`Unsupported Solana chain: "${value}"`);
-  }
-  return value;
-};
-var isChain = (value) => Object.keys(ETHEREUM_CHAINS).includes(value) || Object.keys(SOLANA_CHAINS).includes(value);
-var Chain = (value) => {
-  if (!isChain(value)) {
-    throw new ValidationError(`Unsupported chain: "${value}"`);
-  }
-  return value;
-};
-var EvmWalletAddress = (value) => value;
-var EvmContractAddress = (value) => value;
-var HexEncodedTransactionData = (value) => value;
-var MAX_ASSET_DECIMALS = 77;
-var AssetDecimals = (value) => {
-  if (!Number.isInteger(value)) {
-    throw new ValidationError(`Asset decimals must be an integer: ${value}`);
-  }
-  if (value < 0 || value > MAX_ASSET_DECIMALS) {
-    throw new ValidationError(
-      `Asset decimals out of range [0, ${MAX_ASSET_DECIMALS}]: ${value}`
-    );
-  }
-  return value;
-};
-var STABLE_DECIMALS = AssetDecimals(6);
-var DecimalString = (value) => value;
-var MAX_UINT_256 = 2n ** 256n - 1n;
-var assertUint256 = (value) => {
-  if (isUint256(value)) return value;
-  throw new InvariantError(`Value out of uint256 bounds: ${value}`);
-};
-var parseUint256 = (value, label) => {
-  if (isUint256(value)) return value;
-  throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
-};
-var isUint256 = (value) => value >= 0n && value <= MAX_UINT_256;
-var BlockchainAmount = Object.assign(
-  (value) => value,
-  {
-    add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
-    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y),
-    mul: multiplyAmounts,
-    div: divideAmounts
-  }
-);
-function multiplyAmounts(a, b) {
-  const product = a.raw * b.raw;
-  return BlockchainAmount({
-    raw: product / 10n ** BigInt(b.decimals),
-    decimals: a.decimals
-  });
-}
-function divideAmounts(a, b) {
-  if (b.raw === 0n) {
-    throw new MathError("Cannot divide a BlockchainAmount by zero");
-  }
-  const scaled = a.raw * 10n ** BigInt(b.decimals);
-  return BlockchainAmount({ raw: scaled / b.raw, decimals: a.decimals });
-}
-function combineAmounts(a, b, op) {
-  if (a.decimals !== b.decimals) {
-    throw new InvariantError(
-      `Cannot combine BlockchainAmounts with different decimals: ${a.decimals} vs ${b.decimals}`
-    );
-  }
-  const raw = op(a.raw, b.raw);
-  if (raw < 0n || raw > MAX_UINT_256) {
-    throw new InvariantError(`BlockchainAmount out of uint256 bounds: ${raw}`);
-  }
-  return BlockchainAmount({ raw, decimals: a.decimals });
-}
-var AssetSymbol = (value) => value;
-var StablecoinSymbol = (value) => value;
-var KnownAssetSymbol = StablecoinSymbol;
-var Bps = (value) => value;
-
-// src/universal/core/shared/blockchain/math.ts
-function blockchainAmountFromRawOrThrow({
-  label,
-  raw,
-  decimals
-}) {
-  const trimmed = raw.trim();
-  if (trimmed === "") {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  let value;
-  try {
-    value = BigInt(trimmed);
-  } catch {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  try {
-    return BlockchainAmount({ raw: assertUint256(value), decimals });
-  } catch {
-    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
-  }
-}
-function parseBlockchainAmount(amount, decimals) {
-  const trimmed = amount.trim();
-  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
-  if (trimmed.startsWith("-")) {
-    return { valid: false, reason: { type: "negative" } };
-  }
-  if (/[eE]/.test(trimmed)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  if (trimmed === ".") {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
-  if (!/^\d+(\.\d+)?$/.test(normalised)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const [, fraction = ""] = normalised.split(".");
-  if (fraction.length > decimals) {
-    return {
-      valid: false,
-      reason: { type: "too-many-decimals", maxDecimals: decimals }
-    };
-  }
-  try {
-    const raw = (0, import_viem.parseUnits)(normalised, decimals);
-    if (raw > MAX_UINT_256) {
-      return { valid: false, reason: { type: "overflow" } };
-    }
-    return {
-      valid: true,
-      amount: BlockchainAmount({ raw, decimals })
-    };
-  } catch {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-}
-
-// src/universal/core/shared/utils/wire.ts
-function unknownTypeError(dto, model) {
-  const type = dto.type;
-  throw new ValidationError(
-    `${model}.type: unknown type ${JSON.stringify(type)}`
-  );
-}
-function requiredString(value, field) {
-  const text = notBlankStringOrNull(value);
-  if (text === null) {
-    throw new ValidationError(
-      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
-    );
-  }
-  return text;
-}
-function requiredDate(value, field) {
-  const date = typeof value === "string" ? new Date(value) : null;
-  if (date === null || Number.isNaN(date.getTime())) {
-    throw new ValidationError(
-      `${field}: expected a date, got ${JSON.stringify(value)}`
-    );
-  }
-  return date;
-}
-function dateOrNull(value, field) {
-  return value === null ? null : requiredDate(value, field);
-}
-function decimalOrNull(value) {
-  return value === null ? null : DecimalString(value);
-}
-function requiredArray(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ValidationError(
-      `${field}: expected an array, got ${typeof value}`
-    );
-  }
-  return value;
-}
-
-// src/universal/types/providers/centrifuge/centrifuge.ts
-var 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 CentrifugeVaultBuyTransaction = {
-  fromDto: (dto) => {
-    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
-    };
-  }
-};
-var CentrifugeVaultClaimTransaction = {
-  fromDto: (dto) => ({
-    ...parseTransactionCore(dto, "CentrifugeVaultClaimTransaction"),
-    claimableShares: blockchainAmountFromRawOrThrow({
-      label: "claimable_shares",
-      raw: dto.claimable_shares,
-      decimals: AssetDecimals(dto.share_decimals)
-    })
-  })
-};
-var CentrifugeVaultPosition = {
-  fromDto: (dto) => {
-    const assetDecimals = AssetDecimals(dto.asset_decimals);
-    const shareDecimals = AssetDecimals(dto.share_decimals);
-    const asset = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: assetDecimals });
-    const shares = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: shareDecimals });
-    return {
-      chain: EthereumChain(dto.chain),
-      symbol: AssetSymbol(dto.symbol),
-      walletAddress: EvmWalletAddress(dto.wallet_address),
-      status: dto.status,
-      requested: asset("requested", dto.requested),
-      pending: asset("pending", dto.pending),
-      filledAssets: asset("filled_assets", dto.filled_assets),
-      earnedShares: shares("earned_shares", dto.earned_shares),
-      claimedShares: shares("claimed_shares", dto.claimed_shares),
-      claimableShares: shares("claimable_shares", dto.claimable_shares),
-      shareBalance: shares("share_balance", dto.share_balance),
-      averagePrice: decimalOrNull(dto.average_price),
-      frozen: dto.frozen,
-      asOf: requiredDate(dto.as_of, "CentrifugeVaultPosition.as_of")
-    };
-  }
-};
-var CentrifugeVaultRedeemPosition = {
-  fromDto: (dto) => ({
-    chain: EthereumChain(dto.chain),
-    symbol: AssetSymbol(dto.symbol),
-    walletAddress: EvmWalletAddress(dto.wallet_address),
-    status: dto.status,
-    pending: blockchainAmountFromRawOrThrow({
-      label: "pending",
-      raw: dto.pending,
-      decimals: AssetDecimals(dto.share_decimals)
-    }),
-    claimableAssets: blockchainAmountFromRawOrThrow({
-      label: "claimable_assets",
-      raw: dto.claimable_assets,
-      decimals: AssetDecimals(dto.asset_decimals)
-    }),
-    frozen: dto.frozen,
-    asOf: requiredDate(dto.as_of, "CentrifugeVaultRedeemPosition.as_of")
-  })
-};
-var CentrifugeVaultLeg = {
-  /**
-   * What a claim on the leg would collect: shares for `invest`, the funding
-   * token for `redeem`.
-   */
-  claimable: (leg) => {
-    switch (leg.direction) {
-      case "invest":
-        return leg.position.claimableShares;
-      case "redeem":
-        return leg.position.claimableAssets;
-      default: {
-        const exhaustive = leg;
-        return exhaustive;
-      }
-    }
-  },
-  /** Whether the leg has anything queued or anything ready to claim. */
-  isActive: (leg) => leg.position.pending.raw > 0n || CentrifugeVaultLeg.claimable(leg).raw > 0n
-};
-var CentrifugeVaultLegId = {
-  /** Addresses compare case-insensitively: frontline echoes them lower case. */
-  of: (leg) => [
-    leg.direction,
-    leg.position.chain,
-    leg.position.walletAddress.toLowerCase()
-  ].join(":")
-};
-var CentrifugeVaultClaimProceedsTransaction = {
-  fromDto: (dto) => ({
-    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
-    claimableAssets: blockchainAmountFromRawOrThrow({
-      label: "claimable_assets",
-      raw: dto.claimable_assets,
-      decimals: AssetDecimals(dto.asset_decimals)
-    })
-  })
-};
-function parseOrderability(canOrder, reasons, model) {
-  const [first, ...rest] = reasons;
-  if (canOrder) {
-    if (first !== void 0) {
-      throw new ValidationError(
-        `${model}.reasons: expected none when can_order is true, got ${JSON.stringify(reasons)}`
-      );
-    }
-    return { type: "orderable" };
-  }
-  if (first === void 0) {
-    throw new ValidationError(
-      `${model}.reasons: expected at least one when can_order is false`
-    );
-  }
-  return { type: "blocked", reasons: [first, ...rest] };
-}
-function parseTransactionCore(dto, model) {
-  return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
-  };
-}
-
-// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
-async function getCentrifugeVaultStatus(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/centrifuge/vault/status",
-    queryParams: {
-      symbol: params.symbol,
-      chain: params.chain
-    },
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultStatus.fromDto(dto);
-}
-async function buildCentrifugeVaultBuy(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/centrifuge/vault/invest",
-    body: {
-      ...walletFields(params),
-      amount: params.amount.raw.toString()
-    },
-    attributes: Attributes.protected()
-  });
-  if (dto.spend_input_decimals !== params.amount.decimals) {
-    throw new ValidationError(
-      `spend_input_decimals: the request was priced in ${dto.spend_input_decimals} decimals but the deposit was sized in ${params.amount.decimals}`
-    );
-  }
-  return CentrifugeVaultBuyTransaction.fromDto(dto);
-}
-async function getCentrifugeVaultPosition(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/centrifuge/vault/position",
-    queryParams: walletFields(params),
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultPosition.fromDto(dto);
-}
-async function getCentrifugeVaultRedeemPosition(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/centrifuge/vault/redeem-position",
-    queryParams: walletFields(params),
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultRedeemPosition.fromDto(dto);
-}
-async function createCentrifugeVaultClaim(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/centrifuge/vault/claim",
-    body: walletFields(params),
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultClaimTransaction.fromDto(dto);
-}
-async function createCentrifugeVaultClaimProceeds(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/centrifuge/vault/claim-proceeds",
-    body: walletFields(params),
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultClaimProceedsTransaction.fromDto(dto);
-}
-function walletFields(params) {
-  return {
-    symbol: params.symbol,
-    chain: params.chain,
-    wallet_address: params.walletAddress
-  };
-}
-
-// src/universal/core/shared/observability/log-cause.ts
-var import_viem2 = require("viem");
-function classifyLogCause(error) {
-  if (error instanceof HttpError) {
-    return httpCause(error);
-  }
-  if (error instanceof ValidationError) {
-    return { type: "validation", message: error.message };
-  }
-  if (error instanceof InvariantError) {
-    return { type: "invariant", message: error.message };
-  }
-  if (error instanceof MathError) {
-    return { type: "math", message: error.message };
-  }
-  if (error instanceof NotAuthenticatedError) {
-    return { type: "not-authenticated" };
-  }
-  if (error instanceof NotImplementedError) {
-    return { type: "not-implemented" };
-  }
-  if (error instanceof import_viem2.BaseError) {
-    const http = error.walk((e) => e instanceof HttpError);
-    if (http instanceof HttpError) {
-      return httpCause(http);
-    }
-    return { type: "rpc", reason: rpcFailureReason(error) };
-  }
-  return { type: "generic-error", name: errorName(error) };
-}
-function rpcFailureReason(error) {
-  if (error.walk((e) => e instanceof import_viem2.ContractFunctionRevertedError)) {
-    return "reverted";
-  }
-  if (error.walk((e) => e instanceof import_viem2.RpcError)) {
-    return "node-rejected";
-  }
-  if (error.walk(
-    (e) => e instanceof import_viem2.HttpRequestError || e instanceof import_viem2.WebSocketRequestError || e instanceof import_viem2.SocketClosedError || e instanceof import_viem2.TimeoutError
-  )) {
-    return "transport";
-  }
-  if (error instanceof import_viem2.ContractFunctionExecutionError) {
-    return "malformed-response";
-  }
-  return "unknown";
-}
-function describeErrorUnredacted(error) {
-  if (error instanceof HttpError) {
-    return describeHttpErrorRedacted(error);
-  }
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  return `thrown non-error: ${stringifyUnredacted(error)}`;
-}
-function stringifyUnredacted(value) {
-  if (value === void 0) return "";
-  try {
-    return JSON.stringify(
-      value,
-      (_key, item) => typeof item === "bigint" ? `${item}` : item
-    ) ?? String(value);
-  } catch (_) {
-    return "<unserializable>";
-  }
-}
-function describeHttpErrorRedacted(error) {
-  const code = apiErrorCode(error);
-  const status = error.response.status;
-  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
-}
-function errorName(error) {
-  return error instanceof Error ? error.name : `non-error ${typeof error}`;
-}
-function httpCause(error) {
-  return {
-    type: "http",
-    requestId: error.requestId,
-    status: error.response.status,
-    code: apiErrorCode(error),
-    eventId: apiErrorEventId(error)
-  };
-}
-function apiErrorEventId(error) {
-  const body = error.response.body;
-  if (typeof body !== "object" || body === null) return null;
-  const eventId = body.event_id;
-  return typeof eventId === "string" ? eventId : null;
-}
-
-// src/universal/core/shared/observability/internal-logger.ts
-function internalLogger(logger, scope) {
-  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
-}
-var LEVEL_RANK = {
-  none: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4
-};
-function scopedLogger(logger, scope, bindings) {
-  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
-  const safe = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {},
-    ...event.cause === void 0 ? {} : { cause: event.cause }
-  });
-  const unredacted = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {}
-  });
-  const self = {
-    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
-    debug: (event) => {
-      if (admits("debug")) logger.debug(() => unredacted(event()));
-    },
-    info: (event) => {
-      if (admits("info")) logger.info(() => safe(event()));
-    },
-    warn: (event) => {
-      if (admits("warn")) logger.warn(() => safe(event()));
-    },
-    error: (event) => {
-      if (admits("error")) logger.error(() => safe(event()));
-    },
-    failure: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("error")) logger.error(() => safe(classified(event(), error)));
-    },
-    warning: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
-    },
-    wrap: async (op, params, run) => {
-      const opLog = self.child({ op });
-      opLog.debug(() => ({ msg: "call", fields: { params } }));
-      try {
-        return await run();
-      } catch (error) {
-        opLog.failure(() => ({ msg: "call failed" }), error);
-        throw error;
-      }
-    }
-  };
-  return self;
-}
-function verbatim(event, error) {
-  return {
-    msg: event.msg,
-    fields: { ...event.fields, error: describeErrorUnredacted(error) }
-  };
-}
-function classified(event, error) {
-  return { ...event, cause: event.cause ?? classifyLogCause(error) };
-}
-var noopInternalLogger = {
-  child: () => noopInternalLogger,
-  debug: () => void 0,
-  info: () => void 0,
-  warn: () => void 0,
-  error: () => void 0,
-  failure: () => void 0,
-  warning: () => void 0,
-  wrap: (_op, _params, run) => run()
-};
-
-// src/universal/core/checkout/centrifuge/centrifuge-namespace.ts
-var CentrifugeNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "CENTRIFUGE");
-  }
-  async getVaultStatus(params) {
-    return this.log.wrap("getVaultStatus", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getCentrifugeVaultStatus(this.ctx.api, params);
-    });
-  }
-  async getPosition(params) {
-    return this.log.wrap("getPosition", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getCentrifugeVaultPosition(this.ctx.api, params);
-    });
-  }
-  async getRedeemPosition(params) {
-    return this.log.wrap("getRedeemPosition", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
-    });
-  }
-  async createClaim(params) {
-    return this.log.wrap("createClaim", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return createCentrifugeVaultClaim(this.ctx.api, params);
-    });
-  }
-  async createClaimProceeds(params) {
-    return this.log.wrap("createClaimProceeds", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return createCentrifugeVaultClaimProceeds(this.ctx.api, params);
-    });
-  }
-  async buildBuyTransaction(params) {
-    return this.log.wrap("buildBuyTransaction", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return buildCentrifugeVaultBuy(this.ctx.api, params);
-    });
-  }
-};
-
-// src/universal/core/checkout/centrifuge/constants.ts
-var CENTRIFUGE_POLL_INTERVAL_MS = 15e3;
-
-// src/universal/core/checkout/centrifuge/vaults.ts
-function resolveCentrifugeVaults(offer, lookup) {
-  return offer.vaultContracts.map((contract) => {
-    const { chain } = contract;
-    if (!isEthereumChain(chain)) {
-      return { type: "unresolved", chain, missing: "evm-chain" };
-    }
-    const onChain = (role) => offer.tokens.filter(
-      (token) => token.role === role && token.chain === chain
-    );
-    const share = firstKnown(onChain("vault"), lookup);
-    if (share === null) {
-      return { type: "unresolved", chain, missing: "share-token" };
-    }
-    const funding = firstKnown(onChain("funding"), lookup);
-    if (funding === null) {
-      return { type: "unresolved", chain, missing: "funding-token" };
-    }
-    return {
-      type: "resolved",
-      vault: { chain, proxy: contract.address, share, funding }
-    };
-  });
-}
-function firstKnown(tokens, lookup) {
-  for (const token of tokens) {
-    const metadata = lookup(token);
-    if (metadata !== null) return metadata;
-  }
-  return null;
-}
-function isEthereumChain(chain) {
-  return chain in ETHEREUM_CHAINS;
-}
-
-// src/universal/types/pagination.ts
-var Cursor = (value) => value;
-var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
-  /**
-   * For a mapper that decides the page as a whole - one that drops items it
-   * cannot map, such as `Offer.listFromDto` - rather than item by item. The
-   * cursors are the wire's either way: dropping an item changes what the
-   * page holds, not where the next page starts.
-   */
-  fromDtoPage: (dto, pageMapper) => ({
-    data: pageMapper(dto.data),
-    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
-    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
-  })
-};
-var PaginationParams = {
-  toQueryParams: (params) => {
-    const queryParams = {};
-    if (params.after) {
-      queryParams.starting_after = params.after;
-    }
-    if (params.before) {
-      queryParams.starting_before = params.before;
-    }
-    if (params.limit) {
-      queryParams.limit = params.limit;
-    }
-    return queryParams;
-  }
-};
-
-// src/universal/types/asset.ts
-var AssetId = (value) => value;
-var AssetCode = (value) => value;
-var Asset = {
-  fromDto: (dto) => ({
-    id: AssetId(dto.id),
-    code: AssetCode(dto.code),
-    name: dto.name,
-    fractionalDigits: dto.fractional_digits
-  })
-};
-
-// src/universal/types/offer.ts
-var OfferId = (value) => value;
-var OfferSlug = (value) => value;
-var OFFER_TYPES = {
-  "coinlist::token_sale": true,
-  "superstate::swap": true,
-  "ondo::swap": true,
-  "centrifuge::vault": true
-};
-var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
-var OfferEditorial = {
-  /**
-   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
-   * the same three checks name the payload that failed them.
-   */
-  fromDto: (dto, model) => ({
-    tagline: requiredString(dto.tagline, `${model}.tagline`),
-    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
-    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
-  })
-};
-var Offer = {
-  fromDto: (dto) => {
-    const tokens = requiredArray(dto.tokens, "Offer.tokens");
-    const base2 = {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      tokens: OfferToken.listFromDto(tokens)
-    };
-    switch (dto.type) {
-      case "coinlist::token_sale":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "Offer"),
-          type: dto.type,
-          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
-        };
-      case "superstate::swap":
-        return {
-          ...base2,
-          ...OfferEditorial.fromDto(dto, "Offer"),
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url)
-        };
-      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
-      // on the wire: copying them would hand every consumer a `startsAt` that
-      // is 1970 for one variant and a date for the others.
-      case "ondo::swap":
-      case "centrifuge::vault":
-        return {
-          ...base2,
-          type: dto.type,
-          logoUrl: notBlankStringOrNull(dto.logo_url)
-        };
-      default:
-        return unknownTypeError(dto, "Offer");
-    }
-  },
-  /**
-   * Maps a page of offers, dropping every offer whose `type` this SDK does not
-   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
-   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
-   * reject the whole page, so one offer of an unknown type would blank the
-   * grid for every offer beside it. A single offer fetched by id still
-   * throws, because there is nothing beside it to keep.
-   */
-  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
-};
-var OfferToken = {
-  fromDto: (dto) => ({
-    role: dto.role,
-    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/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/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/token-registry.ts
-var USDC_SYMBOL = StablecoinSymbol("USDC");
-var USDC = {
-  name: "USD Coin",
-  symbol: USDC_SYMBOL,
-  decimals: AssetDecimals(6)
-};
-var USDT_SYMBOL = StablecoinSymbol("USDT");
-var USDT = {
-  name: "Tether USD",
-  symbol: USDT_SYMBOL,
-  decimals: AssetDecimals(6)
-};
-var USDC_ADDRESSES = {
-  ethereum_mainnet: EvmContractAddress(
-    "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
-  ),
-  ethereum_sepolia: EvmContractAddress(
-    "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
-  ),
-  base_mainnet: EvmContractAddress(
-    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-  ),
-  base_sepolia: EvmContractAddress(
-    "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-  )
-};
-var USDT_ADDRESSES = {
-  ethereum_mainnet: EvmContractAddress(
-    "0xdac17f958d2ee523a2206206994597c13d831ec7"
-  ),
-  ethereum_sepolia: EvmContractAddress(
-    "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
-  ),
-  base_mainnet: EvmContractAddress(
-    "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"
-  ),
-  base_sepolia: null
-};
-var TOKEN_REGISTRY = {
-  erc20: (symbol) => {
-    switch (symbol) {
-      case "USDC":
-        return USDC;
-      case "USDT":
-        return USDT;
-      default:
-        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
-    }
-  },
-  /**
-   * USDC's contract on `chain`. USDC is deployed on every chain the SDK
-   * models, so the table is total and the answer is never `null`.
-   */
-  usdcAddress: (chain) => USDC_ADDRESSES[chain],
-  /**
-   * USDT's contract on `chain`, or `null` where Tether publishes none —
-   * Base Sepolia today. The honest answer, never a fake address a balance
-   * read would call.
-   */
-  usdtAddress: (chain) => USDT_ADDRESSES[chain]
-};
-
-// src/universal/core/checkout/ondo/constants.ts
-var ONDO_POLL_INTERVAL_MS = 15e3;
-var ONDO_QUOTE_MAX_TTL_MS = 15e3;
-var DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE = DecimalString("1000");
-var ONDO_SETTLEMENT_ASSET = USDC_SYMBOL;
-var DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE = 1;
-var ONDO_SUPPORTED_INPUT_ASSETS = [
-  USDC_SYMBOL
-];
-
-// src/universal/core/checkout/ondo/math.ts
-function computeOndoBuyPrice(transaction) {
-  const { notionalValue, receiveOutputAmount } = transaction;
-  return pricePerShare({
-    usd: notionalValue,
-    shares: receiveOutputAmount
-  });
-}
-function computeOndoSellPrice(transaction) {
-  const { expected, spendInputAmount } = transaction;
-  return pricePerShare({
-    usd: grossProceeds(expected),
-    shares: spendInputAmount
-  });
-}
-function ondoQuoteOfferDeadline(expiresAt, nowMs = Date.now()) {
-  return new Date(Math.min(expiresAt.getTime(), nowMs + ONDO_QUOTE_MAX_TTL_MS));
-}
-function grossProceeds(expected) {
-  const raw = expected.quantity.raw + expected.fee.raw;
-  if (raw > MAX_UINT_256) {
-    throw new MathError(`Ondo sell proceeds: out of uint256 bounds (${raw})`);
-  }
-  return BlockchainAmount.add(expected.quantity, expected.fee);
-}
-function pricePerShare({
-  usd,
-  shares
-}) {
-  const price = BlockchainAmount.div(usd, shares);
-  return BlockchainAmount({
-    raw: assertPriceFits(price.raw),
-    decimals: price.decimals
-  });
-}
-function assertPriceFits(raw) {
-  try {
-    return assertUint256(raw);
-  } catch {
-    throw new MathError(`Ondo price: out of uint256 bounds (${raw})`);
-  }
-}
-
-// src/universal/core/checkout/ondo/not-tradable.ts
-var ONDO_NOT_TRADABLE_CODE = "not_tradable";
-function isOndoNotTradableError(error) {
-  return apiErrorCode(error) === ONDO_NOT_TRADABLE_CODE;
-}
-
-// src/universal/core/shared/blockchain/formatters.ts
-var import_viem3 = require("viem");
-
-// 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
-function shortenAddress(address) {
-  const short = address.length > 10 ? `${address.slice(0, 6)}\u2026${address.slice(-4)}` : address;
-  return ShortenedWalletAddress(short);
-}
-function formatAmount(amount, locale, options) {
-  const decimal = formatRawAmount(amount);
-  let [integerPart, fractionPart = ""] = decimal.split(".");
-  const maxFractionDigits = options?.maxFractionDigits;
-  const minFractionDigits = Math.min(
-    options?.minFractionDigits ?? (maxFractionDigits !== void 0 ? maxFractionDigits : 2),
-    maxFractionDigits ?? amount.decimals,
-    amount.decimals
-  );
-  if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
-    ({ integerPart, fractionPart } = roundFractionHalfUp(
-      integerPart,
-      fractionPart,
-      maxFractionDigits
-    ));
-  }
-  const trimmed = fractionPart.replace(/0+$/, "");
-  const fraction = trimmed.padEnd(minFractionDigits, "0");
-  const integerFormatted = BigInt(integerPart).toLocaleString(locale);
-  if (minFractionDigits === 0 && fraction === "") {
-    return FormattedAmountUi(integerFormatted);
-  }
-  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
-  return FormattedAmountUi(`${integerFormatted}${decimalSeparator}${fraction}`);
-}
-function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
-  if (fractionPart.length <= maxFractionDigits) {
-    return { integerPart, fractionPart };
-  }
-  if (maxFractionDigits === 0) {
-    const roundUp = fractionPart[0] >= "5";
-    const integer = BigInt(integerPart) + (roundUp ? 1n : 0n);
-    return { integerPart: integer.toString(), fractionPart: "" };
-  }
-  const trimmed = fractionPart.slice(0, maxFractionDigits);
-  if (fractionPart[maxFractionDigits] < "5") {
-    return { integerPart, fractionPart: trimmed };
-  }
-  const digits = trimmed.split("").map((digit) => Number.parseInt(digit, 10));
-  let carry = 1;
-  for (let i = digits.length - 1; i >= 0 && carry > 0; i -= 1) {
-    const sum = digits[i] + carry;
-    if (sum === 10) {
-      digits[i] = 0;
-      carry = 1;
-    } else {
-      digits[i] = sum;
-      carry = 0;
-    }
-  }
-  return {
-    integerPart: carry > 0 ? (BigInt(integerPart) + 1n).toString() : integerPart,
-    fractionPart: digits.join("")
-  };
-}
-function formatRawAmount(amount) {
-  return (0, import_viem3.formatUnits)(amount.raw, amount.decimals);
-}
-function formatCompactAmount(amount, locale) {
-  const value = Number(formatRawAmount(amount));
-  const formatted = new Intl.NumberFormat(locale, {
-    notation: "compact",
-    maximumFractionDigits: 2
-  }).format(value);
-  return FormattedAmountUi(formatted);
-}
-function formatBpsAsPercent(bps, locale) {
-  const whole = bps / 100n;
-  const fraction = bps % 100n;
-  const wholeFormatted = whole.toLocaleString(locale);
-  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
-  if (fraction === 0n) {
-    return FormattedPercentUi(`${wholeFormatted}%`);
-  }
-  const fractionFormatted = fraction.toString().padStart(2, "0").replace(/0+$/, "");
-  return FormattedPercentUi(
-    `${wholeFormatted}${decimalSeparator}${fractionFormatted}%`
-  );
-}
-function usdAmount(amount) {
-  return FormattedAmountAssetUi(`$${amount}`);
-}
-function assetAmount(amount, symbol) {
-  return FormattedAmountAssetUi(`${amount} ${symbol}`);
-}
-var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
-var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
-var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
-function formatShareAmount(amount, locale) {
-  return formatAmount(amount, locale, {
-    maxFractionDigits: SHARE_MAX_FRACTION_DIGITS,
-    minFractionDigits: SHARE_MIN_FRACTION_DIGITS
-  });
-}
-var USD_FRACTION_DIGITS = AssetDecimals(2);
-function formattedUsdPrice(amount, locale) {
-  if (!amount) return NA_AMOUNT_ASSET_UI;
-  return usdAmount(
-    formatAmount(amount, locale, { maxFractionDigits: USD_FRACTION_DIGITS })
-  );
-}
-
-// src/universal/core/shared/blockchain/chain.ts
-var import_chains = require("viem/chains");
-var VIEM_CHAINS = {
-  ethereum_mainnet: import_chains.mainnet,
-  ethereum_sepolia: import_chains.sepolia,
-  base_mainnet: import_chains.base,
-  base_sepolia: import_chains.baseSepolia
-};
-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 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;
-    }
-  }
-}
-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;
-    }
-  }
-}
-
-// src/universal/types/providers/ondo/ondo.ts
-var OndoTradingStatus = {
-  fromDto: (dto) => {
-    if (!dto.tradable) return { type: "not-tradable", side: dto.side };
-    return {
-      type: "tradable",
-      side: dto.side,
-      grossMaxTokens: decimalOrNull(dto.gross_max_tokens),
-      grossMaxNotionalValue: decimalOrNull(dto.gross_max_notional_value),
-      grossMaxActiveNotionalValue: decimalOrNull(
-        dto.gross_max_active_notional_value
-      )
-    };
-  }
-};
-var OndoQuote = {
-  fromDto: (dto) => {
-    const assetDecimals = AssetDecimals(dto.asset_decimals);
-    return {
-      chain: chainFromId(dto.chain_id),
-      ticker: Ticker(dto.ticker),
-      assetAddress: EvmContractAddress(dto.asset_address),
-      asset: {
-        name: dto.ticker,
-        symbol: AssetSymbol(dto.symbol),
-        decimals: assetDecimals
-      },
-      side: dto.side,
-      tokenBaseUnits: blockchainAmountFromRawOrThrow({
-        label: "tokenBaseUnits",
-        raw: dto.token_base_units,
-        decimals: assetDecimals
-      }),
-      price: DecimalString(dto.price)
-    };
-  }
-};
-var OndoBuyTransaction = {
-  fromDto: (dto) => {
-    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
-    const outputDecimals = AssetDecimals(dto.receive_output_decimals);
-    return {
-      ...parseSwapCore(dto, spendDecimals),
-      side: "buy",
-      fee: blockchainAmountFromRawOrThrow({
-        label: "fee",
-        raw: dto.fee,
-        decimals: spendDecimals
-      }),
-      notionalValue: blockchainAmountFromRawOrThrow({
-        label: "notional_value",
-        raw: dto.notional_value,
-        decimals: spendDecimals
-      }),
-      receiveOutputAmount: parsePositiveAmount({
-        label: "receive_output_amount",
-        raw: dto.receive_output_amount,
-        decimals: outputDecimals,
-        // A transaction that yields nothing is not one to sign - the user
-        // would pay the deposit and receive no asset - and frontline refuses
-        // to emit one. A zero here is a changed encoding, not a small order.
-        // Rejecting it at the boundary is also what lets `computeOndoBuyPrice`
-        // divide by it without a fallible result: the failure surfaces as the
-        // data hook's ERROR state rather than as a division during render.
-        reason: "a buy that yields nothing is not fillable"
-      })
-    };
-  }
-};
-var OndoSellTransaction = {
-  fromDto: (dto) => {
-    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
-    const outputDecimals = AssetDecimals(dto.receive_output_decimals);
-    const expectedQuantity = parsePositiveAmount({
-      label: "expected_quantity",
-      raw: dto.expected_quantity,
-      decimals: outputDecimals,
-      reason: "a sale that yields nothing is not fillable"
-    });
-    return {
-      ...parseSwapCore(dto, spendDecimals),
-      side: "sell",
-      expected: {
-        quantity: expectedQuantity,
-        fee: blockchainAmountFromRawOrThrow({
-          label: "expected_fee",
-          raw: dto.expected_fee,
-          decimals: outputDecimals
-        })
-      },
-      minimum: {
-        quantity: parseMinimumQuantity(
-          dto.minimum_quantity,
-          outputDecimals,
-          expectedQuantity
-        ),
-        fee: blockchainAmountFromRawOrThrow({
-          label: "minimum_fee",
-          raw: dto.minimum_fee,
-          decimals: outputDecimals
-        })
-      }
-    };
-  }
-};
-function parseSwapCore(dto, spendDecimals) {
-  return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: parseExpiresAt(dto.expires_at),
-    spendInputAmount: parsePositiveAmount({
-      label: "spend_input_amount",
-      raw: dto.spend_input_amount,
-      decimals: spendDecimals,
-      // A transaction that takes nothing from the wallet is not one to sign:
-      // it would settle one leg of a trade and skip the other. Frontline
-      // refuses an `amount` of zero whichever way the trade runs, so this is a
-      // changed encoding rather than a small order.
-      //
-      // Guarded on both sides rather than on the sale alone, because which
-      // amount becomes the divisor in the price flips with the direction: a
-      // guard placed by that would be a rule about the arithmetic rather than
-      // about the trade.
-      reason: "a swap that spends nothing is not fillable"
-    })
-  };
-}
-function parseMinimumQuantity(raw, decimals, expectedQuantity) {
-  const amount = parsePositiveAmount({
-    label: "minimum_quantity",
-    raw,
-    decimals,
-    reason: "a floor of zero guarantees nothing"
-  });
-  if (amount.raw > expectedQuantity.raw) {
-    throw new ValidationError(
-      `minimum_quantity: must not exceed expected_quantity ("${raw}" > "${expectedQuantity.raw}")`
-    );
-  }
-  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) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/ondo/swap/trading-status",
-    queryParams: { symbol: params.symbol, side: params.side },
-    attributes: Attributes.protected()
-  });
-  return OndoTradingStatus.fromDto(dto);
-}
-async function getOndoQuote(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/ondo/swap/quote",
-    queryParams: {
-      symbol: params.symbol,
-      side: params.side,
-      duration: params.duration,
-      ...sizeParam(params)
-    },
-    attributes: Attributes.protected()
-  });
-  return OndoQuote.fromDto(dto);
-}
-async function buildOndoBuy(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/ondo/swap/buy",
-    body: swapBody(params),
-    attributes: Attributes.protected()
-  });
-  assertSpendScaleAgrees({
-    published: dto.spend_input_decimals,
-    sized: params.amount,
-    trade: "purchase"
-  });
-  return OndoBuyTransaction.fromDto(dto);
-}
-async function buildOndoSell(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/ondo/swap/sell",
-    body: swapBody(params),
-    attributes: Attributes.protected()
-  });
-  assertSpendScaleAgrees({
-    published: dto.spend_input_decimals,
-    sized: params.amount,
-    trade: "sale",
-    // The two answers come from two chains, so on a testnet they can disagree
-    // for a reason that is neither the caller's nor a corrupt response. Say so,
-    // or a QA run reads as a puzzle rather than a diagnosis.
-    note: "the quote resolves the asset on Ethereum mainnet while the swap executes on the chain requested, so these disagree until frontline serves a chain-scoped quote"
-  });
-  return OndoSellTransaction.fromDto(dto);
-}
-function swapBody(params) {
-  return {
-    symbol: params.symbol,
-    chain: params.chain,
-    wallet_address: params.walletAddress,
-    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;
-  if (tokenAmount !== void 0) {
-    if (notionalValue !== void 0) {
-      throw new ValidationError(
-        "An Ondo quote takes tokenAmount or notionalValue, not both"
-      );
-    }
-    return { token_amount: formatRawAmount(tokenAmount) };
-  }
-  if (notionalValue === void 0) {
-    throw new ValidationError(
-      "An Ondo quote must be sized by tokenAmount or notionalValue"
-    );
-  }
-  return { notional_value: notionalValue };
-}
-
-// src/universal/core/checkout/ondo/ondo-namespace.ts
-var OndoNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "ONDO");
-  }
-  async getTradingStatus(params) {
-    return this.log.wrap("getTradingStatus", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getOndoTradingStatus(this.ctx.api, params);
-    });
-  }
-  async getQuote(params) {
-    return this.log.wrap("getQuote", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getOndoQuote(this.ctx.api, params);
-    });
-  }
-  async buildBuyTransaction(params) {
-    return this.log.wrap("buildBuyTransaction", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return buildOndoBuy(this.ctx.api, params);
-    });
-  }
-  async buildSellTransaction(params) {
-    return this.log.wrap("buildSellTransaction", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return buildOndoSell(this.ctx.api, params);
-    });
-  }
-};
-
-// src/universal/core/checkout/superstate/blockchain/abi.ts
-var SUPERSTATE_SWAP_ABI = [
-  {
-    type: "function",
-    name: "KIND",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint16",
-        internalType: "uint16"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "ONE_HUNDRED_P",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "SWAP_LEVEL",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint32",
-        internalType: "uint32"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "VERSION",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint16",
-        internalType: "uint16"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "authorized",
-    inputs: [
-      {
-        name: "user",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "bpp",
-    inputs: [
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "bps",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "cancelOwnershipHandover",
-    inputs: [],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "completeOwnershipHandover",
-    inputs: [
-      {
-        name: "pendingOwner",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "fee",
-    inputs: [
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "id",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "inputTokens",
-    inputs: [
-      {
-        name: "",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "outputToken",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "outputTokenBalance",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "owner",
-    inputs: [],
-    outputs: [
-      {
-        name: "result",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "ownershipHandoverExpiresAt",
-    inputs: [
-      {
-        name: "pendingOwner",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "result",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "pause",
-    inputs: [
-      {
-        name: "level",
-        type: "uint32",
-        internalType: "uint32"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "paused",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint32",
-        internalType: "uint32"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "preview",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "tuple",
-        internalType: "struct Preview",
-        components: [
-          {
-            name: "input",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "fee",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "output",
-            type: "uint256",
-            internalType: "uint256"
-          }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "renounceOwnership",
-    inputs: [],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "requestOwnershipHandover",
-    inputs: [],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "setBps",
-    inputs: [
-      {
-        name: "points",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "setInputToken",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "val",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "status",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "tuple",
-        internalType: "struct Status",
-        components: [
-          {
-            name: "flags",
-            type: "uint32",
-            internalType: "uint32"
-          },
-          {
-            name: "state",
-            type: "uint8",
-            internalType: "enum State"
-          }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "stop",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "stopped",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "swap",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "slip",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "tokenBalance",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totals",
-    inputs: [
-      {
-        name: "user",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "tuple",
-        internalType: "struct SwapTotal",
-        components: [
-          {
-            name: "inputSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "feeSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "outputSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "count",
-            type: "uint256",
-            internalType: "uint256"
-          }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totals",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "tuple",
-        internalType: "struct SwapTotal",
-        components: [
-          {
-            name: "inputSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "feeSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "outputSum",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "count",
-            type: "uint256",
-            internalType: "uint256"
-          }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      {
-        name: "to",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      {
-        name: "to",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool",
-        internalType: "bool"
-      }
-    ],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transferOwnership",
-    inputs: [
-      {
-        name: "newOwner",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "event",
-    name: "BpsUpdated",
-    inputs: [
-      {
-        name: "prev",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      },
-      {
-        name: "next",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "InputTokenUpdated",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "prev",
-        type: "bool",
-        indexed: false,
-        internalType: "bool"
-      },
-      {
-        name: "next",
-        type: "bool",
-        indexed: false,
-        internalType: "bool"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "OwnershipHandoverCanceled",
-    inputs: [
-      {
-        name: "pendingOwner",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "OwnershipHandoverRequested",
-    inputs: [
-      {
-        name: "pendingOwner",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "OwnershipTransferred",
-    inputs: [
-      {
-        name: "oldOwner",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "newOwner",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Paused",
-    inputs: [
-      {
-        name: "previous",
-        type: "uint32",
-        indexed: false,
-        internalType: "uint32"
-      },
-      {
-        name: "next",
-        type: "uint32",
-        indexed: false,
-        internalType: "uint32"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Stopped",
-    inputs: [],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Swapped",
-    inputs: [
-      {
-        name: "user",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "inputToken",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "outputToken",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "inputAmount",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      },
-      {
-        name: "fee",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      },
-      {
-        name: "outputAmount",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Transferred",
-    inputs: [
-      {
-        name: "to",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "token",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "error",
-    name: "AlreadyInitialized",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InsufficientAmount",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidAddress",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidAmount",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "IsPaused",
-    inputs: [
-      {
-        name: "level",
-        type: "uint32",
-        internalType: "uint32"
-      }
-    ]
-  },
-  {
-    type: "error",
-    name: "IsStopped",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "NewOwnerIsZeroAddress",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "NoHandoverRequest",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "SwapFailed",
-    inputs: [
-      {
-        name: "user",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "token",
-        type: "address",
-        internalType: "address"
-      }
-    ]
-  },
-  {
-    type: "error",
-    name: "Unauthorized",
-    inputs: []
-  }
-];
-
-// src/universal/core/shared/blockchain/bps.ts
-var BPS_DENOM = Bps(10000n);
-function applyBps(amount, bps) {
-  return assertUint256(amount * bps / BPS_DENOM);
-}
-
-// src/universal/core/checkout/superstate/blockchain/math.ts
-function computePrice({
-  inputTokenAmount,
-  outputTokenAmount
-}) {
-  if (outputTokenAmount.raw === 0n) return null;
-  const scale = 10n ** BigInt(outputTokenAmount.decimals);
-  const raw = assertUint256(
-    inputTokenAmount.raw * scale / outputTokenAmount.raw
-  );
-  return BlockchainAmount({ raw, decimals: inputTokenAmount.decimals });
-}
-function computeSlip(amount, slippage) {
-  const retained = Bps(assertUint256(BPS_DENOM - slippage));
-  const slipRaw = applyBps(amount.raw, retained);
-  return BlockchainAmount({ raw: slipRaw, decimals: amount.decimals });
-}
-
-// 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/core/checkout/superstate/blockchain/status.ts
-var SWAP_LEVEL = 2;
-function isSwapAvailable(status) {
-  switch (status.state) {
-    case "active":
-      return true;
-    case "stopped":
-      return false;
-    case "paused":
-      return (status.pausedLevels & SWAP_LEVEL) === 0;
-    default: {
-      const _exhaustive = status;
-      return _exhaustive;
-    }
-  }
-}
-
-// src/universal/core/checkout/superstate/blockchain/swapped-event.ts
-var import_viem4 = require("viem");
-function decodeSwappedOutputAmount(receipt, outputDecimals) {
-  try {
-    const [swapped] = (0, import_viem4.parseEventLogs)({
-      abi: SUPERSTATE_SWAP_ABI,
-      eventName: "Swapped",
-      logs: receipt.logs
-    });
-    if (!swapped) return null;
-    const raw = swapped.args.outputAmount;
-    if (raw < 0n || raw > MAX_UINT_256) return null;
-    return BlockchainAmount({ raw, decimals: outputDecimals });
-  } catch {
-    return null;
-  }
-}
-
-// src/universal/core/checkout/superstate/constants.ts
-var SUPERSTATE_ISSUER_NAME = "Superstate";
-var SUPERSTATE_SUPPORTED_INPUT_ASSETS = [USDC_SYMBOL];
-var SWAP_POLL_INTERVAL_MS = 15e3;
-var DEFAULT_AMOUNT_TO_COMPUTE_PRICE = 1000000n;
-var SLIPPAGE_OPTIONS_BPS = [25n, 50n, 100n, 200n, 500n].map(
-  (n) => Bps(n)
-);
-var DEFAULT_SLIPPAGE_BPS = Bps(50n);
-var SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA = EvmContractAddress("0x27E8CE9Ca1A1E98Bc4009F08Dc596bFcf88aCED1");
-var SUPERSTATE_SWAP_CONTRACT_ADDRESSES = {
-  ethereum_sepolia: SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA
-};
-function superstateSwapContractAddress(chain) {
-  return SUPERSTATE_SWAP_CONTRACT_ADDRESSES[chain] ?? null;
-}
-
-// src/universal/core/checkout/superstate/formatters.ts
-function formattedPricePerShare(quote, locale) {
-  if (!quote) return NA_AMOUNT_ASSET_UI;
-  return formattedUsdPrice(computePrice(quote), locale);
-}
-
-// 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/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/rpc/providers/superstate/swap.ts
-async function getSwapAuthorization(clients, params) {
-  return clients(params.chain).readContract({
-    address: params.contractAddress,
-    abi: SUPERSTATE_SWAP_ABI,
-    functionName: "authorized",
-    args: [params.walletAddress]
-  });
-}
-async function getSwapPreview(clients, params) {
-  const preview = await clients(params.chain).readContract({
-    address: params.contractAddress,
-    abi: SUPERSTATE_SWAP_ABI,
-    functionName: "preview",
-    args: [params.inputToken, params.amount]
-  });
-  return SwapPreview.fromContract(preview);
-}
-async function getSwapStatus(clients, params) {
-  const status = await clients(params.chain).readContract({
-    address: params.contractAddress,
-    abi: SUPERSTATE_SWAP_ABI,
-    functionName: "status"
-  });
-  return SwapStatus.fromContract(status);
-}
-async function getSwapOutputToken(clients, params) {
-  const client = clients(params.chain);
-  const tokenAddress = await client.readContract({
-    address: params.contractAddress,
-    abi: SUPERSTATE_SWAP_ABI,
-    functionName: "outputToken"
-  });
-  const token = { address: EvmContractAddress(tokenAddress), abi: ERC20_ABI };
-  const [name, symbol, decimals] = await client.multicall({
-    contracts: [
-      { ...token, functionName: "name" },
-      { ...token, functionName: "symbol" },
-      { ...token, functionName: "decimals" }
-    ],
-    allowFailure: false
-  });
-  return {
-    name,
-    symbol: AssetSymbol(symbol),
-    decimals: AssetDecimals(decimals)
-  };
-}
-
-// src/universal/core/checkout/superstate/swap-namespace.ts
-var SuperstateSwapNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "SUPERSTATE");
-  }
-  async getAuthorization(params) {
-    return this.log.wrap(
-      "getAuthorization",
-      params,
-      async () => getSwapAuthorization(this.ctx.rpc, params)
-    );
-  }
-  async getPreview(params) {
-    return this.log.wrap(
-      "getPreview",
-      params,
-      async () => getSwapPreview(this.ctx.rpc, params)
-    );
-  }
-  async getStatus(params) {
-    return this.log.wrap(
-      "getStatus",
-      params,
-      async () => getSwapStatus(this.ctx.rpc, params)
-    );
-  }
-  async getOutputToken(params) {
-    return this.log.wrap(
-      "getOutputToken",
-      params,
-      async () => getSwapOutputToken(this.ctx.rpc, params)
-    );
-  }
-  async allowWallet(params) {
-    return this.log.wrap("allowWallet", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return allowWallet(this.ctx.api, params);
-    });
-  }
-};
-
-// src/universal/api/frontline/offers.ts
-async function fetchOffers(api, clientCreds) {
-  return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
-}
-async function fetchOffersPage(api, params, clientCreds) {
-  const queryParams = PaginationParams.toQueryParams(params);
-  const pageDto = await api.send({
-    method: "GET",
-    url: "/v1/offers",
-    queryParams,
-    attributes: Attributes.concat(
-      Attributes.protected(),
-      Attributes.clientCredentials(clientCreds)
-    )
-  });
-  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
-}
-async function fetchOfferDetails(api, id, clientCreds) {
-  const dto = await api.send({
-    method: "GET",
-    url: `/v1/offers/${id}`,
-    attributes: Attributes.concat(
-      Attributes.protected(),
-      Attributes.clientCredentials(clientCreds)
-    )
-  });
-  return OfferDetail.fromDto(dto);
-}
-
-// src/universal/core/offers/offers-namespace.ts
-var OffersNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "OFFERS");
-  }
-  async list() {
-    return this.log.wrap("list", void 0, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return fetchOffers(this.ctx.api, void 0);
-    });
-  }
-  async listPage(params) {
-    return this.log.wrap("listPage", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return fetchOffersPage(this.ctx.api, params, void 0);
-    });
-  }
-  async get(id) {
-    return this.log.wrap("get", id, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return fetchOfferDetails(this.ctx.api, id, void 0);
-    });
-  }
-};
-
-// src/universal/core/offers/swap-contracts.ts
-function swapSpender(swapContracts, chain) {
-  return swapContracts.find((contract) => contract.chain === chain)?.address ?? null;
-}
-
-// src/universal/types/document-submission.ts
-var DocumentSubmission = {
-  fromDto: (dto) => ({
-    status: dto.status,
-    formType: dto.form_type
-  })
-};
-
-// src/universal/api/frontline/documents.ts
-async function submitDocument(api, documentType, fields) {
-  const dto = await api.send({
-    method: "POST",
-    url: `/v1/documents/${documentType}/submission`,
-    body: fields,
-    attributes: Attributes.protected()
-  });
-  return DocumentSubmission.fromDto(dto);
-}
-
-// src/universal/types/kyc.ts
-var KycToken = {
-  fromDto: (dto) => ({
-    token: dto.token
-  })
-};
-
-// src/universal/api/frontline/kyc.ts
-async function createKycToken(api, levelName, reset) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/kyc-token",
-    body: {
-      ...levelName === void 0 ? {} : { level_name: levelName },
-      ...reset === void 0 ? {} : { reset }
-    },
-    attributes: Attributes.protected()
-  });
-  return KycToken.fromDto(dto);
-}
-
-// src/universal/types/pii.ts
-var Iso2CountryCode = (value) => value;
-var PiiJurisdiction = {
-  fromDto: (dto) => ({
-    iso2: Iso2CountryCode(dto.iso_2),
-    name: dto.name
-  })
-};
-var PiiAddress = {
-  fromDto: (dto) => ({
-    street: dto.street,
-    city: dto.city,
-    state: dto.state,
-    postalCode: dto.postal_code,
-    country: dto.country
-  })
-};
-var Pii = {
-  fromDto: (dto) => ({
-    kind: dto.kind,
-    fullLegalName: dto.full_legal_name,
-    dateOfBirth: dto.date_of_birth,
-    jurisdiction: dto.jurisdiction ? PiiJurisdiction.fromDto(dto.jurisdiction) : null,
-    taxId: dto.tax_id,
-    permanentAddress: PiiAddress.fromDto(dto.permanent_address)
-  })
-};
-
-// src/universal/api/frontline/pii.ts
-async function fetchPii(api) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/pii",
-    attributes: Attributes.protected()
-  });
-  return Pii.fromDto(dto);
-}
-
-// src/universal/types/requirement.ts
-var RequirementId = (value) => value;
-var Requirement = {
-  fromDto: (dto) => ({
-    id: RequirementId(dto.id),
-    type: dto.type,
-    details: dto.details
-  })
-};
-var RequirementStatusInfo = {
-  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(
-    ([id, value]) => typeof value === "string" ? { id: RequirementId(id), status: value, action: null } : {
-      id: RequirementId(id),
-      status: value.status,
-      action: value.action ?? null,
-      kycLevel: value.kyc_level,
-      kycReset: value.kyc_reset
-    }
-  )
-};
-
-// src/universal/api/frontline/requirements.ts
-async function fetchOfferRequirements(api, offerId, clientCreds) {
-  const response = await api.send({
-    method: "GET",
-    url: `/v1/offers/${offerId}/requirements`,
-    attributes: Attributes.concat(
-      Attributes.protected(),
-      Attributes.clientCredentials(clientCreds)
-    )
-  });
-  return Object.fromEntries(
-    Object.entries(response.options).map(([optionId, list]) => [
-      optionId,
-      list.data.map(Requirement.fromDto)
-    ])
-  );
-}
-async function fetchRequirementStatuses(api, offerId) {
-  const response = await api.send({
-    method: "GET",
-    url: `/v1/offers/${offerId}/requirements/statuses`,
-    attributes: Attributes.protected()
-  });
-  return RequirementStatusInfo.fromStatusesDto(response);
-}
-
-// src/universal/core/requirements/requirements-namespace.ts
-var RequirementsNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    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/api/rpc/erc20.ts
-async function getTokenAllowance(clients, params) {
-  const allowance = await clients(params.chain).readContract({
-    address: params.tokenAddress,
-    abi: ERC20_ABI,
-    functionName: "allowance",
-    args: [params.owner, params.spender]
-  });
-  return parseUint256(allowance, "allowance");
-}
-async function getTokenBalance(clients, params) {
-  const balance = await clients(params.chain).readContract({
-    address: params.tokenAddress,
-    abi: ERC20_ABI,
-    functionName: "balanceOf",
-    args: [params.owner]
-  });
-  return parseUint256(balance, "balanceOf");
-}
-
-// src/universal/core/shared/blockchain/erc20/erc20-namespace.ts
-var Erc20NamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "ERC20");
-  }
-  async getAllowance(params) {
-    return this.log.wrap(
-      "getAllowance",
-      params,
-      async () => getTokenAllowance(this.ctx.rpc, params)
-    );
-  }
-  async getBalance(params) {
-    return this.log.wrap(
-      "getBalance",
-      params,
-      async () => getTokenBalance(this.ctx.rpc, params)
-    );
-  }
-};
-
-// src/universal/core/tokens/token-registry-snapshot.ts
-var TokenRegistrySnapshot = {
-  /** Indexes a `tokens.list()` result. `[]` is a valid, empty snapshot. */
-  fromTokens: (tokens) => ({
-    tokens,
-    byKey: new Map(
-      tokens.map((token) => [registryKey(token.identifier), token])
-    )
-  }),
-  /**
-   * The registry's entry for one token, or `null` when it lists none. The
-   * registry is curated, so `null` is an ordinary answer rather than an
-   * error, and callers fall back to their own display defaults.
-   */
-  get: (snapshot, token) => snapshot.byKey.get(registryKey(token)) ?? null,
-  /**
-   * The registry's entry for the token an offer is *about*, or `null` when
-   * it lists none of them.
-   *
-   * Resolution follows {@link offerDisplayTokens}: the token a sale
-   * distributes or a swap hands over, never the funding token the user pays
-   * with. An offer deployed on several chains carries one such token per
-   * chain, and the first the registry knows wins - they are the same asset,
-   * so any listed one answers for the offer.
-   */
-  forOffer: (snapshot, offer) => {
-    for (const token of offerDisplayTokens(offer)) {
-      const metadata = TokenRegistrySnapshot.get(snapshot, token);
-      if (metadata !== null) {
-        return metadata;
-      }
-    }
-    return null;
-  }
-};
-function offerDisplayTokens(offer) {
-  const swaps = offer.tokens.filter(
-    (token) => token.role === "swap" || token.role === "vault"
-  );
-  const distributions = offer.tokens.filter(
-    (token) => token.role === "distribution"
-  );
-  return [...swaps, ...distributions];
-}
-function registryKey(token) {
-  return `${token.chain}:${token.address.toLowerCase()}`;
-}
-
-// src/universal/api/nabu/tokens.ts
-var import_viem5 = require("viem");
-
-// src/universal/api/frontline/config.ts
-var HEADER_API_VERSION = "X-API-Version";
-
-// src/universal/api/http-client.ts
-var HttpClient = class {
-  constructor(config, middleware = {}, logger = null, options = {}) {
-    this.config = config;
-    this.middleware = middleware;
-    this.log = internalLogger(logger, "HTTP");
-    this.makeRequestId = options.makeRequestId ?? defaultMakeRequestId;
-  }
-  async send(request) {
-    return this.runRequestWithAfterMiddleware(request);
-  }
-  /**
-   * Runs beforeRequest, executeRequest, then the full afterRequest middleware
-   * chain. Used by send() and by the retry() callback so that when a
-   * middleware calls retry(), the retried response also goes through all
-   * afterRequest middleware (e.g. session renewal, retry). Middleware
-   * must use request.attributes.retryAttempt (or similar) to avoid infinite
-   * recursion when they trigger retries.
-   */
-  async runRequestWithAfterMiddleware(request) {
-    const preparedRequest = await this.runBeforeRequestMiddleware(
-      this.withClientDefaults(request)
-    );
-    let response = await this.executeRequest(preparedRequest);
-    for (const middleware of this.middleware.afterRequest ?? []) {
-      let retried = false;
-      response = await middleware({
-        request: preparedRequest,
-        response,
-        retry: (nextRequest = preparedRequest) => {
-          retried = true;
-          return this.runRequestWithAfterMiddleware(nextRequest);
-        }
-      });
-      if (retried) {
-        return response;
-      }
-    }
-    return response;
-  }
-  withClientDefaults(request) {
-    const url = this.resolveUrl(request.url);
-    const headers = {
-      ...request.headers ?? {},
-      ...this.config.xApiVersion !== void 0 ? { [HEADER_API_VERSION]: this.config.xApiVersion } : {}
-    };
-    return {
-      ...request,
-      url,
-      headers,
-      // Only when absent: a retry or a post-renewal re-send arrives with the
-      // first attempt's id already on it, and keeping it is the whole point.
-      attributes: Attributes.getRequestId(request.attributes) === null ? Attributes.concat(
-        request.attributes ?? Attributes.empty,
-        Attributes.requestId(this.makeRequestId())
-      ) : request.attributes
-    };
-  }
-  /**
-   * Resolves a request URL against the client's baseUrl.
-   *
-   * @internal Public only for testing. Do not use in application code; use
-   * {@link HttpClient.send} with a path and the client will resolve the URL.
-   */
-  resolveUrl(url) {
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return url;
-    }
-    const base2 = this.config.baseUrl.replace(/\/$/, "");
-    const path = url.startsWith("/") ? url : `/${url}`;
-    return base2 + path;
-  }
-  async runBeforeRequestMiddleware(initialRequest) {
-    let request = initialRequest;
-    for (const middleware of this.middleware.beforeRequest ?? []) {
-      request = await middleware(request);
-    }
-    return request;
-  }
-  /**
-   * One physical attempt, logged as one line.
-   *
-   * A non-2xx is a `warn` rather than an `error` because the wire does not
-   * know whether it is a failure: the retry middleware may turn a 503 into a
-   * success, and the token registry reads a 404 as "not listed". The namespace
-   * above decides, and logs the `error` when it does.
-   */
-  async executeRequest(request) {
-    const requestId2 = Attributes.getRequestId(request.attributes);
-    const log = requestId2 === null ? this.log : this.log.child({ requestId: requestId2 });
-    const attempt = Attributes.getRetryAttempt(request.attributes) + 1;
-    const startedAt = Date.now();
-    log.debug(() => ({
-      msg: "request sent",
-      fields: describeRequestUnredacted(request)
-    }));
-    try {
-      const response = await makeRequest(request);
-      const elapsed = Date.now() - startedAt;
-      const outcome = () => ({
-        msg: "request completed",
-        fields: {
-          ...identifyRequest(request),
-          "http.response.status_code": response.status,
-          duration_ms: elapsed,
-          attempt
-        }
-      });
-      if (response.status >= 200 && response.status < 300) {
-        log.info(outcome);
-      } else {
-        log.warn(outcome);
-      }
-      log.debug(() => ({
-        msg: "response received",
-        fields: { body: response.body }
-      }));
-      return requestId2 === null ? response : { ...response, requestId: requestId2 };
-    } catch (error) {
-      const elapsed = Date.now() - startedAt;
-      log.warning(
-        () => ({
-          msg: "request threw",
-          fields: {
-            ...identifyRequest(request),
-            duration_ms: elapsed,
-            attempt
-          }
-        }),
-        error
-      );
-      throw error;
-    }
-  }
-};
-function identifyRequest(request) {
-  const { host, path } = splitUrl(request.url);
-  return {
-    "http.request.method": request.method,
-    "server.address": host,
-    "url.path": path
-  };
-}
-function splitUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return { host: parsed.host, path: parsed.pathname };
-  } catch (_) {
-    return { host: null, path: url };
-  }
-}
-function defaultMakeRequestId() {
-  return Math.random().toString(36).slice(2, 10).padEnd(8, "0");
-}
-function describeRequestUnredacted(request) {
-  return {
-    "http.request.method": request.method,
-    "url.full": buildUrlWithQueryParams(request.url, request.queryParams),
-    headers: request.headers,
-    ...request.method === "POST" ? { body: request.body } : {}
-  };
-}
-
-// src/universal/types/token-metadata.ts
-var TokenLogoUrl = (value) => value;
-var TokenLogo = {
-  /** `baseUrl` is the registry origin; registry URLs are root-relative. */
-  fromDto: (dto, baseUrl) => dto.kind === "VECTOR" ? { kind: "VECTOR", url: resolveLogoUrl(dto.url, baseUrl) } : {
-    kind: "RASTER",
-    original: logoImageFromDto(dto.original, baseUrl),
-    variants: dto.variants.map((v) => logoImageFromDto(v, baseUrl))
-  }
-};
-var TokenMetadata = {
-  /** `baseUrl` is the registry origin; registry logo URLs are root-relative. */
-  fromDto: (dto, baseUrl) => {
-    assertSupportedSchemaVersion(dto.schema_version);
-    return {
-      identifier: {
-        chain: EthereumChain(dto.chain),
-        address: EvmContractAddress(dto.address)
-      },
-      name: dto.name,
-      symbol: AssetSymbol(dto.symbol),
-      decimals: AssetDecimals(dto.decimals),
-      logo: TokenLogo.fromDto(dto.logo, baseUrl),
-      logoDark: dto.logo_dark === void 0 ? null : TokenLogo.fromDto(dto.logo_dark, baseUrl)
-    };
-  },
-  /**
-   * Maps the complete registry snapshot to every token it lists across the
-   * chains this SDK models, skipping native coins and chains outside
-   * {@link EthereumChain} (e.g. Solana) rather than failing on them — the
-   * registry may serve chains ahead of the SDK's type surface.
-   */
-  fromRegistryDto: (dto, baseUrl) => {
-    assertSupportedSchemaVersion(dto.schema_version);
-    return dto.chains.flatMap((chainDto) => {
-      let chain;
-      try {
-        chain = EthereumChain(chainDto.chain);
-      } catch {
-        return [];
-      }
-      return tokensOfChain(chain, chainDto.assets, baseUrl);
-    });
-  },
-  /**
-   * Maps a chain snapshot to the tokens it lists, skipping the chain's native
-   * coin (`kind: 'COIN'`, no contract address).
-   */
-  fromChainAssetsDto: (dto, baseUrl) => {
-    assertSupportedSchemaVersion(dto.schema_version);
-    return tokensOfChain(EthereumChain(dto.chain), dto.assets, baseUrl);
-  }
-};
-function tokensOfChain(chain, assets, baseUrl) {
-  return assets.filter((asset) => asset.kind === "TOKEN" && asset.address !== void 0).map((asset) => ({
-    identifier: {
-      chain,
-      // The filter above cannot narrow `address` for the type checker.
-      address: EvmContractAddress(asset.address)
-    },
-    name: asset.name,
-    symbol: AssetSymbol(asset.symbol),
-    decimals: AssetDecimals(asset.decimals),
-    logo: TokenLogo.fromDto(asset.logo, baseUrl),
-    logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
-  }));
-}
-function assertSupportedSchemaVersion(version) {
-  if (version !== 1) {
-    throw new ValidationError(
-      `Unsupported token registry schema_version: ${version}`
-    );
-  }
-}
-var logoImageFromDto = (dto, baseUrl) => ({
-  url: resolveLogoUrl(dto.url, baseUrl),
-  width: dto.width,
-  height: dto.height
-});
-var resolveLogoUrl = (url, baseUrl) => TokenLogoUrl(
-  url.startsWith("http") ? url : `${baseUrl.replace(/\/$/, "")}${url}`
-);
-
-// src/universal/api/nabu/tokens.ts
-function createNabuApiClient(baseUrl, logger = null) {
-  return new HttpClient({ baseUrl }, {}, logger);
-}
-async function fetchTokenMetadata(client, token) {
-  const address = checksummed(token.address);
-  let response;
-  try {
-    response = await client.send({
-      method: "GET",
-      url: `/${token.chain}/token/${address}`
-    });
-  } catch (error) {
-    if (isRegistryHtmlFallback(error)) {
-      return null;
-    }
-    throw error;
-  }
-  if (response.status === 404) {
-    return null;
-  }
-  assertOk(response);
-  if (response.body === null) {
-    throw new ValidationError(
-      `Token registry returned an empty body for token "${address}" on "${token.chain}"`
-    );
-  }
-  return TokenMetadata.fromDto(response.body, client.config.baseUrl);
-}
-async function fetchTokensMetadata(client, chain) {
-  let response;
-  try {
-    response = await client.send({
-      method: "GET",
-      url: `/${chain}/assets.json`
-    });
-  } catch (error) {
-    if (isRegistryHtmlFallback(error)) {
-      throw new ValidationError(
-        `Token registry returned non-JSON for the "${chain}" snapshot`
-      );
-    }
-    throw error;
-  }
-  assertOk(response);
-  if (response.body === null) {
-    throw new ValidationError(
-      `Token registry returned an empty "${chain}" snapshot`
-    );
-  }
-  return TokenMetadata.fromChainAssetsDto(response.body, client.config.baseUrl);
-}
-async function fetchAllTokensMetadata(client) {
-  let response;
-  try {
-    response = await client.send({
-      method: "GET",
-      url: `/assets.json`
-    });
-  } catch (error) {
-    if (isRegistryHtmlFallback(error)) {
-      throw new ValidationError(
-        "Token registry returned non-JSON for the complete snapshot"
-      );
-    }
-    throw error;
-  }
-  assertOk(response);
-  if (response.body === null) {
-    throw new ValidationError(
-      "Token registry returned an empty complete snapshot"
-    );
-  }
-  return TokenMetadata.fromRegistryDto(response.body, client.config.baseUrl);
-}
-function isRegistryHtmlFallback(error) {
-  return error instanceof HttpError && error.response.status >= 200 && error.response.status < 300;
-}
-function assertOk(response) {
-  if (response.status < 200 || response.status >= 300) {
-    throw new HttpError(response);
-  }
-}
-function checksummed(address) {
-  try {
-    return (0, import_viem5.getAddress)(address);
-  } catch (_) {
-    throw new ValidationError(`Invalid EVM contract address: "${address}"`);
-  }
-}
-
-// src/universal/core/tokens/tokens-namespace.ts
-var TokensNamespaceImpl = class {
-  /**
-   * Takes the registry origin rather than a `UniversalNamespaceContext`: the
-   * registry is unauthenticated and on its own host, so the frontline sender
-   * and the auth check would both be dead weight here.
-   */
-  constructor(baseUrl, logger = null) {
-    this.api = createNabuApiClient(baseUrl, logger);
-    this.log = internalLogger(logger, "TOKENS");
-  }
-  get(token) {
-    return this.log.wrap(
-      "get",
-      token,
-      () => fetchTokenMetadata(this.api, token)
-    );
-  }
-  list(chain) {
-    return this.log.wrap(
-      "list",
-      chain,
-      () => chain === void 0 ? fetchAllTokensMetadata(this.api) : fetchTokensMetadata(this.api, chain)
-    );
-  }
-};
-
-// 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/blockchain/wallet-error.ts
-var RedactedWalletError = {
-  fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
-};
-
-// src/universal/types/blockchain/wallet-selection.ts
-var WalletSelection = {
-  /**
-   * Every wallet in display order - embedded first, then the external one -
-   * each address once. Addresses compare case-insensitively, so a host that
-   * hands the same wallet over as both embedded and external sees it once.
-   */
-  all: (selection) => {
-    const seen = /* @__PURE__ */ new Set();
-    return [
-      ...selection.embedded,
-      ...selection.external === null ? [] : [selection.external]
-    ].filter((wallet) => {
-      const key = wallet.address.toLowerCase();
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-};
-
-// src/universal/types/oauth-session.ts
-var ClientCredentialsOAuth = (value) => value;
-var OAuthRefreshToken = (value) => value;
-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/types/time.ts
-var MAX_EPOCH_MILLIS = 864e13;
-var EpochMillis = {
-  /**
-   * @throws {@link ValidationError} unless `value` is an integer a `Date` can
-   * represent: at most {@link MAX_EPOCH_MILLIS} either side of the epoch.
-   */
-  of: (value) => {
-    if (!Number.isInteger(value) || Math.abs(value) > MAX_EPOCH_MILLIS) {
-      throw new ValidationError(
-        `EpochMillis must be an integer within \xB1${MAX_EPOCH_MILLIS}, got ${value}`
-      );
-    }
-    return value;
-  },
-  /** The wall clock. Code that needs the time takes a `TimeEff` instead. */
-  now: () => EpochMillis.of(Date.now()),
-  /** @throws {@link ValidationError} for an invalid `Date`. */
-  fromDate: (date) => EpochMillis.of(date.getTime()),
-  /** How long after `from` the instant `to` is; negative if it is before. */
-  elapsed: (from, to) => Millis.of(to - from),
-  plus: (at, duration) => EpochMillis.of(at + duration)
-};
-var Millis = {
-  of: (value) => value
-};
-var Seconds = {
-  /**
-   * @throws {@link ValidationError} unless `value` is a non-negative integer.
-   */
-  of: (value) => {
-    if (!Number.isInteger(value) || value < 0) {
-      throw new ValidationError(
-        `Seconds must be a non-negative integer, got ${value}`
-      );
-    }
-    return value;
-  },
-  toMillis: (value) => Millis.of(value * 1e3)
-};
-function isExpired({
-  expiresAt,
-  now,
-  buffer = Millis.of(0)
-}) {
-  return now >= expiresAt - buffer;
-}
-
-// src/universal/types/user.ts
-var UserId = (value) => value;
-var UserEmail = (value) => value;
-var User = {
-  fromDto: (dto) => ({
-    id: UserId(dto.id),
-    email: UserEmail(dto.email)
-  })
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AllowWalletResponse,
-  Asset,
-  AssetCode,
-  AssetDecimals,
-  AssetIconUrl,
-  AssetId,
-  AssetSymbol,
-  AsyncOfferDetail,
-  AuthorizationCode,
-  BPS_DENOM,
-  Blockchain,
-  BlockchainAmount,
-  Bps,
-  CENTRIFUGE_POLL_INTERVAL_MS,
-  CentrifugeNamespaceImpl,
-  CentrifugeVaultBuyTransaction,
-  CentrifugeVaultClaimProceedsTransaction,
-  CentrifugeVaultClaimTransaction,
-  CentrifugeVaultLeg,
-  CentrifugeVaultLegId,
-  CentrifugeVaultPosition,
-  CentrifugeVaultRedeemPosition,
-  CentrifugeVaultStatus,
-  Chain,
-  ClientCredentialsOAuth,
-  ClientId,
-  ClientSecret,
-  CodeChallenge,
-  CodeVerifier,
-  CoinListTokenSaleNamespaceImpl,
-  ConnectExternalWalletParams,
-  CreateParticipationParams,
-  CreateWalletOwnershipChallengeParams,
-  Cursor,
-  DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
-  DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
-  DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE,
-  DEFAULT_SLIPPAGE_BPS,
-  DecimalString,
-  DocumentSubmission,
-  ERC20_ABI,
-  ETHEREUM_CHAINS,
-  EpochMillis,
-  Erc20NamespaceImpl,
-  EthereumChain,
-  EvmContractAddress,
-  EvmWalletAddress,
-  FaqItem,
-  FormattedAmountAssetUi,
-  FormattedAmountUi,
-  FormattedPercentUi,
-  HexEncodedTransactionData,
-  HttpError,
-  InvariantError,
-  Isin,
-  Iso2CountryCode,
-  KnownAssetSymbol,
-  KycToken,
-  Link,
-  MAX_ASSET_DECIMALS,
-  MAX_UINT_256,
-  MathError,
-  Milestone,
-  Millis,
-  NA_AMOUNT_ASSET_UI,
-  NotAuthenticatedError,
-  NotImplementedError,
-  OAuthRefreshToken,
-  OAuthSession,
-  ONDO_NOT_TRADABLE_CODE,
-  ONDO_POLL_INTERVAL_MS,
-  ONDO_QUOTE_MAX_TTL_MS,
-  ONDO_SETTLEMENT_ASSET,
-  ONDO_SUPPORTED_INPUT_ASSETS,
-  Offer,
-  OfferDetail,
-  OfferEditorial,
-  OfferId,
-  OfferOption,
-  OfferOptionAddress,
-  OfferOptionAddressId,
-  OfferOptionId,
-  OfferOptionSlug,
-  OfferSlug,
-  OfferSwapContract,
-  OfferToken,
-  OfferVaultContract,
-  OffersNamespaceImpl,
-  OndoBuyTransaction,
-  OndoNamespaceImpl,
-  OndoQuote,
-  OndoSellTransaction,
-  OndoTradingStatus,
-  PKCEState,
-  PaginatedResponse,
-  PaginationParams,
-  Participation,
-  ParticipationId,
-  ParticipationsPaginationParams,
-  PauseFlags,
-  Pii,
-  PiiAddress,
-  PiiJurisdiction,
-  RedactedWalletError,
-  RedirectUri,
-  Requirement,
-  RequirementId,
-  RequirementStatusInfo,
-  RequirementsNamespaceImpl,
-  SLIPPAGE_OPTIONS_BPS,
-  SOLANA_CHAINS,
-  STABLE_DECIMALS,
-  SUPERSTATE_ISSUER_NAME,
-  SUPERSTATE_SUPPORTED_INPUT_ASSETS,
-  SUPERSTATE_SWAP_ABI,
-  SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
-  SWAP_LEVEL,
-  SWAP_POLL_INTERVAL_MS,
-  Seconds,
-  ShortenedWalletAddress,
-  SolanaChain,
-  StablecoinSymbol,
-  SuperstateSwapNamespaceImpl,
-  SwapPreview,
-  SwapQuote,
-  SwapStatus,
-  TOKEN_REGISTRY,
-  TermItem,
-  Ticker,
-  TokenLogo,
-  TokenLogoUrl,
-  TokenMetadata,
-  TokenRegistrySnapshot,
-  TokensNamespaceImpl,
-  TxExplorerUrl,
-  USDC,
-  USDC_SYMBOL,
-  USDT,
-  USDT_SYMBOL,
-  User,
-  UserEmail,
-  UserId,
-  ValidationError,
-  WalletAddress,
-  WalletOwnershipChallenge,
-  WalletSelection,
-  WalletsNamespaceImpl,
-  apiErrorCode,
-  applyBps,
-  assertUint256,
-  assetAmount,
-  blockchainAmountFromRawOrThrow,
-  chainFromId,
-  computeOndoBuyPrice,
-  computeOndoSellPrice,
-  computePrice,
-  computeSlip,
-  decodeSwappedOutputAmount,
-  fetchAllPages,
-  formatAmount,
-  formatBpsAsPercent,
-  formatCompactAmount,
-  formatRawAmount,
-  formatShareAmount,
-  formattedPricePerShare,
-  formattedUsdPrice,
-  generatePKCEParams,
-  getChainId,
-  getNetworkName,
-  isChain,
-  isExpired,
-  isOfferType,
-  isOndoNotTradableError,
-  isSwapAvailable,
-  offerDisplayTokens,
-  ondoQuoteOfferDeadline,
-  parseBlockchainAmount,
-  parseUint256,
-  resolveCentrifugeVaults,
-  shortenAddress,
-  superstateSwapContractAddress,
-  swapSpender,
-  txExplorerUrl,
-  usdAmount,
-  viemChain
-});
-//# sourceMappingURL=index.cjs.map