@coinlist-co/react 0.12.0 → 0.12.1-rc.0fa5c3b

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;
@@ -1051,6 +1078,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;
@@ -1103,6 +1134,8 @@ var OfferDetail = {
         `OfferDetail.swap_contracts: expected an array, got ${typeof swapContracts}`
       );
     }
+    const isin = notBlankStringOrNull(dto.isin);
+    const ticker = notBlankStringOrNull(dto.ticker);
     return {
       id: OfferId(dto.id),
       slug: OfferSlug(dto.slug),
@@ -1117,6 +1150,11 @@ var OfferDetail = {
       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),
@@ -1441,6 +1479,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 +1738,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 +1769,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 +2063,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 +2123,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,11 +2136,1025 @@ async function allowWallet(api, params) {
   });
   return AllowWalletResponse.fromDto(dto);
 }
-function toErc20Asset(dto) {
+
+// 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: dto.name,
-    symbol: AssetSymbol(dto.symbol),
-    decimals: AssetDecimals(dto.decimals)
+    name,
+    symbol: AssetSymbol(symbol),
+    decimals: AssetDecimals(decimals)
   };
 }
 
@@ -2067,28 +3165,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 () => {
@@ -2098,6 +3200,26 @@ var SuperstateSwapNamespaceImpl = 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) {
@@ -2105,21 +3227,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 +3413,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 +3612,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)