@coinlist-co/react 0.12.1-rc.73e7e17 → 0.12.1-rc.9aec85a

package/dist/universal/index.cjs

@@ -77,11 +77,12 @@ __export(universal_exports, {
   OAuthRefreshToken: () => OAuthRefreshToken,
   OAuthSession: () => OAuthSession,
   ONDO_POLL_INTERVAL_MS: () => ONDO_POLL_INTERVAL_MS,
-  ONDO_QUOTE_EXPIRY_THRESHOLD_MS: () => ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_QUOTE_MAX_TTL_MS: () => ONDO_QUOTE_MAX_TTL_MS,
   ONDO_SETTLEMENT_ASSET: () => ONDO_SETTLEMENT_ASSET,
   ONDO_SUPPORTED_INPUT_ASSETS: () => ONDO_SUPPORTED_INPUT_ASSETS,
   Offer: () => Offer,
   OfferDetail: () => OfferDetail,
+  OfferEditorial: () => OfferEditorial,
   OfferId: () => OfferId,
   OfferOption: () => OfferOption,
   OfferOptionAddress: () => OfferOptionAddress,
@@ -103,6 +104,7 @@ __export(universal_exports, {
   Participation: () => Participation,
   ParticipationId: () => ParticipationId,
   ParticipationsPaginationParams: () => ParticipationsPaginationParams,
+  PauseFlags: () => PauseFlags,
   Pii: () => Pii,
   PiiAddress: () => PiiAddress,
   PiiJurisdiction: () => PiiJurisdiction,
@@ -119,23 +121,22 @@ __export(universal_exports, {
   SUPERSTATE_SUPPORTED_INPUT_ASSETS: () => SUPERSTATE_SUPPORTED_INPUT_ASSETS,
   SUPERSTATE_SWAP_ABI: () => SUPERSTATE_SWAP_ABI,
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA: () => SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
+  SWAP_LEVEL: () => SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS: () => SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress: () => ShortenedWalletAddress,
   SolanaChain: () => SolanaChain,
   StablecoinSymbol: () => StablecoinSymbol,
   SuperstateSwapNamespaceImpl: () => SuperstateSwapNamespaceImpl,
-  SwapAuthorization: () => SwapAuthorization,
   SwapPreview: () => SwapPreview,
   SwapQuote: () => SwapQuote,
   SwapStatus: () => SwapStatus,
   TOKEN_REGISTRY: () => TOKEN_REGISTRY,
   TermItem: () => TermItem,
   Ticker: () => Ticker,
-  TokenAllowance: () => TokenAllowance,
-  TokenBalance: () => TokenBalance,
   TokenLogo: () => TokenLogo,
   TokenLogoUrl: () => TokenLogoUrl,
   TokenMetadata: () => TokenMetadata,
+  TokenRegistrySnapshot: () => TokenRegistrySnapshot,
   TokensNamespaceImpl: () => TokensNamespaceImpl,
   TxExplorerUrl: () => TxExplorerUrl,
   USDC: () => USDC,
@@ -171,14 +172,18 @@ __export(universal_exports, {
   getChainId: () => getChainId,
   getNetworkName: () => getNetworkName,
   isChain: () => isChain,
-  isStopped: () => isStopped,
+  isOfferType: () => isOfferType,
+  isSwapAvailable: () => isSwapAvailable,
+  offerDisplayTokens: () => offerDisplayTokens,
+  ondoQuoteOfferDeadline: () => ondoQuoteOfferDeadline,
   parseBlockchainAmount: () => parseBlockchainAmount,
   parseUint256: () => parseUint256,
   shortenAddress: () => shortenAddress,
   superstateSwapContractAddress: () => superstateSwapContractAddress,
   swapSpender: () => swapSpender,
   txExplorerUrl: () => txExplorerUrl,
-  usdAmount: () => usdAmount
+  usdAmount: () => usdAmount,
+  viemChain: () => viemChain
 });
 module.exports = __toCommonJS(universal_exports);
 
@@ -428,8 +433,15 @@ async function generatePKCEParams(config) {
 // src/universal/types/pagination.ts
 var Cursor = (value) => value;
 var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => ({
-    data: dto.data.map(itemMapper),
+  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
+  /**
+   * For a mapper that decides the page as a whole - one that drops items it
+   * cannot map, such as `Offer.listFromDto` - rather than item by item. The
+   * cursors are the wire's either way: dropping an item changes what the
+   * page holds, not where the next page starts.
+   */
+  fromDtoPage: (dto, pageMapper) => ({
+    data: pageMapper(dto.data),
     startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
     startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
   })
@@ -494,6 +506,40 @@ var MathError = class extends Error {
   }
 };
 
+// src/universal/core/shared/utils/wire.ts
+function unknownTypeError(dto, model) {
+  const type = dto.type;
+  throw new ValidationError(
+    `${model}.type: unknown type ${JSON.stringify(type)}`
+  );
+}
+function requiredString(value, field) {
+  const text = notBlankStringOrNull(value);
+  if (text === null) {
+    throw new ValidationError(
+      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
+    );
+  }
+  return text;
+}
+function requiredDate(value, field) {
+  const date = typeof value === "string" ? new Date(value) : null;
+  if (date === null || Number.isNaN(date.getTime())) {
+    throw new ValidationError(
+      `${field}: expected a date, got ${JSON.stringify(value)}`
+    );
+  }
+  return date;
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(
+      `${field}: expected an array, got ${typeof value}`
+    );
+  }
+  return value;
+}
+
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -594,25 +640,69 @@ var Bps = (value) => value;
 // src/universal/types/offer.ts
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
+var OFFER_TYPES = {
+  "coinlist::token_sale": true,
+  "superstate::swap": true,
+  "ondo::swap": true
+};
+var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
+var OfferEditorial = {
+  /**
+   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+   * the same three checks name the payload that failed them.
+   */
+  fromDto: (dto, model) => ({
+    tagline: requiredString(dto.tagline, `${model}.tagline`),
+    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
+    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
+  })
+};
 var Offer = {
   fromDto: (dto) => {
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    return {
+    const tokens = requiredArray(dto.tokens, "Offer.tokens");
+    const base2 = {
       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: OfferToken.listFromDto(dto.tokens)
+      tokens: OfferToken.listFromDto(tokens)
     };
-  }
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire: copying them would hand every consumer a `startsAt` that
+      // is 1970 for one variant and a date for the others.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      default:
+        return unknownTypeError(dto, "Offer");
+    }
+  },
+  /**
+   * Maps a page of offers, dropping every offer whose `type` this SDK does not
+   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+   * reject the whole page, so one offer of an unknown type would blank the
+   * grid for every offer beside it. A single offer fetched by id still
+   * throws, because there is nothing beside it to keep.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
 };
 var OfferToken = {
   fromDto: (dto) => ({
@@ -649,76 +739,69 @@ var OfferSwapContract = {
 };
 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}`
-      );
-    }
-    const swapContracts = dto.swap_contracts === void 0 ? [] : dto.swap_contracts;
-    if (!Array.isArray(swapContracts)) {
-      throw new ValidationError(
-        `OfferDetail.swap_contracts: expected an array, got ${typeof swapContracts}`
-      );
-    }
+    const fundingAssets = requiredArray(
+      dto.funding_assets,
+      "OfferDetail.funding_assets"
+    );
+    const options = requiredArray(dto.options, "OfferDetail.options");
+    const terms = requiredArray(dto.terms, "OfferDetail.terms");
+    const links = requiredArray(dto.links, "OfferDetail.links");
+    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
+    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
+    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
     const isin = notBlankStringOrNull(dto.isin);
     const ticker = notBlankStringOrNull(dto.ticker);
-    return {
+    const base2 = {
       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: OfferToken.listFromDto(dto.tokens),
-      swapContracts: swapContracts.map(OfferSwapContract.fromDto),
+      fundingAssets: fundingAssets.map(Asset.fromDto),
+      tokens: OfferToken.listFromDto(tokens),
       about: notBlankStringOrNull(dto.about),
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
       category: dto.category,
       issuer: notBlankStringOrNull(dto.issuer),
       isin: isin === null ? null : Isin(isin),
       ticker: ticker === null ? null : Ticker(ticker),
       instrumentType: notBlankStringOrNull(dto.instrument_type),
       listingVenue: notBlankStringOrNull(dto.listing_venue),
-      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)
+      faqs: faqs.map(FaqItem.fromDto),
+      links: links.map(Link.fromDto),
+      milestones: milestones.map(Milestone.fromDto),
+      options: options.map(OfferOption.fromDto),
+      terms: terms.map(TermItem.fromDto)
     };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire, as in `Offer.fromDto`.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          swapContracts: requiredArray(
+            dto.swap_contracts,
+            "OfferDetail.swap_contracts"
+          ).map(OfferSwapContract.fromDto)
+        };
+      default:
+        return unknownTypeError(dto, "OfferDetail");
+    }
   }
 };
 var OfferOption = {
@@ -841,6 +924,7 @@ async function createParticipation(api, params) {
 }
 
 // src/universal/core/shared/observability/log-cause.ts
+var import_viem = require("viem");
 function classifyLogCause(error) {
   if (error instanceof HttpError) {
     return httpCause(error);
@@ -860,8 +944,32 @@ function classifyLogCause(error) {
   if (error instanceof NotImplementedError) {
     return { type: "not-implemented" };
   }
+  if (error instanceof import_viem.BaseError) {
+    const http = error.walk((e) => e instanceof HttpError);
+    if (http instanceof HttpError) {
+      return httpCause(http);
+    }
+    return { type: "rpc", reason: rpcFailureReason(error) };
+  }
   return { type: "generic-error", name: errorName(error) };
 }
+function rpcFailureReason(error) {
+  if (error.walk((e) => e instanceof import_viem.ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof import_viem.RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof import_viem.HttpRequestError || e instanceof import_viem.WebSocketRequestError || e instanceof import_viem.SocketClosedError || e instanceof import_viem.TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof import_viem.ContractFunctionExecutionError) {
+    return "malformed-response";
+  }
+  return "unknown";
+}
 function describeErrorUnredacted(error) {
   if (error instanceof HttpError) {
     return describeHttpErrorRedacted(error);
@@ -1086,7 +1194,7 @@ var TOKEN_REGISTRY = {
 
 // src/universal/core/checkout/ondo/constants.ts
 var ONDO_POLL_INTERVAL_MS = 15e3;
-var ONDO_QUOTE_EXPIRY_THRESHOLD_MS = 5e3;
+var ONDO_QUOTE_MAX_TTL_MS = 15e3;
 var DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE = DecimalString("1000");
 var ONDO_SETTLEMENT_ASSET = USDC_SYMBOL;
 var DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE = 1;
@@ -1109,6 +1217,9 @@ function computeOndoSellPrice(transaction) {
     shares: spendInputAmount
   });
 }
+function ondoQuoteOfferDeadline(expiresAt, nowMs = Date.now()) {
+  return new Date(Math.min(expiresAt.getTime(), nowMs + ONDO_QUOTE_MAX_TTL_MS));
+}
 function grossProceeds(expected) {
   const raw = expected.quantity.raw + expected.fee.raw;
   if (raw > MAX_UINT_256) {
@@ -1135,7 +1246,7 @@ function assertPriceFits(raw) {
 }
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem = require("viem");
+var import_viem2 = require("viem");
 
 // src/universal/types/blockchain/ui.ts
 var FormattedAmountUi = (value) => value;
@@ -1201,7 +1312,7 @@ function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
   };
 }
 function formatRawAmount(amount) {
-  return (0, import_viem.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem2.formatUnits)(amount.raw, amount.decimals);
 }
 function formatCompactAmount(amount, locale) {
   const value = Number(formatRawAmount(amount));
@@ -1240,18 +1351,22 @@ function formattedUsdPrice(amount, locale) {
 }
 
 // src/universal/core/shared/blockchain/chain.ts
-var CHAIN_IDS = {
-  ethereum_mainnet: 1,
-  ethereum_sepolia: 11155111,
-  base_mainnet: 8453,
-  base_sepolia: 84532
+var import_chains = require("viem/chains");
+var VIEM_CHAINS = {
+  ethereum_mainnet: import_chains.mainnet,
+  ethereum_sepolia: import_chains.sepolia,
+  base_mainnet: import_chains.base,
+  base_sepolia: import_chains.baseSepolia
 };
+function viemChain(chain) {
+  return VIEM_CHAINS[chain];
+}
 function getChainId(chain) {
-  return CHAIN_IDS[chain];
+  return VIEM_CHAINS[chain].id;
 }
 function chainFromId(chainId) {
-  const chains = Object.keys(CHAIN_IDS);
-  const chain = chains.find((c) => String(CHAIN_IDS[c]) === chainId);
+  const chains = Object.keys(VIEM_CHAINS);
+  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
   if (!chain) {
     throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
   }
@@ -1294,7 +1409,7 @@ function explorerBaseUrl(chain) {
 }
 
 // src/universal/core/shared/blockchain/math.ts
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 function blockchainAmountFromRawOrThrow({
   label,
   raw,
@@ -1325,10 +1440,14 @@ function parseBlockchainAmount(amount, decimals) {
   if (/[eE]/.test(trimmed)) {
     return { valid: false, reason: { type: "invalid-format" } };
   }
-  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+  if (trimmed === ".") {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
+  if (!/^\d+(\.\d+)?$/.test(normalised)) {
     return { valid: false, reason: { type: "invalid-format" } };
   }
-  const [, fraction = ""] = trimmed.split(".");
+  const [, fraction = ""] = normalised.split(".");
   if (fraction.length > decimals) {
     return {
       valid: false,
@@ -1336,7 +1455,7 @@ function parseBlockchainAmount(amount, decimals) {
     };
   }
   try {
-    const raw = (0, import_viem2.parseUnits)(trimmed, decimals);
+    const raw = (0, import_viem3.parseUnits)(normalised, decimals);
     if (raw > MAX_UINT_256) {
       return { valid: false, reason: { type: "overflow" } };
     }
@@ -1646,190 +1765,796 @@ var OndoNamespaceImpl = class {
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
-    name: "authorized",
-    inputs: [{ name: "user", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    name: "KIND",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "stopped",
+    name: "ONE_HUNDRED_P",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
     name: "SWAP_LEVEL",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "preview",
-    inputs: [
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
-    ],
+    name: "VERSION",
+    inputs: [],
     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" }
-        ]
+        type: "uint16",
+        internalType: "uint16"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "swap",
+    name: "authorized",
     inputs: [
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" },
-      { name: "slip", type: "uint256", internalType: "uint256" }
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
     ],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
-    stateMutability: "nonpayable"
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
   },
   {
     type: "function",
-    name: "tokenBalance",
-    inputs: [{ name: "token", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    name: "bpp",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "outputToken",
+    name: "bps",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "outputTokenBalance",
+    name: "cancelOwnershipHandover",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
-    stateMutability: "view"
+    outputs: [],
+    stateMutability: "payable"
   },
   {
     type: "function",
-    name: "totals",
-    inputs: [{ name: "token", type: "address", internalType: "address" }],
-    outputs: [
+    name: "completeOwnershipHandover",
+    inputs: [
       {
-        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" }
-        ]
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
       }
     ],
-    stateMutability: "view"
+    outputs: [],
+    stateMutability: "payable"
   },
   {
     type: "function",
-    name: "totals",
+    name: "fee",
     inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" }
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
     ],
     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" }
-        ]
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "to", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
+    name: "id",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    stateMutability: "view"
   },
   {
     type: "function",
-    name: "transfer",
+    name: "inputTokens",
     inputs: [
-      { name: "to", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
   },
   {
     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",
+    inputs: [],
+    outputs: [
       {
-        name: "outputToken",
+        name: "",
         type: "address",
-        indexed: true,
         internalType: "address"
-      },
-      {
-        name: "inputAmount",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      },
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputTokenBalance",
+    inputs: [],
+    outputs: [
       {
-        name: "outputAmount",
+        name: "",
         type: "uint256",
-        indexed: false,
         internalType: "uint256"
       }
     ],
-    anonymous: false
+    stateMutability: "view"
   },
   {
-    type: "event",
-    name: "Transferred",
-    inputs: [
-      { name: "to", type: "address", indexed: true, internalType: "address" },
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
       {
-        name: "token",
+        name: "result",
         type: "address",
-        indexed: true,
         internalType: "address"
-      },
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownershipHandoverExpiresAt",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "result",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pause",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preview",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Preview",
+        components: [
+          {
+            name: "input",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "fee",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "output",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "requestOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "setBps",
+    inputs: [
+      {
+        name: "points",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setInputToken",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "val",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "status",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Status",
+        components: [
+          {
+            name: "flags",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "state",
+            type: "uint8",
+            internalType: "enum State"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "stop",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "stopped",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "swap",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "slip",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenBalance",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      {
+        name: "newOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "event",
+    name: "BpsUpdated",
+    inputs: [
+      {
+        name: "prev",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "next",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "InputTokenUpdated",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "prev",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      },
+      {
+        name: "next",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverCanceled",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverRequested",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "oldOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Paused",
+    inputs: [
+      {
+        name: "previous",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      },
+      {
+        name: "next",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Stopped",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Swapped",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "outputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "outputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transferred",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
       {
         name: "amount",
         type: "uint256",
@@ -1841,7 +2566,7 @@ var SUPERSTATE_SWAP_ABI = [
   },
   {
     type: "error",
-    name: "InvalidAddress",
+    name: "AlreadyInitialized",
     inputs: []
   },
   {
@@ -1849,18 +2574,62 @@ var SUPERSTATE_SWAP_ABI = [
     name: "InsufficientAmount",
     inputs: []
   },
+  {
+    type: "error",
+    name: "InvalidAddress",
+    inputs: []
+  },
   {
     type: "error",
     name: "InvalidAmount",
     inputs: []
   },
+  {
+    type: "error",
+    name: "IsPaused",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "IsStopped",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NewOwnerIsZeroAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NoHandoverRequest",
+    inputs: []
+  },
   {
     type: "error",
     name: "SwapFailed",
     inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" }
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
     ]
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
   }
 ];
 
@@ -1909,15 +2678,27 @@ var SwapQuote = {
 };
 
 // src/universal/core/checkout/superstate/blockchain/status.ts
-function isStopped(status) {
-  return (status.stopped & status.swapLevel) !== 0n;
+var SWAP_LEVEL = 2;
+function isSwapAvailable(status) {
+  switch (status.state) {
+    case "active":
+      return true;
+    case "stopped":
+      return false;
+    case "paused":
+      return (status.pausedLevels & SWAP_LEVEL) === 0;
+    default: {
+      const _exhaustive = status;
+      return _exhaustive;
+    }
+  }
 }
 
 // src/universal/core/checkout/superstate/blockchain/swapped-event.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 function decodeSwappedOutputAmount(receipt, outputDecimals) {
   try {
-    const [swapped] = (0, import_viem3.parseEventLogs)({
+    const [swapped] = (0, import_viem4.parseEventLogs)({
       abi: SUPERSTATE_SWAP_ABI,
       eventName: "Swapped",
       logs: receipt.logs
@@ -1940,7 +2721,7 @@ 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_ADDRESS_SEPOLIA = EvmContractAddress("0x27E8CE9Ca1A1E98Bc4009F08Dc596bFcf88aCED1");
 var SUPERSTATE_SWAP_CONTRACT_ADDRESSES = {
   ethereum_sepolia: SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA
 };
@@ -1955,39 +2736,42 @@ function formattedPricePerShare(quote, locale) {
 }
 
 // src/universal/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"
-    )
+  /** Maps the contract's `Preview { input, fee, output }` struct. */
+  fromContract: (preview) => ({
+    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
+    fee: parseUint256(preview.fee, "SwapPreview.fee"),
+    outputAmount: parseUint256(preview.output, "SwapPreview.output")
   })
 };
+var PauseFlags = (value) => value;
 var SwapStatus = {
-  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")
-  })
+  /**
+   * Maps the contract's `Status { uint32 flags; State state }` struct, where
+   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
+   *
+   * `flags` is carried onto the `paused` arm only. On the other two the
+   * contract sets it to a self-identifying marker rather than to information -
+   * so repeating it would invite a caller to read meaning into a constant.
+   *
+   * @throws ValidationError on a `state` outside the enum. A contract that has
+   * grown a fourth state is one the SDK does not model, and guessing `active`
+   * would let a halted swap read as a live one.
+   */
+  fromContract: (status) => {
+    switch (status.state) {
+      case 0:
+        return { state: "active" };
+      case 1:
+        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
+      case 2:
+        return { state: "stopped" };
+      default:
+        throw new ValidationError(
+          `SwapStatus.state: unknown contract state (${status.state})`
+        );
+    }
+  }
 };
 var AllowWalletResponse = {
   fromDto: (dto) => {
@@ -2009,87 +2793,9 @@ var AllowWalletResponse = {
       }
     }
   }
-};
-
-// src/universal/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);
-}
+};
+
+// src/universal/api/frontline/providers/superstate/swap.ts
 async function allowWallet(api, params) {
   const dto = await api.send({
     method: "POST",
@@ -2103,11 +2809,153 @@ async function allowWallet(api, params) {
   });
   return AllowWalletResponse.fromDto(dto);
 }
-function toErc20Asset(dto) {
+
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
+// src/universal/api/rpc/providers/superstate/swap.ts
+async function getSwapAuthorization(clients, params) {
+  return clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "authorized",
+    args: [params.walletAddress]
+  });
+}
+async function getSwapPreview(clients, params) {
+  const preview = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "preview",
+    args: [params.inputToken, params.amount]
+  });
+  return SwapPreview.fromContract(preview);
+}
+async function getSwapStatus(clients, params) {
+  const status = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "status"
+  });
+  return SwapStatus.fromContract(status);
+}
+async function getSwapOutputToken(clients, params) {
+  const client = clients(params.chain);
+  const tokenAddress = await client.readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "outputToken"
+  });
+  const token = { address: EvmContractAddress(tokenAddress), abi: ERC20_ABI };
+  const [name, symbol, decimals] = await client.multicall({
+    contracts: [
+      { ...token, functionName: "name" },
+      { ...token, functionName: "symbol" },
+      { ...token, functionName: "decimals" }
+    ],
+    allowFailure: false
+  });
   return {
-    name: dto.name,
-    symbol: AssetSymbol(dto.symbol),
-    decimals: AssetDecimals(dto.decimals)
+    name,
+    symbol: AssetSymbol(symbol),
+    decimals: AssetDecimals(decimals)
   };
 }
 
@@ -2118,28 +2966,32 @@ var SuperstateSwapNamespaceImpl = class {
     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);
-    });
+    return this.log.wrap(
+      "getAuthorization",
+      params,
+      async () => getSwapAuthorization(this.ctx.rpc, params)
+    );
   }
   async getPreview(params) {
-    return this.log.wrap("getPreview", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapPreview(this.ctx.api, params);
-    });
+    return this.log.wrap(
+      "getPreview",
+      params,
+      async () => getSwapPreview(this.ctx.rpc, params)
+    );
   }
   async getStatus(params) {
-    return this.log.wrap("getStatus", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapStatus(this.ctx.api, params);
-    });
+    return this.log.wrap(
+      "getStatus",
+      params,
+      async () => getSwapStatus(this.ctx.rpc, params)
+    );
   }
   async getOutputToken(params) {
-    return this.log.wrap("getOutputToken", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapOutputToken(this.ctx.api, params);
-    });
+    return this.log.wrap(
+      "getOutputToken",
+      params,
+      async () => getSwapOutputToken(this.ctx.rpc, params)
+    );
   }
   async allowWallet(params) {
     return this.log.wrap("allowWallet", params, async () => {
@@ -2164,7 +3016,7 @@ async function fetchOffersPage(api, params, clientCreds) {
       Attributes.clientCredentials(clientCreds)
     )
   });
-  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
 }
 async function fetchOfferDetails(api, id, clientCreds) {
   const dto = await api.send({
@@ -2384,105 +3236,25 @@ var RequirementsNamespaceImpl = class {
   }
 };
 
-// src/universal/core/shared/blockchain/erc20/abi.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "name",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "symbol",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    inputs: [
-      { name: "sender", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      { name: "owner", type: "address", indexed: true },
-      { name: "spender", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      { name: "from", type: "address", indexed: true },
-      { name: "to", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  }
-];
+// src/universal/api/rpc/erc20.ts
+async function getTokenAllowance(clients, params) {
+  const allowance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [params.owner, params.spender]
+  });
+  return parseUint256(allowance, "allowance");
+}
+async function getTokenBalance(clients, params) {
+  const balance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [params.owner]
+  });
+  return parseUint256(balance, "balanceOf");
+}
 
 // src/universal/core/shared/blockchain/erc20/erc20-namespace.ts
 var Erc20NamespaceImpl = class {
@@ -2491,21 +3263,69 @@ var Erc20NamespaceImpl = class {
     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);
-    });
+    return this.log.wrap(
+      "getAllowance",
+      params,
+      async () => getTokenAllowance(this.ctx.rpc, params)
+    );
   }
   async getBalance(params) {
-    return this.log.wrap("getBalance", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getTokenBalance(this.ctx.api, params);
-    });
+    return this.log.wrap(
+      "getBalance",
+      params,
+      async () => getTokenBalance(this.ctx.rpc, params)
+    );
+  }
+};
+
+// src/universal/core/tokens/token-registry-snapshot.ts
+var TokenRegistrySnapshot = {
+  /** Indexes a `tokens.list()` result. `[]` is a valid, empty snapshot. */
+  fromTokens: (tokens) => ({
+    tokens,
+    byKey: new Map(
+      tokens.map((token) => [registryKey(token.identifier), token])
+    )
+  }),
+  /**
+   * The registry's entry for one token, or `null` when it lists none. The
+   * registry is curated, so `null` is an ordinary answer rather than an
+   * error, and callers fall back to their own display defaults.
+   */
+  get: (snapshot, token) => snapshot.byKey.get(registryKey(token)) ?? null,
+  /**
+   * The registry's entry for the token an offer is *about*, or `null` when
+   * it lists none of them.
+   *
+   * Resolution follows {@link offerDisplayTokens}: the token a sale
+   * distributes or a swap hands over, never the funding token the user pays
+   * with. An offer deployed on several chains carries one such token per
+   * chain, and the first the registry knows wins - they are the same asset,
+   * so any listed one answers for the offer.
+   */
+  forOffer: (snapshot, offer) => {
+    for (const token of offerDisplayTokens(offer)) {
+      const metadata = TokenRegistrySnapshot.get(snapshot, token);
+      if (metadata !== null) {
+        return metadata;
+      }
+    }
+    return null;
   }
 };
+function offerDisplayTokens(offer) {
+  const swaps = offer.tokens.filter((token) => token.role === "swap");
+  const distributions = offer.tokens.filter(
+    (token) => token.role === "distribution"
+  );
+  return [...swaps, ...distributions];
+}
+function registryKey(token) {
+  return `${token.chain}:${token.address.toLowerCase()}`;
+}
 
 // src/universal/api/nabu/tokens.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 
 // src/universal/api/frontline/config.ts
 var HEADER_API_VERSION = "X-API-Version";
@@ -2571,9 +3391,9 @@ var HttpClient = class {
     if (url.startsWith("http://") || url.startsWith("https://")) {
       return url;
     }
-    const base = this.config.baseUrl.replace(/\/$/, "");
+    const base2 = this.config.baseUrl.replace(/\/$/, "");
     const path = url.startsWith("/") ? url : `/${url}`;
-    return base + path;
+    return base2 + path;
   }
   async runBeforeRequestMiddleware(initialRequest) {
     let request = initialRequest;
@@ -2834,7 +3654,7 @@ function assertOk(response) {
 }
 function checksummed(address) {
   try {
-    return (0, import_viem4.getAddress)(address);
+    return (0, import_viem5.getAddress)(address);
   } catch (_) {
     throw new ValidationError(`Invalid EVM contract address: "${address}"`);
   }
@@ -3097,11 +3917,12 @@ var User = {
   OAuthRefreshToken,
   OAuthSession,
   ONDO_POLL_INTERVAL_MS,
-  ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_QUOTE_MAX_TTL_MS,
   ONDO_SETTLEMENT_ASSET,
   ONDO_SUPPORTED_INPUT_ASSETS,
   Offer,
   OfferDetail,
+  OfferEditorial,
   OfferId,
   OfferOption,
   OfferOptionAddress,
@@ -3123,6 +3944,7 @@ var User = {
   Participation,
   ParticipationId,
   ParticipationsPaginationParams,
+  PauseFlags,
   Pii,
   PiiAddress,
   PiiJurisdiction,
@@ -3139,23 +3961,22 @@ var User = {
   SUPERSTATE_SUPPORTED_INPUT_ASSETS,
   SUPERSTATE_SWAP_ABI,
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
+  SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress,
   SolanaChain,
   StablecoinSymbol,
   SuperstateSwapNamespaceImpl,
-  SwapAuthorization,
   SwapPreview,
   SwapQuote,
   SwapStatus,
   TOKEN_REGISTRY,
   TermItem,
   Ticker,
-  TokenAllowance,
-  TokenBalance,
   TokenLogo,
   TokenLogoUrl,
   TokenMetadata,
+  TokenRegistrySnapshot,
   TokensNamespaceImpl,
   TxExplorerUrl,
   USDC,
@@ -3191,13 +4012,17 @@ var User = {
   getChainId,
   getNetworkName,
   isChain,
-  isStopped,
+  isOfferType,
+  isSwapAvailable,
+  offerDisplayTokens,
+  ondoQuoteOfferDeadline,
   parseBlockchainAmount,
   parseUint256,
   shortenAddress,
   superstateSwapContractAddress,
   swapSpender,
   txExplorerUrl,
-  usdAmount
+  usdAmount,
+  viemChain
 });
 //# sourceMappingURL=index.cjs.map