@coinlist-co/react 0.10.1 → 0.11.1-rc.209af8d

package/dist/shared/index.cjs

@@ -32,20 +32,26 @@ __export(shared_exports, {
   Blockchain: () => Blockchain,
   BlockchainAmount: () => BlockchainAmount,
   Bps: () => Bps,
+  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_SLIPPAGE_BPS: () => DEFAULT_SLIPPAGE_BPS,
+  DecimalString: () => DecimalString,
   DocumentSubmission: () => DocumentSubmission,
   ERC20_ABI: () => ERC20_ABI,
+  ETHEREUM_CHAINS: () => ETHEREUM_CHAINS,
   Erc20NamespaceImpl: () => Erc20NamespaceImpl,
+  EthereumChain: () => EthereumChain,
   EvmContractAddress: () => EvmContractAddress,
   EvmWalletAddress: () => EvmWalletAddress,
   FaqItem: () => FaqItem,
@@ -53,10 +59,13 @@ __export(shared_exports, {
   FormattedAmountUi: () => FormattedAmountUi,
   FormattedPercentUi: () => FormattedPercentUi,
   HexEncodedTransactionData: () => HexEncodedTransactionData,
+  HttpError: () => HttpError,
+  InvariantError: () => InvariantError,
   Iso2CountryCode: () => Iso2CountryCode,
   KnownAssetSymbol: () => KnownAssetSymbol,
   KycToken: () => KycToken,
   Link: () => Link,
+  MAX_ASSET_DECIMALS: () => MAX_ASSET_DECIMALS,
   MAX_UINT_256: () => MAX_UINT_256,
   Milestone: () => Milestone,
   NA_AMOUNT_ASSET_UI: () => NA_AMOUNT_ASSET_UI,
@@ -64,6 +73,9 @@ __export(shared_exports, {
   NotImplementedError: () => NotImplementedError,
   OAuthRefreshToken: () => OAuthRefreshToken,
   OAuthSession: () => OAuthSession,
+  ONDO_POLL_INTERVAL_MS: () => ONDO_POLL_INTERVAL_MS,
+  ONDO_QUOTE_EXPIRY_THRESHOLD_MS: () => ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_SUPPORTED_INPUT_ASSETS: () => ONDO_SUPPORTED_INPUT_ASSETS,
   Offer: () => Offer,
   OfferDetail: () => OfferDetail,
   OfferId: () => OfferId,
@@ -73,6 +85,12 @@ __export(shared_exports, {
   OfferOptionId: () => OfferOptionId,
   OfferOptionSlug: () => OfferOptionSlug,
   OfferSlug: () => OfferSlug,
+  OfferToken: () => OfferToken,
+  OffersNamespaceImpl: () => OffersNamespaceImpl,
+  OndoNamespaceImpl: () => OndoNamespaceImpl,
+  OndoQuote: () => OndoQuote,
+  OndoSwapTransaction: () => OndoSwapTransaction,
+  OndoTradingStatus: () => OndoTradingStatus,
   PKCEState: () => PKCEState,
   PaginatedResponse: () => PaginatedResponse,
   PaginationParams: () => PaginationParams,
@@ -82,27 +100,37 @@ __export(shared_exports, {
   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,
-  SUPERSTATE_TOS_URL: () => SUPERSTATE_TOS_URL,
   SWAP_POLL_INTERVAL_MS: () => SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress: () => ShortenedWalletAddress,
+  SolanaChain: () => SolanaChain,
   StablecoinSymbol: () => StablecoinSymbol,
+  SuperstateSwapNamespaceImpl: () => SuperstateSwapNamespaceImpl,
   SwapAuthorization: () => SwapAuthorization,
-  SwapNamespaceImpl: () => SwapNamespaceImpl,
   SwapPreview: () => SwapPreview,
   SwapQuote: () => SwapQuote,
   SwapStatus: () => SwapStatus,
   TOKEN_REGISTRY: () => TOKEN_REGISTRY,
   TermItem: () => TermItem,
+  Ticker: () => Ticker,
   TokenAllowance: () => TokenAllowance,
   TokenBalance: () => TokenBalance,
-  TokenSaleNamespaceImpl: () => TokenSaleNamespaceImpl,
+  TokenLogo: () => TokenLogo,
+  TokenLogoUrl: () => TokenLogoUrl,
+  TokenMetadata: () => TokenMetadata,
+  TokensNamespaceImpl: () => TokensNamespaceImpl,
   TxExplorerUrl: () => TxExplorerUrl,
   USDC: () => USDC,
   USDC_SYMBOL: () => USDC_SYMBOL,
@@ -111,11 +139,17 @@ __export(shared_exports, {
   User: () => User,
   UserEmail: () => UserEmail,
   UserId: () => UserId,
+  ValidationError: () => ValidationError,
   WalletAddress: () => WalletAddress,
   WalletOwnershipChallenge: () => WalletOwnershipChallenge,
+  WalletsNamespaceImpl: () => WalletsNamespaceImpl,
+  apiErrorCode: () => apiErrorCode,
   applyBps: () => applyBps,
   assertUint256: () => assertUint256,
   assetAmount: () => assetAmount,
+  blockchainAmountFromRawOrThrow: () => blockchainAmountFromRawOrThrow,
+  chainFromId: () => chainFromId,
+  computeOndoPrice: () => computeOndoPrice,
   computePrice: () => computePrice,
   computeSlip: () => computeSlip,
   decodeSwappedOutputAmount: () => decodeSwappedOutputAmount,
@@ -130,15 +164,182 @@ __export(shared_exports, {
   getChainId: () => getChainId,
   getNetworkName: () => getNetworkName,
   isStopped: () => isStopped,
+  ondoSwapContractAddress: () => ondoSwapContractAddress,
   parseBlockchainAmount: () => parseBlockchainAmount,
+  parseUint256: () => parseUint256,
   shortenAddress: () => shortenAddress,
+  superstateSwapContractAddress: () => superstateSwapContractAddress,
   txExplorerUrl: () => txExplorerUrl,
   usdAmount: () => usdAmount
 });
 module.exports = __toCommonJS(shared_exports);
 
+// src/shared/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 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 getClientCredentials = (attrs) => attrs?.clientCredentials;
+var Attributes = {
+  empty,
+  concat,
+  concatAll,
+  protected: protectedRequest,
+  isProtected,
+  userAgent,
+  needUserAgent,
+  idempotencyKey,
+  isIdempotent,
+  retryAttempt,
+  getRetryAttempt,
+  renewAttempted,
+  wasRenewAttempted,
+  clientCredentials,
+  getClientCredentials,
+  requestId,
+  getRequestId
+};
+
+// src/shared/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/shared/api/pagination.ts
-var Cursor = (value) => value;
 async function fetchAllPages(fetchPage, baseParams) {
   const items = [];
   let cursor = null;
@@ -153,82 +354,284 @@ async function fetchAllPages(fetchPage, baseParams) {
   } while (cursor);
   return items;
 }
-var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => ({
-    data: dto.data.map(itemMapper),
-    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
-    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
-  })
+
+// src/shared/core/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/shared/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/shared/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/shared/types/errors.ts
+var NotImplementedError = class extends Error {
+  constructor(message = "Not implemented yet") {
+    super(message);
+    this.name = "NotImplementedError";
+  }
 };
-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;
+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";
   }
 };
 
-// src/shared/core/blockchain/abis/erc20.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"
-  },
+// src/shared/types/blockchain/core.ts
+var ETHEREUM_CHAINS = {
+  ethereum_mainnet: true,
+  ethereum_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 Chain = (value) => {
+  if (!Object.keys(ETHEREUM_CHAINS).includes(value) && !Object.keys(SOLANA_CHAINS).includes(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,
   {
-    type: "function",
-    name: "totalSupply",
+    add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
+    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y)
+  }
+);
+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/shared/core/blockchain/bps.ts
+var BPS_DENOM = Bps(10000n);
+function applyBps(amount, bps) {
+  return assertUint256(amount * bps / BPS_DENOM);
+}
+
+// src/shared/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/shared/core/blockchain/chain.ts
+var CHAIN_IDS = {
+  ethereum_mainnet: 1,
+  ethereum_sepolia: 11155111
+};
+function getChainId(chain) {
+  return CHAIN_IDS[chain];
+}
+function chainFromId(chainId) {
+  const chains = Object.keys(CHAIN_IDS);
+  const chain = chains.find((c) => String(CHAIN_IDS[c]) === 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";
+    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";
+    default: {
+      const _exhaustive = chain;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/shared/core/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"
@@ -274,9 +677,1041 @@ var ERC20_ABI = [
     ],
     anonymous: false
   }
-];
+];
+
+// src/shared/types/providers/superstate/swap.ts
+var SwapAuthorization = {
+  fromDto: (dto) => ({
+    authorized: dto.authorized
+  })
+};
+var SwapPreview = {
+  fromDto: (dto) => ({
+    inputAmount: parseUint256(
+      BigInt(dto.pay_input_amount),
+      "SwapPreview.pay_input_amount"
+    ),
+    fee: parseUint256(BigInt(dto.fee), "SwapPreview.fee"),
+    outputAmount: parseUint256(
+      BigInt(dto.receive_output_amount),
+      "SwapPreview.receive_output_amount"
+    )
+  })
+};
+var SwapStatus = {
+  fromDto: (dto) => ({
+    stopped: parseUint256(BigInt(dto.stopped), "SwapStatus.stopped"),
+    swapLevel: parseUint256(BigInt(dto.swap_level), "SwapStatus.swap_level")
+  })
+};
+var TokenAllowance = {
+  fromDto: (dto) => ({
+    allowance: parseUint256(BigInt(dto.allowance), "TokenAllowance.allowance")
+  })
+};
+var TokenBalance = {
+  fromDto: (dto) => ({
+    balance: parseUint256(BigInt(dto.balance), "TokenBalance.balance")
+  })
+};
+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/shared/api/frontline/providers/superstate/swap.ts
+async function getSwapAuthorization(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/wallet/authorized",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress,
+      wallet_address: params.walletAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapAuthorization.fromDto(dto);
+}
+async function getSwapOutputToken(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/output-token",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return toErc20Asset(dto);
+}
+async function getSwapPreview(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/preview",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress,
+      input_token: params.inputToken,
+      amount: params.amount.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapPreview.fromDto(dto);
+}
+async function getSwapStatus(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/status",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapStatus.fromDto(dto);
+}
+async function getTokenAllowance(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/token/allowance",
+    queryParams: {
+      chain: params.chain,
+      token_address: params.tokenAddress,
+      owner: params.owner,
+      spender: params.spender
+    },
+    attributes: Attributes.protected()
+  });
+  return TokenAllowance.fromDto(dto);
+}
+async function getTokenBalance(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/token/balance",
+    queryParams: {
+      chain: params.chain,
+      token_address: params.tokenAddress,
+      owner: params.owner
+    },
+    attributes: Attributes.protected()
+  });
+  return TokenBalance.fromDto(dto);
+}
+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);
+}
+function toErc20Asset(dto) {
+  return {
+    name: dto.name,
+    symbol: AssetSymbol(dto.symbol),
+    decimals: AssetDecimals(dto.decimals)
+  };
+}
+
+// src/shared/core/observability/log-cause.ts
+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 NotAuthenticatedError) {
+    return { type: "not-authenticated" };
+  }
+  if (error instanceof NotImplementedError) {
+    return { type: "not-implemented" };
+  }
+  return { type: "generic-error", name: errorName(error) };
+}
+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/shared/core/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/shared/core/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 () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getTokenAllowance(this.ctx.api, params);
+    });
+  }
+  async getBalance(params) {
+    return this.log.wrap("getBalance", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getTokenBalance(this.ctx.api, params);
+    });
+  }
+};
+
+// src/shared/core/blockchain/formatters.ts
+var import_viem = require("viem");
+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 = maxFractionDigits !== void 0 ? Math.min(maxFractionDigits, amount.decimals) : Math.min(2, amount.decimals);
+  if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
+    ({ integerPart, fractionPart } = roundFractionHalfUp(
+      integerPart,
+      fractionPart,
+      maxFractionDigits
+    ));
+  }
+  const fraction = minFractionDigits === 0 ? "" : fractionPart.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_viem.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 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/shared/core/blockchain/math.ts
+var import_viem2 = require("viem");
+function blockchainAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals
+}) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  let value;
+  try {
+    value = BigInt(trimmed);
+  } catch {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  try {
+    return BlockchainAmount({ raw: assertUint256(value), decimals });
+  } catch {
+    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+  }
+}
+function parseBlockchainAmount(amount, decimals) {
+  const trimmed = amount.trim();
+  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
+  if (trimmed.startsWith("-")) {
+    return { valid: false, reason: { type: "negative" } };
+  }
+  if (/[eE]/.test(trimmed)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const [, fraction = ""] = trimmed.split(".");
+  if (fraction.length > decimals) {
+    return {
+      valid: false,
+      reason: { type: "too-many-decimals", maxDecimals: decimals }
+    };
+  }
+  try {
+    const raw = (0, import_viem2.parseUnits)(trimmed, 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/shared/core/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"
+  )
+};
+var USDT_ADDRESSES = {
+  ethereum_mainnet: EvmContractAddress(
+    "0xdac17f958d2ee523a2206206994597c13d831ec7"
+  ),
+  ethereum_sepolia: EvmContractAddress(
+    "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
+  )
+};
+var TOKEN_REGISTRY = {
+  erc20: (symbol) => {
+    switch (symbol) {
+      case "USDC":
+        return USDC;
+      case "USDT":
+        return USDT;
+      default:
+        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
+    }
+  },
+  contractAddress: (symbol, chain) => {
+    switch (symbol) {
+      case "USDC":
+        return USDC_ADDRESSES[chain];
+      case "USDT":
+        return USDT_ADDRESSES[chain];
+      default:
+        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
+    }
+  }
+};
+
+// src/shared/types/pagination.ts
+var Cursor = (value) => value;
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => ({
+    data: dto.data.map(itemMapper),
+    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/shared/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/shared/types/offer.ts
+var OfferId = (value) => value;
+var OfferSlug = (value) => value;
+var Offer = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.tokens)) {
+      throw new ValidationError(
+        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
+      );
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      type: dto.type,
+      tagline: dto.tagline,
+      bannerUrl: dto.banner_url,
+      logoUrl: dto.logo_url,
+      startsAt: new Date(dto.starts_at),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      tokens: dto.tokens.map(OfferToken.fromDto)
+    };
+  }
+};
+var OfferToken = {
+  fromDto: (dto) => ({
+    role: dto.role,
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  })
+};
+
+// src/shared/types/offer-detail.ts
+var OfferOptionId = (value) => value;
+var OfferOptionSlug = (value) => value;
+var OfferDetail = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.funding_assets)) {
+      throw new ValidationError(
+        `OfferDetail.funding_assets: expected an array, got ${typeof dto.funding_assets}`
+      );
+    }
+    if (!Array.isArray(dto.options)) {
+      throw new ValidationError(
+        `OfferDetail.options: expected an array, got ${typeof dto.options}`
+      );
+    }
+    if (!Array.isArray(dto.terms)) {
+      throw new ValidationError(
+        `OfferDetail.terms: expected an array, got ${typeof dto.terms}`
+      );
+    }
+    if (!Array.isArray(dto.links)) {
+      throw new ValidationError(
+        `OfferDetail.links: expected an array, got ${typeof dto.links}`
+      );
+    }
+    if (!Array.isArray(dto.faqs)) {
+      throw new ValidationError(
+        `OfferDetail.faqs: expected an array, got ${typeof dto.faqs}`
+      );
+    }
+    if (!Array.isArray(dto.milestones)) {
+      throw new ValidationError(
+        `OfferDetail.milestones: expected an array, got ${typeof dto.milestones}`
+      );
+    }
+    if (!Array.isArray(dto.tokens)) {
+      throw new ValidationError(
+        `OfferDetail.tokens: expected an array, got ${typeof dto.tokens}`
+      );
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      type: dto.type,
+      name: dto.name,
+      asset: Asset.fromDto(dto.asset),
+      fundingAssets: dto.funding_assets.map(Asset.fromDto),
+      tokens: dto.tokens.map(OfferToken.fromDto),
+      about: notBlankStringOrNull(dto.about),
+      tagline: dto.tagline,
+      bannerUrl: dto.banner_url,
+      logoUrl: dto.logo_url,
+      category: dto.category,
+      startsAt: new Date(dto.starts_at),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      faqs: dto.faqs.map(FaqItem.fromDto),
+      links: dto.links.map(Link.fromDto),
+      milestones: dto.milestones.map(Milestone.fromDto),
+      options: dto.options.map(OfferOption.fromDto),
+      terms: dto.terms.map(TermItem.fromDto)
+    };
+  }
+};
+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/shared/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/shared/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/shared/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/shared/core/checkout/ondo/constants.ts
+var ONDO_SWAP_CONTRACT_ADDRESSES = {
+  ethereum_sepolia: EvmContractAddress(
+    "0x7014019ed51Edab984a71D30F2707D2dB2316A7A"
+  )
+};
+function ondoSwapContractAddress(chain) {
+  return ONDO_SWAP_CONTRACT_ADDRESSES[chain] ?? null;
+}
+var ONDO_POLL_INTERVAL_MS = 15e3;
+var ONDO_QUOTE_EXPIRY_THRESHOLD_MS = 5e3;
+var DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE = DecimalString("1000");
+var ONDO_SUPPORTED_INPUT_ASSETS = [
+  USDC_SYMBOL
+];
+
+// src/shared/core/checkout/ondo/math.ts
+function computeOndoPrice(transaction) {
+  const { notionalValue, receiveOutputAmount } = transaction;
+  if (receiveOutputAmount.raw <= 0n) {
+    throw new ValidationError(
+      "Ondo price: receiveOutputAmount must be greater than zero"
+    );
+  }
+  const scaled = notionalValue.raw * 10n ** BigInt(receiveOutputAmount.decimals);
+  const raw = scaled / receiveOutputAmount.raw;
+  return BlockchainAmount({
+    raw: assertPriceFits(raw),
+    decimals: notionalValue.decimals
+  });
+}
+function assertPriceFits(raw) {
+  try {
+    return assertUint256(raw);
+  } catch {
+    throw new ValidationError(`Ondo price: out of uint256 bounds (${raw})`);
+  }
+}
+
+// src/shared/types/trading.ts
+var Ticker = (value) => value;
+
+// src/shared/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 decimalOrNull = (value) => value === null ? null : DecimalString(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 OndoSwapTransaction = {
+  fromDto: (dto) => {
+    const inputDecimals = AssetDecimals(dto.pay_input_decimals);
+    const outputDecimals = AssetDecimals(dto.receive_output_decimals);
+    return {
+      tx: {
+        to: EvmContractAddress(dto.to),
+        data: HexEncodedTransactionData(dto.data)
+      },
+      expiresAt: parseExpiresAt(dto.expires_at),
+      payInputAmount: blockchainAmountFromRawOrThrow({
+        label: "pay_input_amount",
+        raw: dto.pay_input_amount,
+        decimals: inputDecimals
+      }),
+      fee: blockchainAmountFromRawOrThrow({
+        label: "fee",
+        raw: dto.fee,
+        decimals: inputDecimals
+      }),
+      notionalValue: blockchainAmountFromRawOrThrow({
+        label: "notional_value",
+        raw: dto.notional_value,
+        decimals: inputDecimals
+      }),
+      receiveOutputAmount: parseReceiveOutputAmount(
+        dto.receive_output_amount,
+        outputDecimals
+      )
+    };
+  }
+};
+function parseReceiveOutputAmount(raw, decimals) {
+  const amount = blockchainAmountFromRawOrThrow({
+    label: "receive_output_amount",
+    raw,
+    decimals
+  });
+  if (amount.raw <= 0n) {
+    throw new ValidationError(
+      `receive_output_amount: must be greater than zero ("${raw}")`
+    );
+  }
+  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/shared/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 buildOndoSwapTransaction(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/ondo/swap/transaction",
+    body: {
+      symbol: params.symbol,
+      chain: params.chain,
+      wallet_address: params.walletAddress,
+      amount: params.amount.raw.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  assertFundingScaleAgrees(dto, params);
+  return OndoSwapTransaction.fromDto(dto);
+}
+function assertFundingScaleAgrees(dto, params) {
+  if (dto.pay_input_decimals !== params.amount.decimals) {
+    throw new ValidationError(
+      `pay_input_decimals: the swap was priced in ${dto.pay_input_decimals} decimals but the order was sized in ${params.amount.decimals}`
+    );
+  }
+}
+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/shared/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 buildSwapTransaction(params) {
+    return this.log.wrap("buildSwapTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildOndoSwapTransaction(this.ctx.api, params);
+    });
+  }
+};
 
-// src/shared/core/blockchain/abis/superstate-swap.ts
+// src/shared/core/checkout/superstate/blockchain/abi.ts
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
@@ -487,272 +1922,36 @@ var SUPERSTATE_SWAP_ABI = [
     type: "error",
     name: "InvalidAmount",
     inputs: []
-  },
-  {
-    type: "error",
-    name: "SwapFailed",
-    inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" }
-    ]
-  }
-];
-
-// src/shared/types/blockchain/core.ts
-var EvmWalletAddress = (value) => value;
-var EvmContractAddress = (value) => value;
-var HexEncodedTransactionData = (value) => value;
-var AssetDecimals = (value) => value;
-var MAX_UINT_256 = 2n ** 256n - 1n;
-var assertUint256 = (value) => {
-  if (value < 0n || value > MAX_UINT_256) {
-    throw new Error(`Value out of uint256 bounds: ${value}`);
-  }
-  return value;
-};
-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)
-  }
-);
-function combineAmounts(a, b, op) {
-  if (a.decimals !== b.decimals) {
-    throw new Error(
-      `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 Error(`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/shared/core/blockchain/bps.ts
-var BPS_DENOM = Bps(10000n);
-function applyBps(amount, bps) {
-  return assertUint256(amount * bps / BPS_DENOM);
-}
-
-// src/shared/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/shared/core/blockchain/chain.ts
-function getChainId(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return 1;
-    case "ethereum_sepolia":
-      return 11155111;
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
-    }
-  }
-}
-function getNetworkName(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return "Ethereum";
-    case "ethereum_sepolia":
-      return "Ethereum 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";
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
-    }
-  }
-}
-
-// src/shared/core/blockchain/formatters.ts
-var import_viem = require("viem");
-
-// src/shared/core/blockchain/swap/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/shared/core/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 = maxFractionDigits !== void 0 ? Math.min(maxFractionDigits, amount.decimals) : Math.min(2, amount.decimals);
-  if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
-    ({ integerPart, fractionPart } = roundFractionHalfUp(
-      integerPart,
-      fractionPart,
-      maxFractionDigits
-    ));
-  }
-  const fraction = minFractionDigits === 0 ? "" : fractionPart.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_viem.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 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 })
-  );
-}
-function formattedPricePerShare(quote, locale) {
-  if (!quote) return NA_AMOUNT_ASSET_UI;
-  return formattedUsdPrice(computePrice(quote), locale);
-}
-
-// src/shared/core/blockchain/math.ts
-var import_viem2 = require("viem");
-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 (!/^\d+(\.\d+)?$/.test(trimmed)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const [, fraction = ""] = trimmed.split(".");
-  if (fraction.length > decimals) {
-    return {
-      valid: false,
-      reason: { type: "too-many-decimals", maxDecimals: decimals }
-    };
-  }
-  try {
-    return {
-      valid: true,
-      amount: BlockchainAmount({
-        raw: (0, import_viem2.parseUnits)(trimmed, decimals),
-        decimals
-      })
-    };
-  } catch {
-    return { valid: false, reason: { type: "invalid-format" } };
+  },
+  {
+    type: "error",
+    name: "SwapFailed",
+    inputs: [
+      { name: "user", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" }
+    ]
   }
-}
+];
 
-// src/shared/core/blockchain/swap/constants.ts
-var SUPERSTATE_TOS_URL = "https://superstate.com/terms";
-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("0x84f8e9a6C9Cc12fe911259372EfCa5582C4ae557");
+// src/shared/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/shared/core/blockchain/swap/quote.ts
+// src/shared/core/checkout/superstate/blockchain/quote.ts
 var SwapQuote = {
   /**
    * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
@@ -772,12 +1971,12 @@ var SwapQuote = {
   })
 };
 
-// src/shared/core/blockchain/swap/status.ts
+// src/shared/core/checkout/superstate/blockchain/status.ts
 function isStopped(status) {
   return (status.stopped & status.swapLevel) !== 0n;
 }
 
-// src/shared/core/blockchain/swap/swapped-event.ts
+// src/shared/core/checkout/superstate/blockchain/swapped-event.ts
 var import_viem3 = require("viem");
 function decodeSwappedOutputAmount(receipt, outputDecimals) {
   try {
@@ -795,420 +1994,658 @@ function decodeSwappedOutputAmount(receipt, outputDecimals) {
   }
 }
 
-// src/shared/core/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"
-  )
-};
-var USDT_ADDRESSES = {
-  ethereum_mainnet: EvmContractAddress(
-    "0xdac17f958d2ee523a2206206994597c13d831ec7"
-  ),
-  ethereum_sepolia: EvmContractAddress(
-    "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
-  )
-};
-var TOKEN_REGISTRY = {
-  erc20: (symbol) => {
-    switch (symbol) {
-      case "USDC":
-        return USDC;
-      case "USDT":
-        return USDT;
-      default:
-        throw new Error(`Unknown asset symbol: ${symbol}`);
-    }
-  },
-  contractAddress: (symbol, chain) => {
-    switch (symbol) {
-      case "USDC":
-        return USDC_ADDRESSES[chain];
-      case "USDT":
-        return USDT_ADDRESSES[chain];
-      default:
-        throw new Error(`Unknown asset symbol: ${symbol}`);
-    }
-  }
+// src/shared/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("0x84f8e9a6C9Cc12fe911259372EfCa5582C4ae557");
+var SUPERSTATE_SWAP_CONTRACT_ADDRESSES = {
+  ethereum_sepolia: SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA
 };
+function superstateSwapContractAddress(chain) {
+  return SUPERSTATE_SWAP_CONTRACT_ADDRESSES[chain] ?? null;
+}
 
-// src/shared/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 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 getClientCredentials = (attrs) => attrs?.clientCredentials;
-var Attributes = {
-  empty,
-  concat,
-  concatAll,
-  protected: protectedRequest,
-  isProtected,
-  userAgent,
-  needUserAgent,
-  idempotencyKey,
-  isIdempotent,
-  retryAttempt,
-  getRetryAttempt,
-  renewAttempted,
-  wasRenewAttempted,
-  clientCredentials,
-  getClientCredentials
-};
+// src/shared/core/checkout/superstate/formatters.ts
+function formattedPricePerShare(quote, locale) {
+  if (!quote) return NA_AMOUNT_ASSET_UI;
+  return formattedUsdPrice(computePrice(quote), locale);
+}
 
-// src/shared/types/swap.ts
-var SwapAuthorization = {
-  fromDto: (dto) => ({
-    authorized: dto.authorized
-  })
-};
-var SwapPreview = {
-  fromDto: (dto) => ({
-    inputAmount: assertUint256(BigInt(dto.pay_input_amount)),
-    fee: assertUint256(BigInt(dto.fee)),
-    outputAmount: assertUint256(BigInt(dto.receive_output_amount))
-  })
-};
-var SwapStatus = {
-  fromDto: (dto) => ({
-    stopped: assertUint256(BigInt(dto.stopped)),
-    swapLevel: assertUint256(BigInt(dto.swap_level))
-  })
-};
-var TokenAllowance = {
-  fromDto: (dto) => ({
-    allowance: assertUint256(BigInt(dto.allowance))
-  })
-};
-var TokenBalance = {
-  fromDto: (dto) => ({
-    balance: assertUint256(BigInt(dto.balance))
-  })
-};
-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/shared/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 () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapAuthorization(this.ctx.api, params);
+    });
+  }
+  async getPreview(params) {
+    return this.log.wrap("getPreview", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapPreview(this.ctx.api, params);
+    });
+  }
+  async getStatus(params) {
+    return this.log.wrap("getStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapStatus(this.ctx.api, params);
+    });
+  }
+  async getOutputToken(params) {
+    return this.log.wrap("getOutputToken", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapOutputToken(this.ctx.api, params);
+    });
+  }
+  async allowWallet(params) {
+    return this.log.wrap("allowWallet", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return allowWallet(this.ctx.api, params);
+    });
   }
 };
 
-// src/shared/api/frontline/swap.ts
-async function getSwapAuthorization(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/wallet/authorized",
-    queryParams: {
-      chain: params.chain,
-      contract_address: params.contractAddress,
-      wallet_address: params.walletAddress
-    },
-    attributes: Attributes.protected()
-  });
-  return SwapAuthorization.fromDto(dto);
-}
-async function getSwapOutputToken(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/swap/output-token",
-    queryParams: {
-      chain: params.chain,
-      contract_address: params.contractAddress
-    },
-    attributes: Attributes.protected()
-  });
-  return toErc20Asset(dto);
-}
-async function getSwapPreview(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/swap/preview",
-    queryParams: {
-      chain: params.chain,
-      contract_address: params.contractAddress,
-      input_token: params.inputToken,
-      amount: params.amount.toString()
-    },
-    attributes: Attributes.protected()
-  });
-  return SwapPreview.fromDto(dto);
+// src/shared/api/frontline/offers.ts
+async function fetchOffers(api, clientCreds) {
+  return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
 }
-async function getSwapStatus(api, params) {
-  const dto = await api.send({
+async function fetchOffersPage(api, params, clientCreds) {
+  const queryParams = PaginationParams.toQueryParams(params);
+  const pageDto = await api.send({
     method: "GET",
-    url: "/v1/swap/status",
-    queryParams: {
-      chain: params.chain,
-      contract_address: params.contractAddress
-    },
-    attributes: Attributes.protected()
+    url: "/v1/offers",
+    queryParams,
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
   });
-  return SwapStatus.fromDto(dto);
+  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
 }
-async function getTokenAllowance(api, params) {
+async function fetchOfferDetails(api, id, clientCreds) {
   const dto = await api.send({
     method: "GET",
-    url: "/v1/token/allowance",
-    queryParams: {
-      chain: params.chain,
-      token_address: params.tokenAddress,
-      owner: params.owner,
-      spender: params.spender
-    },
-    attributes: Attributes.protected()
+    url: `/v1/offers/${id}`,
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
   });
-  return TokenAllowance.fromDto(dto);
+  return OfferDetail.fromDto(dto);
 }
-async function getTokenBalance(api, params) {
+
+// src/shared/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/shared/types/document-submission.ts
+var DocumentSubmission = {
+  fromDto: (dto) => ({
+    status: dto.status,
+    formType: dto.form_type
+  })
+};
+
+// src/shared/api/frontline/documents.ts
+async function submitDocument(api, documentType, fields) {
   const dto = await api.send({
-    method: "GET",
-    url: "/v1/token/balance",
-    queryParams: {
-      chain: params.chain,
-      token_address: params.tokenAddress,
-      owner: params.owner
-    },
+    method: "POST",
+    url: `/v1/documents/${documentType}/submission`,
+    body: fields,
     attributes: Attributes.protected()
   });
-  return TokenBalance.fromDto(dto);
+  return DocumentSubmission.fromDto(dto);
 }
-async function allowWallet(api, params) {
+
+// src/shared/types/kyc.ts
+var KycToken = {
+  fromDto: (dto) => ({
+    token: dto.token
+  })
+};
+
+// src/shared/api/frontline/kyc.ts
+async function createKycToken(api, levelName, reset) {
   const dto = await api.send({
     method: "POST",
-    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
+    url: "/v1/kyc-token",
     body: {
-      wallet_address: params.walletAddress,
-      chain: params.chain,
-      signature: params.signature
+      ...levelName === void 0 ? {} : { level_name: levelName },
+      ...reset === void 0 ? {} : { reset }
     },
     attributes: Attributes.protected()
   });
-  return AllowWalletResponse.fromDto(dto);
-}
-function toErc20Asset(dto) {
-  return {
-    name: dto.name,
-    symbol: AssetSymbol(dto.symbol),
-    decimals: AssetDecimals(dto.decimals)
-  };
+  return KycToken.fromDto(dto);
 }
 
-// src/shared/core/erc20-namespace.ts
-var Erc20NamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  async getTokenAllowance(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getTokenAllowance(this.ctx.api, params);
-  }
-  async getTokenBalance(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getTokenBalance(this.ctx.api, params);
-  }
+// src/shared/types/pii.ts
+var Iso2CountryCode = (value) => value;
+var PiiJurisdiction = {
+  fromDto: (dto) => ({
+    iso2: Iso2CountryCode(dto.iso_2),
+    name: dto.name
+  })
 };
-
-// src/shared/types/asset.ts
-var AssetId = (value) => value;
-var AssetCode = (value) => value;
-var Asset = {
+var PiiAddress = {
   fromDto: (dto) => ({
-    id: AssetId(dto.id),
-    code: AssetCode(dto.code),
-    name: dto.name,
-    fractionalDigits: dto.fractional_digits
+    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/shared/types/offer.ts
-var OfferId = (value) => value;
-var OfferSlug = (value) => value;
-var Offer = {
+// src/shared/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/shared/types/requirement.ts
+var RequirementId = (value) => value;
+var Requirement = {
   fromDto: (dto) => ({
-    id: OfferId(dto.id),
-    slug: OfferSlug(dto.slug),
+    id: RequirementId(dto.id),
     type: dto.type,
-    tagline: dto.tagline,
-    bannerUrl: dto.banner_url,
-    logoUrl: dto.logo_url,
-    startsAt: new Date(dto.starts_at),
-    endsAt: dto.ends_at ? new Date(dto.ends_at) : null
+    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/shared/utils.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
+// src/shared/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)
+    ])
   );
-  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]);
+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/shared/core/requirements/requirements-namespace.ts
+var RequirementsNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "REQUIREMENTS");
   }
-  let base64 = btoa(binary);
-  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
-  if (!padding) {
-    base64 = base64.replace(/=+$/, "");
+  async forOffer(offerId) {
+    return this.log.wrap("forOffer", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOfferRequirements(
+        this.ctx.api,
+        offerId,
+        void 0
+      );
+    });
   }
-  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;
+  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/shared/types/offer-detail.ts
-var OfferOptionId = (value) => value;
-var OfferOptionSlug = (value) => value;
-var OfferDetail = {
-  fromDto: (dto) => {
-    if (!Array.isArray(dto.funding_assets)) {
-      throw new Error(`funding_assets must be an array`);
-    }
-    if (!Array.isArray(dto.options)) {
-      throw new Error(`options must be an array`);
-    }
-    if (!Array.isArray(dto.terms)) {
-      throw new Error(`terms must be an array`);
+// src/shared/api/nabu/tokens.ts
+var import_viem4 = require("viem");
+
+// src/shared/api/frontline/config.ts
+var HEADER_API_VERSION = "X-API-Version";
+
+// src/shared/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 ?? []) {
+      response = await middleware({
+        request: preparedRequest,
+        response,
+        retry: (nextRequest = preparedRequest) => this.runRequestWithAfterMiddleware(nextRequest)
+      });
     }
-    if (!Array.isArray(dto.links)) {
-      throw new Error(`links must be an array`);
+    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;
     }
-    if (!Array.isArray(dto.faqs)) {
-      throw new Error(`faqs must be an array`);
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    const path = url.startsWith("/") ? url : `/${url}`;
+    return base + path;
+  }
+  async runBeforeRequestMiddleware(initialRequest) {
+    let request = initialRequest;
+    for (const middleware of this.middleware.beforeRequest ?? []) {
+      request = await middleware(request);
     }
-    if (!Array.isArray(dto.milestones)) {
-      throw new Error(`milestones must be an array`);
+    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;
     }
-    return {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      type: dto.type,
-      name: dto.name,
-      asset: Asset.fromDto(dto.asset),
-      fundingAssets: dto.funding_assets.map(Asset.fromDto),
-      about: notBlankStringOrNull(dto.about),
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
-      category: dto.category,
-      startsAt: new Date(dto.starts_at),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      faqs: dto.faqs.map(FaqItem.fromDto),
-      links: dto.links.map(Link.fromDto),
-      milestones: dto.milestones.map(Milestone.fromDto),
-      options: dto.options.map(OfferOption.fromDto),
-      terms: dto.terms.map(TermItem.fromDto)
-    };
   }
 };
-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)
-  })
+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/shared/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 TermItem = {
-  fromDto: (dto) => ({
-    key: notBlankStringOrNull(dto.key),
-    value: notBlankStringOrNull(dto.value)
-  })
+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);
+  }
 };
-var Milestone = {
-  fromDto: (dto) => ({
-    name: notBlankStringOrNull(dto.name),
-    schedule: notBlankStringOrNull(dto.schedule),
-    status: dto.status
-  })
+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/shared/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_viem4.getAddress)(address);
+  } catch (_) {
+    throw new ValidationError(`Invalid EVM contract address: "${address}"`);
+  }
+}
+
+// src/shared/core/tokens/tokens-namespace.ts
+var TokensNamespaceImpl = class {
+  /**
+   * Takes the registry origin rather than a `SharedNamespaceContext`: 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/shared/types/offer-option-address.ts
@@ -1282,195 +2719,79 @@ async function createWalletOwnershipChallenge(api, params) {
   });
   return WalletOwnershipChallenge.fromDto(dto);
 }
-
-// src/shared/core/swap-namespace.ts
-var SwapNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  async getAuthorization(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapAuthorization(this.ctx.api, params);
-  }
-  async getPreview(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapPreview(this.ctx.api, params);
-  }
-  async getStatus(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapStatus(this.ctx.api, params);
-  }
-  async getOutputToken(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapOutputToken(this.ctx.api, params);
-  }
-  async requestWalletOwnershipChallenge(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return createWalletOwnershipChallenge(this.ctx.api, params);
-  }
-  async allowWallet(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return allowWallet(this.ctx.api, params);
-  }
-};
-
-// src/shared/types/participation.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/shared/api/frontline/participations.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),
+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 PaginatedResponse.fromDto(pageDto, Participation.fromDto);
+  return OfferOptionAddress.fromDto(dto);
 }
-async function fetchParticipation(api, id) {
-  const dto = await api.send({
+async function listOptionAddresses(api, offerId, offerOptionId) {
+  const { data } = await api.send({
     method: "GET",
-    url: `/v1/participations/${id}`,
+    url: `/v1/offers/${offerId}/addresses`,
+    queryParams: { offer_option_id: offerOptionId },
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  return data.map(OfferOptionAddress.fromDto);
 }
-async function createParticipation(api, params) {
+async function removeOptionAddress(api, offerId, addressId) {
   const dto = await api.send({
-    method: "POST",
-    url: "/v1/participations",
-    body: CreateParticipationParams.toDto(params),
+    method: "DELETE",
+    url: `/v1/offers/${offerId}/addresses/${addressId}`,
     attributes: Attributes.protected()
   });
-  return Participation.fromDto(dto);
+  return OfferOptionAddress.fromDto(dto);
 }
 
-// src/shared/core/token-sale-namespace.ts
-var TokenSaleNamespaceImpl = class {
+// src/shared/core/wallets/wallets-namespace.ts
+var WalletsNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "WALLETS");
   }
-  async fetchParticipations(offerId) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipations(this.ctx.api, offerId);
-  }
-  async fetchParticipationsPage(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipationsPage(this.ctx.api, params);
-  }
-  async fetchParticipation(id) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipation(this.ctx.api, id);
+  async createOwnershipChallenge(params) {
+    return this.log.wrap("createOwnershipChallenge", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createWalletOwnershipChallenge(
+        this.ctx.api,
+        params
+      );
+    });
   }
-  async createParticipation(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return createParticipation(this.ctx.api, params);
+  async connectExternal(params) {
+    return this.log.wrap("connectExternal", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return connectExternalWallet(this.ctx.api, params);
+    });
   }
-};
-
-// src/shared/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/shared/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/shared/types/document-submission.ts
-var DocumentSubmission = {
-  fromDto: (dto) => ({
-    status: dto.status,
-    formType: dto.form_type
-  })
-};
-
-// src/shared/types/errors.ts
-var NotImplementedError = class extends Error {
-  constructor(message = "Not implemented yet") {
-    super(message);
-    this.name = "NotImplementedError";
+  async list(params) {
+    return this.log.wrap("list", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return listOptionAddresses(
+        this.ctx.api,
+        params.offerId,
+        params.offerOptionId
+      );
+    });
   }
-};
-var NotAuthenticatedError = class extends Error {
-  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
-    super(message);
-    this.name = "NotAuthenticatedError";
+  async remove(params) {
+    return this.log.wrap("remove", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return removeOptionAddress(
+        this.ctx.api,
+        params.offerId,
+        params.addressId
+      );
+    });
   }
 };
 
-// src/shared/types/kyc.ts
-var KycToken = {
-  fromDto: (dto) => ({
-    token: dto.token
-  })
+// src/shared/types/blockchain/wallet-error.ts
+var RedactedWalletError = {
+  fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
 };
 
 // src/shared/types/oauth-session.ts
@@ -1489,55 +2810,6 @@ var OAuthSession = {
   }
 };
 
-// src/shared/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/shared/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/shared/types/user.ts
 var UserId = (value) => value;
 var UserEmail = (value) => value;
@@ -1561,20 +2833,26 @@ var User = {
   Blockchain,
   BlockchainAmount,
   Bps,
+  Chain,
   ClientCredentialsOAuth,
   ClientId,
   ClientSecret,
   CodeChallenge,
   CodeVerifier,
+  CoinListTokenSaleNamespaceImpl,
   ConnectExternalWalletParams,
   CreateParticipationParams,
   CreateWalletOwnershipChallengeParams,
   Cursor,
   DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
+  DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
   DEFAULT_SLIPPAGE_BPS,
+  DecimalString,
   DocumentSubmission,
   ERC20_ABI,
+  ETHEREUM_CHAINS,
   Erc20NamespaceImpl,
+  EthereumChain,
   EvmContractAddress,
   EvmWalletAddress,
   FaqItem,
@@ -1582,10 +2860,13 @@ var User = {
   FormattedAmountUi,
   FormattedPercentUi,
   HexEncodedTransactionData,
+  HttpError,
+  InvariantError,
   Iso2CountryCode,
   KnownAssetSymbol,
   KycToken,
   Link,
+  MAX_ASSET_DECIMALS,
   MAX_UINT_256,
   Milestone,
   NA_AMOUNT_ASSET_UI,
@@ -1593,6 +2874,9 @@ var User = {
   NotImplementedError,
   OAuthRefreshToken,
   OAuthSession,
+  ONDO_POLL_INTERVAL_MS,
+  ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_SUPPORTED_INPUT_ASSETS,
   Offer,
   OfferDetail,
   OfferId,
@@ -1602,6 +2886,12 @@ var User = {
   OfferOptionId,
   OfferOptionSlug,
   OfferSlug,
+  OfferToken,
+  OffersNamespaceImpl,
+  OndoNamespaceImpl,
+  OndoQuote,
+  OndoSwapTransaction,
+  OndoTradingStatus,
   PKCEState,
   PaginatedResponse,
   PaginationParams,
@@ -1611,27 +2901,37 @@ var User = {
   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,
-  SUPERSTATE_TOS_URL,
   SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress,
+  SolanaChain,
   StablecoinSymbol,
+  SuperstateSwapNamespaceImpl,
   SwapAuthorization,
-  SwapNamespaceImpl,
   SwapPreview,
   SwapQuote,
   SwapStatus,
   TOKEN_REGISTRY,
   TermItem,
+  Ticker,
   TokenAllowance,
   TokenBalance,
-  TokenSaleNamespaceImpl,
+  TokenLogo,
+  TokenLogoUrl,
+  TokenMetadata,
+  TokensNamespaceImpl,
   TxExplorerUrl,
   USDC,
   USDC_SYMBOL,
@@ -1640,11 +2940,17 @@ var User = {
   User,
   UserEmail,
   UserId,
+  ValidationError,
   WalletAddress,
   WalletOwnershipChallenge,
+  WalletsNamespaceImpl,
+  apiErrorCode,
   applyBps,
   assertUint256,
   assetAmount,
+  blockchainAmountFromRawOrThrow,
+  chainFromId,
+  computeOndoPrice,
   computePrice,
   computeSlip,
   decodeSwappedOutputAmount,
@@ -1659,8 +2965,11 @@ var User = {
   getChainId,
   getNetworkName,
   isStopped,
+  ondoSwapContractAddress,
   parseBlockchainAmount,
+  parseUint256,
   shortenAddress,
+  superstateSwapContractAddress,
   txExplorerUrl,
   usdAmount
 });