@coinlist-co/react 0.5.1 → 0.9.0

package/dist/shared/index.cjs

@@ -20,20 +20,45 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/shared/index.ts
 var shared_exports = {};
 __export(shared_exports, {
+  AllowWalletResponse: () => AllowWalletResponse,
   Asset: () => Asset,
   AssetCode: () => AssetCode,
+  AssetDecimals: () => AssetDecimals,
+  AssetIconUrl: () => AssetIconUrl,
   AssetId: () => AssetId,
+  AssetSymbol: () => AssetSymbol,
   AuthorizationCode: () => AuthorizationCode,
+  BPS_DENOM: () => BPS_DENOM,
   Blockchain: () => Blockchain,
+  BlockchainAmount: () => BlockchainAmount,
+  Bps: () => Bps,
+  ClientCredentialsOAuth: () => ClientCredentialsOAuth,
   ClientId: () => ClientId,
   ClientSecret: () => ClientSecret,
   CodeChallenge: () => CodeChallenge,
   CodeVerifier: () => CodeVerifier,
+  ConnectExternalWalletParams: () => ConnectExternalWalletParams,
   CreateParticipationParams: () => CreateParticipationParams,
+  CreateWalletOwnershipChallengeParams: () => CreateWalletOwnershipChallengeParams,
   Cursor: () => Cursor,
+  DEFAULT_AMOUNT_TO_COMPUTE_PRICE: () => DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
+  DEFAULT_SLIPPAGE_BPS: () => DEFAULT_SLIPPAGE_BPS,
+  DocumentSubmission: () => DocumentSubmission,
+  ERC20_ABI: () => ERC20_ABI,
+  EvmContractAddress: () => EvmContractAddress,
+  EvmWalletAddress: () => EvmWalletAddress,
   FaqItem: () => FaqItem,
+  FormattedAmountAssetUi: () => FormattedAmountAssetUi,
+  FormattedAmountUi: () => FormattedAmountUi,
+  FormattedPercentUi: () => FormattedPercentUi,
+  HexEncodedTransactionData: () => HexEncodedTransactionData,
+  Iso2CountryCode: () => Iso2CountryCode,
+  KnownAssetSymbol: () => KnownAssetSymbol,
+  KycToken: () => KycToken,
   Link: () => Link,
+  MAX_UINT_256: () => MAX_UINT_256,
   Milestone: () => Milestone,
+  NA_AMOUNT_ASSET_UI: () => NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError: () => NotAuthenticatedError,
   NotImplementedError: () => NotImplementedError,
   OAuthRefreshToken: () => OAuthRefreshToken,
@@ -42,24 +67,71 @@ __export(shared_exports, {
   OfferDetail: () => OfferDetail,
   OfferId: () => OfferId,
   OfferOption: () => OfferOption,
+  OfferOptionAddress: () => OfferOptionAddress,
+  OfferOptionAddressId: () => OfferOptionAddressId,
   OfferOptionId: () => OfferOptionId,
   OfferOptionSlug: () => OfferOptionSlug,
   OfferSlug: () => OfferSlug,
+  PKCEState: () => PKCEState,
   PaginatedResponse: () => PaginatedResponse,
   PaginationParams: () => PaginationParams,
   Participation: () => Participation,
   ParticipationId: () => ParticipationId,
   ParticipationsPaginationParams: () => ParticipationsPaginationParams,
+  Pii: () => Pii,
+  PiiAddress: () => PiiAddress,
+  PiiJurisdiction: () => PiiJurisdiction,
   RedirectUri: () => RedirectUri,
   Requirement: () => Requirement,
   RequirementId: () => RequirementId,
   RequirementStatusInfo: () => RequirementStatusInfo,
+  SLIPPAGE_OPTIONS_BPS: () => SLIPPAGE_OPTIONS_BPS,
+  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,
+  StablecoinSymbol: () => StablecoinSymbol,
+  SwapAuthorization: () => SwapAuthorization,
+  SwapNamespaceImpl: () => SwapNamespaceImpl,
+  SwapPreview: () => SwapPreview,
+  SwapQuote: () => SwapQuote,
+  SwapStatus: () => SwapStatus,
+  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
   TermItem: () => TermItem,
+  TokenAllowance: () => TokenAllowance,
+  TokenBalance: () => TokenBalance,
+  TxExplorerUrl: () => TxExplorerUrl,
+  USDC: () => USDC,
+  USDC_SYMBOL: () => USDC_SYMBOL,
+  USDT: () => USDT,
+  USDT_SYMBOL: () => USDT_SYMBOL,
   User: () => User,
   UserEmail: () => UserEmail,
   UserId: () => UserId,
   WalletAddress: () => WalletAddress,
-  fetchAllPages: () => fetchAllPages
+  WalletOwnershipChallenge: () => WalletOwnershipChallenge,
+  applyBps: () => applyBps,
+  assertUint256: () => assertUint256,
+  assetAmount: () => assetAmount,
+  computePrice: () => computePrice,
+  computeSlip: () => computeSlip,
+  decodeSwappedOutputAmount: () => decodeSwappedOutputAmount,
+  fetchAllPages: () => fetchAllPages,
+  formatAmount: () => formatAmount,
+  formatBpsAsPercent: () => formatBpsAsPercent,
+  formatCompactAmount: () => formatCompactAmount,
+  formatRawAmount: () => formatRawAmount,
+  formattedPricePerShare: () => formattedPricePerShare,
+  formattedUsdPrice: () => formattedUsdPrice,
+  generatePKCEParams: () => generatePKCEParams,
+  getChainId: () => getChainId,
+  getNetworkName: () => getNetworkName,
+  isStopped: () => isStopped,
+  parseBlockchainAmount: () => parseBlockchainAmount,
+  shortenAddress: () => shortenAddress,
+  txExplorerUrl: () => txExplorerUrl,
+  usdAmount: () => usdAmount
 });
 module.exports = __toCommonJS(shared_exports);
 
@@ -102,56 +174,919 @@ var PaginationParams = {
   }
 };
 
-// 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/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"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
+// src/shared/core/blockchain/abis/superstate-swap.ts
+var SUPERSTATE_SWAP_ABI = [
+  {
+    type: "function",
+    name: "authorized",
+    inputs: [{ name: "user", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "stopped",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "SWAP_LEVEL",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preview",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Preview",
+        components: [
+          { name: "input", type: "uint256", internalType: "uint256" },
+          { name: "fee", type: "uint256", internalType: "uint256" },
+          { name: "output", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "swap",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" },
+      { name: "slip", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenBalance",
+    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputToken",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputTokenBalance",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          { name: "inputSum", type: "uint256", internalType: "uint256" },
+          { name: "feeSum", type: "uint256", internalType: "uint256" },
+          { name: "outputSum", type: "uint256", internalType: "uint256" },
+          { name: "count", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      { name: "user", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          { name: "inputSum", type: "uint256", internalType: "uint256" },
+          { name: "feeSum", type: "uint256", internalType: "uint256" },
+          { name: "outputSum", type: "uint256", internalType: "uint256" },
+          { name: "count", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setBps",
+    inputs: [{ name: "points", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Swapped",
+    inputs: [
+      { name: "user", type: "address", indexed: true, internalType: "address" },
+      {
+        name: "inputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "outputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "outputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transferred",
+    inputs: [
+      { name: "to", type: "address", indexed: true, internalType: "address" },
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "InvalidAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InsufficientAmount",
+    inputs: []
+  },
+  {
+    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" } };
+  }
+}
+
+// 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/blockchain/swap/quote.ts
+var SwapQuote = {
+  /**
+   * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
+   * input and fee are denominated in the input token; the output in the output
+   * token.
+   */
+  fromPreview: (preview, inputDecimals, outputDecimals) => ({
+    inputTokenAmount: BlockchainAmount({
+      raw: preview.inputAmount,
+      decimals: inputDecimals
+    }),
+    fee: BlockchainAmount({ raw: preview.fee, decimals: inputDecimals }),
+    outputTokenAmount: BlockchainAmount({
+      raw: preview.outputAmount,
+      decimals: outputDecimals
+    })
   })
 };
 
-// src/shared/types/errors.ts
-var NotImplementedError = class extends Error {
-  constructor(message = "Not implemented yet") {
-    super(message);
-    this.name = "NotImplementedError";
+// src/shared/core/blockchain/swap/status.ts
+function isStopped(status) {
+  return (status.stopped & status.swapLevel) !== 0n;
+}
+
+// src/shared/core/blockchain/swap/swapped-event.ts
+var import_viem3 = require("viem");
+function decodeSwappedOutputAmount(receipt, outputDecimals) {
+  try {
+    const [swapped] = (0, import_viem3.parseEventLogs)({
+      abi: SUPERSTATE_SWAP_ABI,
+      eventName: "Swapped",
+      logs: receipt.logs
+    });
+    if (!swapped) return null;
+    const raw = swapped.args.outputAmount;
+    if (raw < 0n || raw > MAX_UINT_256) return null;
+    return BlockchainAmount({ raw, decimals: outputDecimals });
+  } catch {
+    return null;
   }
+}
+
+// src/shared/core/blockchain/token-registry.ts
+var USDC_SYMBOL = StablecoinSymbol("USDC");
+var USDC = {
+  name: "USD Coin",
+  symbol: USDC_SYMBOL,
+  decimals: AssetDecimals(6)
 };
-var NotAuthenticatedError = class extends Error {
-  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
-    super(message);
-    this.name = "NotAuthenticatedError";
+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/types/oauth.ts
-var AuthorizationCode = (value) => value;
-var CodeVerifier = (value) => value;
-var CodeChallenge = (value) => value;
-var RedirectUri = (value) => value;
-var ClientId = (value) => value;
-var ClientSecret = (value) => value;
+// 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/types/oauth-session.ts
-var OAuthRefreshToken = (value) => value;
-var OAuthSession = {
+// 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) => {
-    const expiresAt = new Date(Date.now() + dto.expires_in * 1e3);
-    return {
-      accessToken: {
-        value: dto.access_token,
-        expiresAt
-      },
-      ...dto.refresh_token != null && dto.refresh_token !== "" ? { refreshToken: OAuthRefreshToken(dto.refresh_token) } : void 0
-    };
+    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/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/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/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
+  );
+  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;
@@ -257,6 +1192,188 @@ var Milestone = {
   })
 };
 
+// src/shared/types/offer-option-address.ts
+var OfferOptionAddressId = (value) => value;
+var OfferOptionAddress = {
+  /** Maps the API DTO into the SDK offer-option-address domain model. */
+  fromDto: (dto) => ({
+    id: OfferOptionAddressId(dto.id),
+    offerOptionId: OfferOptionId(dto.offer_option_id),
+    address: EvmWalletAddress(dto.address),
+    protocol: dto.protocol,
+    createdAt: new Date(dto.created_at)
+  })
+};
+var ConnectExternalWalletParams = {
+  /** Maps connect-wallet params into the API DTO payload. */
+  toDto: (params) => ({
+    offer_option_id: params.offerOptionId,
+    wallet_address: params.walletAddress,
+    chain: params.chain,
+    signature: params.signature
+  })
+};
+
+// src/shared/types/wallet-ownership-challenge.ts
+var WalletOwnershipChallenge = {
+  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
+  fromDto: (dto) => ({
+    message: dto.message,
+    expiresAt: new Date(dto.expires_at)
+  })
+};
+var CreateWalletOwnershipChallengeParams = {
+  /**
+   * Maps challenge-request params into the API DTO payload. The discriminated
+   * union guarantees SIWE fields are present exactly when `challengeType` is
+   * `siwe`, so the mapping narrows on the discriminant.
+   */
+  toDto: (params) => {
+    switch (params.challengeType) {
+      case "plain":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "plain"
+        };
+      case "siwe":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "siwe",
+          domain: params.domain,
+          uri: params.uri,
+          statement: params.statement
+        };
+      default: {
+        const _exhaustive = params;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/shared/api/frontline/wallet-connect.ts
+async function createWalletOwnershipChallenge(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/wallet-ownership",
+    body: CreateWalletOwnershipChallengeParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return WalletOwnershipChallenge.fromDto(dto);
+}
+
+// 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 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);
+  }
+  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/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";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+
+// src/shared/types/kyc.ts
+var KycToken = {
+  fromDto: (dto) => ({
+    token: dto.token
+  })
+};
+
+// src/shared/types/oauth-session.ts
+var ClientCredentialsOAuth = (value) => value;
+var OAuthRefreshToken = (value) => value;
+var OAuthSession = {
+  fromDto: (dto) => {
+    const expiresAt = new Date(Date.now() + dto.expires_in * 1e3);
+    return {
+      accessToken: {
+        value: dto.access_token,
+        expiresAt
+      },
+      ...dto.refresh_token != null && dto.refresh_token !== "" ? { refreshToken: OAuthRefreshToken(dto.refresh_token) } : void 0
+    };
+  }
+};
+
 // src/shared/types/participation.ts
 var ParticipationId = (value) => value;
 var Blockchain = (value) => value;
@@ -304,6 +1421,34 @@ var CreateParticipationParams = {
   })
 };
 
+// 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 = {
@@ -314,10 +1459,15 @@ var Requirement = {
   })
 };
 var RequirementStatusInfo = {
-  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(([id, status]) => ({
-    id: RequirementId(id),
-    status
-  }))
+  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
@@ -331,20 +1481,45 @@ var User = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AllowWalletResponse,
   Asset,
   AssetCode,
+  AssetDecimals,
+  AssetIconUrl,
   AssetId,
+  AssetSymbol,
   AuthorizationCode,
+  BPS_DENOM,
   Blockchain,
+  BlockchainAmount,
+  Bps,
+  ClientCredentialsOAuth,
   ClientId,
   ClientSecret,
   CodeChallenge,
   CodeVerifier,
+  ConnectExternalWalletParams,
   CreateParticipationParams,
+  CreateWalletOwnershipChallengeParams,
   Cursor,
+  DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
+  DEFAULT_SLIPPAGE_BPS,
+  DocumentSubmission,
+  ERC20_ABI,
+  EvmContractAddress,
+  EvmWalletAddress,
   FaqItem,
+  FormattedAmountAssetUi,
+  FormattedAmountUi,
+  FormattedPercentUi,
+  HexEncodedTransactionData,
+  Iso2CountryCode,
+  KnownAssetSymbol,
+  KycToken,
   Link,
+  MAX_UINT_256,
   Milestone,
+  NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError,
   NotImplementedError,
   OAuthRefreshToken,
@@ -353,23 +1528,70 @@ var User = {
   OfferDetail,
   OfferId,
   OfferOption,
+  OfferOptionAddress,
+  OfferOptionAddressId,
   OfferOptionId,
   OfferOptionSlug,
   OfferSlug,
+  PKCEState,
   PaginatedResponse,
   PaginationParams,
   Participation,
   ParticipationId,
   ParticipationsPaginationParams,
+  Pii,
+  PiiAddress,
+  PiiJurisdiction,
   RedirectUri,
   Requirement,
   RequirementId,
   RequirementStatusInfo,
+  SLIPPAGE_OPTIONS_BPS,
+  SUPERSTATE_SWAP_ABI,
+  SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
+  SUPERSTATE_TOS_URL,
+  SWAP_POLL_INTERVAL_MS,
+  ShortenedWalletAddress,
+  StablecoinSymbol,
+  SwapAuthorization,
+  SwapNamespaceImpl,
+  SwapPreview,
+  SwapQuote,
+  SwapStatus,
+  TOKEN_REGISTRY,
   TermItem,
+  TokenAllowance,
+  TokenBalance,
+  TxExplorerUrl,
+  USDC,
+  USDC_SYMBOL,
+  USDT,
+  USDT_SYMBOL,
   User,
   UserEmail,
   UserId,
   WalletAddress,
-  fetchAllPages
+  WalletOwnershipChallenge,
+  applyBps,
+  assertUint256,
+  assetAmount,
+  computePrice,
+  computeSlip,
+  decodeSwappedOutputAmount,
+  fetchAllPages,
+  formatAmount,
+  formatBpsAsPercent,
+  formatCompactAmount,
+  formatRawAmount,
+  formattedPricePerShare,
+  formattedUsdPrice,
+  generatePKCEParams,
+  getChainId,
+  getNetworkName,
+  isStopped,
+  parseBlockchainAmount,
+  shortenAddress,
+  txExplorerUrl,
+  usdAmount
 });
 //# sourceMappingURL=index.cjs.map