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

package/dist/{chunk-D42IQHQZ.js → chunk-MOE5S6CE.js}

@@ -209,6 +209,106 @@ var MathError = class extends Error {
   }
 };
 
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
 // src/universal/api/pagination.ts
 async function fetchAllPages(fetchPage, baseParams) {
   const items = [];
@@ -228,8 +328,15 @@ async function fetchAllPages(fetchPage, baseParams) {
 // 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
   })
@@ -359,53 +466,6 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
-// src/universal/types/offer.ts
-var OfferId = (value) => value;
-var OfferSlug = (value) => value;
-var Offer = {
-  fromDto: (dto) => {
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    return {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      type: dto.type,
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
-      startsAt: new Date(dto.starts_at),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      tokens: OfferToken.listFromDto(dto.tokens)
-    };
-  }
-};
-var OfferToken = {
-  fromDto: (dto) => ({
-    role: dto.role,
-    chain: Chain(dto.chain),
-    address: EvmContractAddress(dto.address)
-  }),
-  /**
-   * Maps an offer's token list, dropping every token on a chain this SDK does
-   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
-   * plain `.map` would throw out of `Offer.fromDto` and, through
-   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
-   * one Base token blanked production's offers list. Dropping costs that
-   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
-   * so nobody could have looked it up anyway.
-   *
-   * Same shape as `TokenMetadata.fromRegistryDto`.
-   */
-  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
-};
-
-// src/universal/types/trading.ts
-var Ticker = (value) => value;
-var Isin = (value) => value;
-
 // src/universal/core/shared/utils/crypto.ts
 async function sha256(data) {
   const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
@@ -456,6 +516,131 @@ function notBlankStringOrNull(value) {
   }
 }
 
+// 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/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) => {
+    const tokens = requiredArray(dto.tokens, "Offer.tokens");
+    const base2 = {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      tokens: OfferToken.listFromDto(tokens)
+    };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire: copying them would hand every consumer a `startsAt` that
+      // is 1970 for one variant and a date for the others.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      default:
+        return unknownTypeError(dto, "Offer");
+    }
+  },
+  /**
+   * Maps a page of offers, dropping every offer whose `type` this SDK does not
+   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+   * reject the whole page, so one offer of an unknown type would blank the
+   * grid for every offer beside it. A single offer fetched by id still
+   * throws, because there is nothing beside it to keep.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
+};
+var OfferToken = {
+  fromDto: (dto) => ({
+    role: dto.role,
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Maps an offer's token list, dropping every token on a chain this SDK does
+   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
+   * plain `.map` would throw out of `Offer.fromDto` and, through
+   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
+   * one Base token blanked production's offers list. Dropping costs that
+   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
+   * so nobody could have looked it up anyway.
+   *
+   * Same shape as `TokenMetadata.fromRegistryDto`.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
+};
+
+// src/universal/types/trading.ts
+var Ticker = (value) => value;
+var Isin = (value) => value;
+
 // src/universal/types/offer-detail.ts
 var OfferOptionId = (value) => value;
 var OfferOptionSlug = (value) => value;
@@ -467,76 +652,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 = {
@@ -659,6 +837,16 @@ async function createParticipation(api, params) {
 }
 
 // src/universal/core/shared/observability/log-cause.ts
+import {
+  BaseError,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  HttpRequestError,
+  RpcError,
+  SocketClosedError,
+  TimeoutError,
+  WebSocketRequestError
+} from "viem";
 function classifyLogCause(error) {
   if (error instanceof HttpError) {
     return httpCause(error);
@@ -678,8 +866,32 @@ function classifyLogCause(error) {
   if (error instanceof NotImplementedError) {
     return { type: "not-implemented" };
   }
+  if (error instanceof 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 ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof HttpRequestError || e instanceof WebSocketRequestError || e instanceof SocketClosedError || e instanceof TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof ContractFunctionExecutionError) {
+    return "malformed-response";
+  }
+  return "unknown";
+}
 function describeErrorUnredacted(error) {
   if (error instanceof HttpError) {
     return describeHttpErrorRedacted(error);
@@ -943,18 +1155,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
+import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
+var VIEM_CHAINS = {
+  ethereum_mainnet: mainnet,
+  ethereum_sepolia: sepolia,
+  base_mainnet: base,
+  base_sepolia: 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}"`);
   }
@@ -1028,10 +1244,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 [, fraction = ""] = trimmed.split(".");
+  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
+  if (!/^\d+(\.\d+)?$/.test(normalised)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const [, fraction = ""] = normalised.split(".");
   if (fraction.length > decimals) {
     return {
       valid: false,
@@ -1039,7 +1259,7 @@ function parseBlockchainAmount(amount, decimals) {
     };
   }
   try {
-    const raw = parseUnits(trimmed, decimals);
+    const raw = parseUnits(normalised, decimals);
     if (raw > MAX_UINT_256) {
       return { valid: false, reason: { type: "overflow" } };
     }
@@ -1345,40 +1565,915 @@ var OndoNamespaceImpl = class {
   }
 };
 
+// src/universal/core/checkout/superstate/blockchain/abi.ts
+var SUPERSTATE_SWAP_ABI = [
+  {
+    type: "function",
+    name: "KIND",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ONE_HUNDRED_P",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "SWAP_LEVEL",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "VERSION",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "authorized",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bpp",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bps",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "cancelOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "completeOwnershipHandover",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "fee",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "id",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "inputTokens",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputToken",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputTokenBalance",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "result",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownershipHandoverExpiresAt",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "result",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pause",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preview",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Preview",
+        components: [
+          {
+            name: "input",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "fee",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "output",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "requestOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "setBps",
+    inputs: [
+      {
+        name: "points",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setInputToken",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "val",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "status",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Status",
+        components: [
+          {
+            name: "flags",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "state",
+            type: "uint8",
+            internalType: "enum State"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "stop",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "stopped",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "swap",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "slip",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenBalance",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      {
+        name: "newOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "event",
+    name: "BpsUpdated",
+    inputs: [
+      {
+        name: "prev",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "next",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "InputTokenUpdated",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "prev",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      },
+      {
+        name: "next",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverCanceled",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverRequested",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "oldOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Paused",
+    inputs: [
+      {
+        name: "previous",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      },
+      {
+        name: "next",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Stopped",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Swapped",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "outputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "outputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transferred",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AlreadyInitialized",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InsufficientAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "IsPaused",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "IsStopped",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NewOwnerIsZeroAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NoHandoverRequest",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SwapFailed",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  }
+];
+
 // src/universal/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) => {
@@ -1403,84 +2498,6 @@ 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);
-}
 async function allowWallet(api, params) {
   const dto = await api.send({
     method: "POST",
@@ -1494,11 +2511,53 @@ async function allowWallet(api, params) {
   });
   return AllowWalletResponse.fromDto(dto);
 }
-function toErc20Asset(dto) {
+
+// 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)
   };
 }
 
@@ -1509,28 +2568,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 () => {
@@ -1715,6 +2778,26 @@ var RequirementsNamespaceImpl = class {
   }
 };
 
+// src/universal/api/rpc/erc20.ts
+async function getTokenAllowance(clients, params) {
+  const allowance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [params.owner, params.spender]
+  });
+  return parseUint256(allowance, "allowance");
+}
+async function getTokenBalance(clients, params) {
+  const balance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [params.owner]
+  });
+  return parseUint256(balance, "balanceOf");
+}
+
 // src/universal/core/shared/blockchain/erc20/erc20-namespace.ts
 var Erc20NamespaceImpl = class {
   constructor(ctx) {
@@ -1722,16 +2805,18 @@ 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)
+    );
   }
 };
 
@@ -1895,9 +2980,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;
@@ -2280,7 +3365,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({
@@ -2321,6 +3406,7 @@ export {
   describeErrorUnredacted,
   internalLogger,
   HttpClient,
+  ERC20_ABI,
   fetchAllPages,
   Cursor,
   PaginatedResponse,
@@ -2351,6 +3437,8 @@ export {
   Bps,
   OfferId,
   OfferSlug,
+  isOfferType,
+  OfferEditorial,
   Offer,
   OfferToken,
   Ticker,
@@ -2386,6 +3474,7 @@ export {
   assetAmount,
   NA_AMOUNT_ASSET_UI,
   formattedUsdPrice,
+  viemChain,
   getChainId,
   chainFromId,
   getNetworkName,
@@ -2397,11 +3486,10 @@ export {
   OndoBuyTransaction,
   OndoSellTransaction,
   OndoNamespaceImpl,
-  SwapAuthorization,
+  SUPERSTATE_SWAP_ABI,
   SwapPreview,
+  PauseFlags,
   SwapStatus,
-  TokenAllowance,
-  TokenBalance,
   AllowWalletResponse,
   SuperstateSwapNamespaceImpl,
   fetchOffers,
@@ -2433,4 +3521,4 @@ export {
   OAuthRefreshToken,
   OAuthSession
 };
-//# sourceMappingURL=chunk-D42IQHQZ.js.map
+//# sourceMappingURL=chunk-MOE5S6CE.js.map