@coinlist-co/react 0.12.1-rc.c2b6ba5 → 0.12.1-rc.e183ffd

package/dist/server/index.cjs

@@ -215,6 +215,9 @@ var HEADER_API_VERSION = "X-API-Version";
 var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
 var API_VERSION = "2025-10-17";
 
+// src/universal/core/shared/observability/log-cause.ts
+var import_viem = require("viem");
+
 // src/universal/types/errors.ts
 var NotImplementedError = class extends Error {
   constructor(message = "Not implemented yet") {
@@ -267,8 +270,32 @@ function classifyLogCause(error) {
   if (error instanceof NotImplementedError) {
     return { type: "not-implemented" };
   }
+  if (error instanceof import_viem.BaseError) {
+    const http2 = error.walk((e) => e instanceof HttpError);
+    if (http2 instanceof HttpError) {
+      return httpCause(http2);
+    }
+    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);
@@ -457,9 +484,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;
@@ -908,6 +935,40 @@ async function fetchAllPages(fetchPage, baseParams) {
   return items;
 }
 
+// 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,
@@ -999,25 +1060,69 @@ var AssetSymbol = (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) => ({
@@ -1051,6 +1156,10 @@ var Asset = {
   })
 };
 
+// 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;
@@ -1062,69 +1171,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}`
-      );
-    }
-    return {
+    const fundingAssets = requiredArray(
+      dto.funding_assets,
+      "OfferDetail.funding_assets"
+    );
+    const options = requiredArray(dto.options, "OfferDetail.options");
+    const terms = requiredArray(dto.terms, "OfferDetail.terms");
+    const links = requiredArray(dto.links, "OfferDetail.links");
+    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
+    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
+    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
+    const isin = notBlankStringOrNull(dto.isin);
+    const ticker = notBlankStringOrNull(dto.ticker);
+    const base2 = {
       id: OfferId(dto.id),
       slug: OfferSlug(dto.slug),
-      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,
-      startsAt: new Date(dto.starts_at),
+      issuer: notBlankStringOrNull(dto.issuer),
+      isin: isin === null ? null : Isin(isin),
+      ticker: ticker === null ? null : Ticker(ticker),
+      instrumentType: notBlankStringOrNull(dto.instrument_type),
+      listingVenue: notBlankStringOrNull(dto.listing_venue),
       endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      faqs: 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 = {
@@ -1168,8 +1277,15 @@ var Milestone = {
 // 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
   })
@@ -1205,7 +1321,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({
@@ -1441,6 +1557,151 @@ var ServerRequirementsNamespaceImpl = class extends RequirementsNamespaceImpl {
 // src/universal/api/nabu/config.ts
 var NABU_BASE_URL = "https://asset.coinlist.co";
 
+// src/universal/api/rpc/public-clients.ts
+var import_viem3 = require("viem");
+
+// src/universal/api/rpc/frontline-transport.ts
+var import_viem2 = require("viem");
+function frontlineTransport(api, chain, logger = null) {
+  const log = internalLogger(logger, "RPC");
+  let nextId = 0;
+  return (0, import_viem2.custom)(
+    {
+      async request({ method, params }) {
+        const id = ++nextId;
+        return sendRpc({ api, log, chain, id, method, params });
+      }
+    },
+    // The `Sender` below already retries: `requestRetryMiddleware` makes three
+    // attempts at a 5xx and `renewSessionMiddleware` re-sends once after a 401.
+    // viem's own default is `retryCount: 3`, and it applies on top: an
+    // `HttpError` carries no numeric `code`, so `buildRequest` wraps it in
+    // `UnknownRpcError` (`code === -1`) and `shouldRetry` says yes. That reruns
+    // the whole pipeline four times - twelve requests for one `eth_call`, and
+    // with multicall batching one `eth_call` is a screen's worth of reads. The
+    // SDK's retry policy is the one that applies, so viem's is turned off.
+    { retryCount: 0 }
+  );
+}
+async function sendRpc({
+  api,
+  log,
+  chain,
+  id,
+  method,
+  params
+}) {
+  const url = rpcPath(chain);
+  const startedAt = Date.now();
+  log.debug(() => ({
+    msg: "rpc call sent",
+    fields: { id, method, chain, params }
+  }));
+  const response = await sendEnvelope(api, url, {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params
+  });
+  const elapsed = Date.now() - startedAt;
+  if (response.error) {
+    const error = new import_viem2.RpcRequestError({
+      body: { method, params },
+      error: response.error,
+      url
+    });
+    log.warning(
+      () => ({
+        msg: "rpc call rejected",
+        cause: { type: "rpc", reason: "node-rejected" },
+        fields: {
+          method,
+          chain,
+          duration_ms: elapsed,
+          "rpc.error_code": response.error?.code ?? null
+        }
+      }),
+      error
+    );
+    throw error;
+  }
+  log.info(() => ({
+    msg: "rpc call",
+    fields: { method, chain, duration_ms: elapsed }
+  }));
+  return response.result;
+}
+function rpcPath(chain) {
+  return `/v1/chains/${encodeURIComponent(chain)}/rpc`;
+}
+async function sendEnvelope(api, url, body) {
+  try {
+    return await api.send({
+      method: "POST",
+      url,
+      body,
+      attributes: Attributes.protected()
+    });
+  } catch (error) {
+    if (error instanceof HttpError && isJsonRpcError(error.response.body)) {
+      return error.response.body;
+    }
+    throw error;
+  }
+}
+function isJsonRpcError(body) {
+  if (typeof body !== "object" || body === null || !("error" in body)) {
+    return false;
+  }
+  const { error } = body;
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "number";
+}
+
+// src/universal/core/shared/blockchain/chain.ts
+var import_chains = require("viem/chains");
+
+// src/universal/types/blockchain/ui.ts
+var FormattedAmountAssetUi = (value) => value;
+
+// src/universal/core/shared/blockchain/chain.ts
+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 chainFromId(chainId) {
+  const chains = Object.keys(VIEM_CHAINS);
+  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
+  if (!chain) {
+    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
+  }
+  return chain;
+}
+
+// src/universal/api/rpc/public-clients.ts
+function publicClients(api, config, logger = null) {
+  const cache = /* @__PURE__ */ new Map();
+  return (chain) => {
+    const cached = cache.get(chain);
+    if (cached) return cached;
+    const client = (0, import_viem3.createPublicClient)({
+      chain: viemChain(chain),
+      transport: transportFor(api, config?.[chain], chain, logger),
+      batch: { multicall: true }
+    });
+    cache.set(chain, client);
+    return client;
+  };
+}
+function transportFor(api, override, chain, logger) {
+  if (override === void 0) return frontlineTransport(api, chain, logger);
+  return typeof override === "string" ? (0, import_viem3.http)(override) : override;
+}
+
 // src/universal/types/providers/coin-list/token-sale.ts
 var ParticipationId = (value) => value;
 var Blockchain = (value) => value;
@@ -1555,36 +1816,15 @@ var CoinListTokenSaleNamespaceImpl = class {
 };
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem = require("viem");
-
-// src/universal/types/blockchain/ui.ts
-var FormattedAmountAssetUi = (value) => value;
-
-// src/universal/core/shared/blockchain/formatters.ts
+var import_viem4 = require("viem");
 function formatRawAmount(amount) {
-  return (0, import_viem.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem4.formatUnits)(amount.raw, amount.decimals);
 }
 var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
 var USD_FRACTION_DIGITS = AssetDecimals(2);
 
-// src/universal/core/shared/blockchain/chain.ts
-var CHAIN_IDS = {
-  ethereum_mainnet: 1,
-  ethereum_sepolia: 11155111,
-  base_mainnet: 8453,
-  base_sepolia: 84532
-};
-function chainFromId(chainId) {
-  const chains = Object.keys(CHAIN_IDS);
-  const chain = chains.find((c) => String(CHAIN_IDS[c]) === chainId);
-  if (!chain) {
-    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
-  }
-  return chain;
-}
-
 // src/universal/core/shared/blockchain/math.ts
-var import_viem2 = require("viem");
+var import_viem5 = require("viem");
 function blockchainAmountFromRawOrThrow({
   label,
   raw,
@@ -1607,9 +1847,6 @@ function blockchainAmountFromRawOrThrow({
   }
 }
 
-// src/universal/types/trading.ts
-var Ticker = (value) => value;
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1904,39 +2141,42 @@ var OndoNamespaceImpl = class {
 };
 
 // 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) => {
@@ -1961,84 +2201,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",
@@ -2052,52 +2214,1090 @@ async function allowWallet(api, params) {
   });
   return AllowWalletResponse.fromDto(dto);
 }
-function toErc20Asset(dto) {
-  return {
-    name: dto.name,
-    symbol: AssetSymbol(dto.symbol),
-    decimals: AssetDecimals(dto.decimals)
-  };
-}
 
-// src/universal/core/checkout/superstate/swap-namespace.ts
-var SuperstateSwapNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "SUPERSTATE");
-  }
-  async getAuthorization(params) {
-    return this.log.wrap("getAuthorization", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapAuthorization(this.ctx.api, params);
-    });
-  }
-  async getPreview(params) {
-    return this.log.wrap("getPreview", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapPreview(this.ctx.api, params);
-    });
-  }
-  async getStatus(params) {
-    return this.log.wrap("getStatus", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapStatus(this.ctx.api, params);
-    });
-  }
-  async getOutputToken(params) {
-    return this.log.wrap("getOutputToken", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getSwapOutputToken(this.ctx.api, params);
-    });
-  }
-  async allowWallet(params) {
-    return this.log.wrap("allowWallet", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return allowWallet(this.ctx.api, params);
-    });
-  }
+// src/universal/core/checkout/superstate/blockchain/abi.ts
+var SUPERSTATE_SWAP_ABI = [
+  {
+    type: "function",
+    name: "KIND",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ONE_HUNDRED_P",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "SWAP_LEVEL",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "VERSION",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "authorized",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bpp",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bps",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "cancelOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "completeOwnershipHandover",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "fee",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "id",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "inputTokens",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputToken",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "outputTokenBalance",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "result",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownershipHandoverExpiresAt",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "result",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pause",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preview",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Preview",
+        components: [
+          {
+            name: "input",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "fee",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "output",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "requestOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "setBps",
+    inputs: [
+      {
+        name: "points",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setInputToken",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "val",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "status",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Status",
+        components: [
+          {
+            name: "flags",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "state",
+            type: "uint8",
+            internalType: "enum State"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "stop",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "stopped",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "swap",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "slip",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenBalance",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totals",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct SwapTotal",
+        components: [
+          {
+            name: "inputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "feeSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputSum",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "count",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      {
+        name: "newOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "event",
+    name: "BpsUpdated",
+    inputs: [
+      {
+        name: "prev",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "next",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "InputTokenUpdated",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "prev",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      },
+      {
+        name: "next",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverCanceled",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipHandoverRequested",
+    inputs: [
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "oldOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Paused",
+    inputs: [
+      {
+        name: "previous",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      },
+      {
+        name: "next",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Stopped",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Swapped",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "outputToken",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "inputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "outputAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transferred",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AlreadyInitialized",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InsufficientAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "IsPaused",
+    inputs: [
+      {
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "IsStopped",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NewOwnerIsZeroAddress",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NoHandoverRequest",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SwapFailed",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  }
+];
+
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
+// src/universal/api/rpc/providers/superstate/swap.ts
+async function getSwapAuthorization(clients, params) {
+  return clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "authorized",
+    args: [params.walletAddress]
+  });
+}
+async function getSwapPreview(clients, params) {
+  const preview = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "preview",
+    args: [params.inputToken, params.amount]
+  });
+  return SwapPreview.fromContract(preview);
+}
+async function getSwapStatus(clients, params) {
+  const status = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "status"
+  });
+  return SwapStatus.fromContract(status);
+}
+async function getSwapOutputToken(clients, params) {
+  const client = clients(params.chain);
+  const tokenAddress = await client.readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "outputToken"
+  });
+  const token = { address: EvmContractAddress(tokenAddress), abi: ERC20_ABI };
+  const [name, symbol, decimals] = await client.multicall({
+    contracts: [
+      { ...token, functionName: "name" },
+      { ...token, functionName: "symbol" },
+      { ...token, functionName: "decimals" }
+    ],
+    allowFailure: false
+  });
+  return {
+    name,
+    symbol: AssetSymbol(symbol),
+    decimals: AssetDecimals(decimals)
+  };
+}
+
+// src/universal/core/checkout/superstate/swap-namespace.ts
+var SuperstateSwapNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "SUPERSTATE");
+  }
+  async getAuthorization(params) {
+    return this.log.wrap(
+      "getAuthorization",
+      params,
+      async () => getSwapAuthorization(this.ctx.rpc, params)
+    );
+  }
+  async getPreview(params) {
+    return this.log.wrap(
+      "getPreview",
+      params,
+      async () => getSwapPreview(this.ctx.rpc, params)
+    );
+  }
+  async getStatus(params) {
+    return this.log.wrap(
+      "getStatus",
+      params,
+      async () => getSwapStatus(this.ctx.rpc, params)
+    );
+  }
+  async getOutputToken(params) {
+    return this.log.wrap(
+      "getOutputToken",
+      params,
+      async () => getSwapOutputToken(this.ctx.rpc, params)
+    );
+  }
+  async allowWallet(params) {
+    return this.log.wrap("allowWallet", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return allowWallet(this.ctx.api, params);
+    });
+  }
 };
 
+// src/universal/api/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) {
@@ -2105,21 +3305,23 @@ 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/api/nabu/tokens.ts
-var import_viem3 = require("viem");
+var import_viem6 = require("viem");
 
 // src/universal/types/token-metadata.ts
 var TokenLogoUrl = (value) => value;
@@ -2289,7 +3491,7 @@ function assertOk(response) {
 }
 function checksummed(address) {
   try {
-    return (0, import_viem3.getAddress)(address);
+    return (0, import_viem6.getAddress)(address);
   } catch (_) {
     throw new ValidationError(`Invalid EVM contract address: "${address}"`);
   }
@@ -2488,6 +3690,7 @@ var CoinListServerImpl = class {
     });
     const ctx = {
       api: this.api,
+      rpc: publicClients(this.api, _config.rpc, _config.logger ?? null),
       logger,
       ensureUserAuthenticated: () => this.ensureAuthenticated(void 0),
       ensureAuthenticated: (clientCreds) => this.ensureAuthenticated(clientCreds)