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

package/dist/universal/index.cjs

@@ -62,6 +62,7 @@ __export(universal_exports, {
   HexEncodedTransactionData: () => HexEncodedTransactionData,
   HttpError: () => HttpError,
   InvariantError: () => InvariantError,
+  Isin: () => Isin,
   Iso2CountryCode: () => Iso2CountryCode,
   KnownAssetSymbol: () => KnownAssetSymbol,
   KycToken: () => KycToken,
@@ -102,6 +103,7 @@ __export(universal_exports, {
   Participation: () => Participation,
   ParticipationId: () => ParticipationId,
   ParticipationsPaginationParams: () => ParticipationsPaginationParams,
+  PauseFlags: () => PauseFlags,
   Pii: () => Pii,
   PiiAddress: () => PiiAddress,
   PiiJurisdiction: () => PiiJurisdiction,
@@ -118,20 +120,18 @@ __export(universal_exports, {
   SUPERSTATE_SUPPORTED_INPUT_ASSETS: () => SUPERSTATE_SUPPORTED_INPUT_ASSETS,
   SUPERSTATE_SWAP_ABI: () => SUPERSTATE_SWAP_ABI,
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA: () => SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
+  SWAP_LEVEL: () => SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS: () => SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress: () => ShortenedWalletAddress,
   SolanaChain: () => SolanaChain,
   StablecoinSymbol: () => StablecoinSymbol,
   SuperstateSwapNamespaceImpl: () => SuperstateSwapNamespaceImpl,
-  SwapAuthorization: () => SwapAuthorization,
   SwapPreview: () => SwapPreview,
   SwapQuote: () => SwapQuote,
   SwapStatus: () => SwapStatus,
   TOKEN_REGISTRY: () => TOKEN_REGISTRY,
   TermItem: () => TermItem,
   Ticker: () => Ticker,
-  TokenAllowance: () => TokenAllowance,
-  TokenBalance: () => TokenBalance,
   TokenLogo: () => TokenLogo,
   TokenLogoUrl: () => TokenLogoUrl,
   TokenMetadata: () => TokenMetadata,
@@ -170,14 +170,15 @@ __export(universal_exports, {
   getChainId: () => getChainId,
   getNetworkName: () => getNetworkName,
   isChain: () => isChain,
-  isStopped: () => isStopped,
+  isSwapAvailable: () => isSwapAvailable,
   parseBlockchainAmount: () => parseBlockchainAmount,
   parseUint256: () => parseUint256,
   shortenAddress: () => shortenAddress,
   superstateSwapContractAddress: () => superstateSwapContractAddress,
   swapSpender: () => swapSpender,
   txExplorerUrl: () => txExplorerUrl,
-  usdAmount: () => usdAmount
+  usdAmount: () => usdAmount,
+  viemChain: () => viemChain
 });
 module.exports = __toCommonJS(universal_exports);
 
@@ -633,6 +634,10 @@ var OfferToken = {
   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;
@@ -685,6 +690,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),
@@ -699,6 +706,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),
@@ -829,6 +841,7 @@ async function createParticipation(api, params) {
 }
 
 // src/universal/core/shared/observability/log-cause.ts
+var import_viem = require("viem");
 function classifyLogCause(error) {
   if (error instanceof HttpError) {
     return httpCause(error);
@@ -848,8 +861,32 @@ function classifyLogCause(error) {
   if (error instanceof NotImplementedError) {
     return { type: "not-implemented" };
   }
+  if (error instanceof import_viem.BaseError) {
+    const http = error.walk((e) => e instanceof HttpError);
+    if (http instanceof HttpError) {
+      return httpCause(http);
+    }
+    return { type: "rpc", reason: rpcFailureReason(error) };
+  }
   return { type: "generic-error", name: errorName(error) };
 }
+function rpcFailureReason(error) {
+  if (error.walk((e) => e instanceof import_viem.ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof import_viem.RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof import_viem.HttpRequestError || e instanceof import_viem.WebSocketRequestError || e instanceof import_viem.SocketClosedError || e instanceof import_viem.TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof import_viem.ContractFunctionExecutionError) {
+    return "malformed-response";
+  }
+  return "unknown";
+}
 function describeErrorUnredacted(error) {
   if (error instanceof HttpError) {
     return describeHttpErrorRedacted(error);
@@ -1123,7 +1160,7 @@ function assertPriceFits(raw) {
 }
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem = require("viem");
+var import_viem2 = require("viem");
 
 // src/universal/types/blockchain/ui.ts
 var FormattedAmountUi = (value) => value;
@@ -1189,7 +1226,7 @@ function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
   };
 }
 function formatRawAmount(amount) {
-  return (0, import_viem.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem2.formatUnits)(amount.raw, amount.decimals);
 }
 function formatCompactAmount(amount, locale) {
   const value = Number(formatRawAmount(amount));
@@ -1228,18 +1265,22 @@ function formattedUsdPrice(amount, locale) {
 }
 
 // src/universal/core/shared/blockchain/chain.ts
-var CHAIN_IDS = {
-  ethereum_mainnet: 1,
-  ethereum_sepolia: 11155111,
-  base_mainnet: 8453,
-  base_sepolia: 84532
+var import_chains = require("viem/chains");
+var VIEM_CHAINS = {
+  ethereum_mainnet: import_chains.mainnet,
+  ethereum_sepolia: import_chains.sepolia,
+  base_mainnet: import_chains.base,
+  base_sepolia: import_chains.baseSepolia
 };
+function viemChain(chain) {
+  return VIEM_CHAINS[chain];
+}
 function getChainId(chain) {
-  return CHAIN_IDS[chain];
+  return VIEM_CHAINS[chain].id;
 }
 function chainFromId(chainId) {
-  const chains = Object.keys(CHAIN_IDS);
-  const chain = chains.find((c) => String(CHAIN_IDS[c]) === chainId);
+  const chains = Object.keys(VIEM_CHAINS);
+  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
   if (!chain) {
     throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
   }
@@ -1282,7 +1323,7 @@ function explorerBaseUrl(chain) {
 }
 
 // src/universal/core/shared/blockchain/math.ts
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 function blockchainAmountFromRawOrThrow({
   label,
   raw,
@@ -1313,10 +1354,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,
@@ -1324,7 +1369,7 @@ function parseBlockchainAmount(amount, decimals) {
     };
   }
   try {
-    const raw = (0, import_viem2.parseUnits)(trimmed, decimals);
+    const raw = (0, import_viem3.parseUnits)(normalised, decimals);
     if (raw > MAX_UINT_256) {
       return { valid: false, reason: { type: "overflow" } };
     }
@@ -1337,9 +1382,6 @@ function parseBlockchainAmount(amount, decimals) {
   }
 }
 
-// src/universal/types/trading.ts
-var Ticker = (value) => value;
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1637,226 +1679,876 @@ var OndoNamespaceImpl = class {
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
-    name: "authorized",
-    inputs: [{ name: "user", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    name: "KIND",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "stopped",
+    name: "ONE_HUNDRED_P",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
     name: "SWAP_LEVEL",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "preview",
-    inputs: [
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
-    ],
+    name: "VERSION",
+    inputs: [],
     outputs: [
       {
         name: "",
-        type: "tuple",
-        internalType: "struct Preview",
-        components: [
-          { name: "input", type: "uint256", internalType: "uint256" },
-          { name: "fee", type: "uint256", internalType: "uint256" },
-          { name: "output", type: "uint256", internalType: "uint256" }
-        ]
+        type: "uint16",
+        internalType: "uint16"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "swap",
+    name: "authorized",
     inputs: [
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" },
-      { name: "slip", type: "uint256", internalType: "uint256" }
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
     ],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
-    stateMutability: "nonpayable"
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
   },
   {
     type: "function",
-    name: "tokenBalance",
-    inputs: [{ name: "token", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    name: "bpp",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "outputToken",
+    name: "bps",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "outputTokenBalance",
+    name: "cancelOwnershipHandover",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
-    stateMutability: "view"
+    outputs: [],
+    stateMutability: "payable"
   },
   {
     type: "function",
-    name: "totals",
-    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    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: "tuple",
-        internalType: "struct SwapTotal",
-        components: [
-          { name: "inputSum", type: "uint256", internalType: "uint256" },
-          { name: "feeSum", type: "uint256", internalType: "uint256" },
-          { name: "outputSum", type: "uint256", internalType: "uint256" },
-          { name: "count", type: "uint256", internalType: "uint256" }
-        ]
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "totals",
-    inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" }
-    ],
+    name: "id",
+    inputs: [],
     outputs: [
       {
         name: "",
-        type: "tuple",
-        internalType: "struct SwapTotal",
-        components: [
-          { name: "inputSum", type: "uint256", internalType: "uint256" },
-          { name: "feeSum", type: "uint256", internalType: "uint256" },
-          { name: "outputSum", type: "uint256", internalType: "uint256" },
-          { name: "count", type: "uint256", internalType: "uint256" }
-        ]
+        type: "bytes32",
+        internalType: "bytes32"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "transfer",
+    name: "inputTokens",
     inputs: [
-      { name: "to", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
   },
   {
     type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "to", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" },
-      { name: "amount", type: "uint256", internalType: "uint256" }
+    name: "outputToken",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    stateMutability: "view"
   },
   {
     type: "function",
-    name: "setBps",
-    inputs: [{ name: "points", type: "uint256", internalType: "uint256" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    name: "outputTokenBalance",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
   },
   {
-    type: "event",
-    name: "Swapped",
-    inputs: [
-      { name: "user", type: "address", indexed: true, internalType: "address" },
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
       {
-        name: "inputToken",
+        name: "result",
         type: "address",
-        indexed: true,
         internalType: "address"
-      },
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownershipHandoverExpiresAt",
+    inputs: [
       {
-        name: "outputToken",
+        name: "pendingOwner",
         type: "address",
-        indexed: true,
         internalType: "address"
-      },
+      }
+    ],
+    outputs: [
       {
-        name: "inputAmount",
+        name: "result",
         type: "uint256",
-        indexed: false,
         internalType: "uint256"
-      },
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pause",
+    inputs: [
       {
-        name: "outputAmount",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
+        name: "level",
+        type: "uint32",
+        internalType: "uint32"
       }
     ],
-    anonymous: false
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
   },
   {
-    type: "event",
-    name: "Transferred",
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preview",
     inputs: [
-      { name: "to", type: "address", indexed: true, internalType: "address" },
       {
         name: "token",
         type: "address",
-        indexed: true,
         internalType: "address"
       },
       {
         name: "amount",
         type: "uint256",
-        indexed: false,
         internalType: "uint256"
       }
     ],
-    anonymous: false
-  },
-  {
-    type: "error",
-    name: "InvalidAddress",
-    inputs: []
+    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: "error",
-    name: "InsufficientAmount",
-    inputs: []
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
   },
   {
-    type: "error",
-    name: "InvalidAmount",
-    inputs: []
+    type: "function",
+    name: "requestOwnershipHandover",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
   },
   {
-    type: "error",
-    name: "SwapFailed",
+    type: "function",
+    name: "setBps",
     inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "token", type: "address", internalType: "address" }
-    ]
-  }
-];
-
-// src/universal/core/shared/blockchain/bps.ts
-var BPS_DENOM = Bps(10000n);
+      {
+        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/bps.ts
+var BPS_DENOM = Bps(10000n);
 function applyBps(amount, bps) {
   return assertUint256(amount * bps / BPS_DENOM);
 }
@@ -1900,15 +2592,27 @@ var SwapQuote = {
 };
 
 // src/universal/core/checkout/superstate/blockchain/status.ts
-function isStopped(status) {
-  return (status.stopped & status.swapLevel) !== 0n;
+var SWAP_LEVEL = 2;
+function isSwapAvailable(status) {
+  switch (status.state) {
+    case "active":
+      return true;
+    case "stopped":
+      return false;
+    case "paused":
+      return (status.pausedLevels & SWAP_LEVEL) === 0;
+    default: {
+      const _exhaustive = status;
+      return _exhaustive;
+    }
+  }
 }
 
 // src/universal/core/checkout/superstate/blockchain/swapped-event.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 function decodeSwappedOutputAmount(receipt, outputDecimals) {
   try {
-    const [swapped] = (0, import_viem3.parseEventLogs)({
+    const [swapped] = (0, import_viem4.parseEventLogs)({
       abi: SUPERSTATE_SWAP_ABI,
       eventName: "Swapped",
       logs: receipt.logs
@@ -1931,7 +2635,7 @@ var SLIPPAGE_OPTIONS_BPS = [25n, 50n, 100n, 200n, 500n].map(
   (n) => Bps(n)
 );
 var DEFAULT_SLIPPAGE_BPS = Bps(50n);
-var SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA = EvmContractAddress("0x84f8e9a6C9Cc12fe911259372EfCa5582C4ae557");
+var SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA = EvmContractAddress("0x27E8CE9Ca1A1E98Bc4009F08Dc596bFcf88aCED1");
 var SUPERSTATE_SWAP_CONTRACT_ADDRESSES = {
   ethereum_sepolia: SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA
 };
@@ -1946,141 +2650,66 @@ function formattedPricePerShare(quote, locale) {
 }
 
 // src/universal/types/providers/superstate/swap.ts
-var SwapAuthorization = {
-  fromDto: (dto) => ({
-    authorized: dto.authorized
-  })
-};
 var SwapPreview = {
-  fromDto: (dto) => ({
-    inputAmount: parseUint256(
-      BigInt(dto.pay_input_amount),
-      "SwapPreview.pay_input_amount"
-    ),
-    fee: parseUint256(BigInt(dto.fee), "SwapPreview.fee"),
-    outputAmount: parseUint256(
-      BigInt(dto.receive_output_amount),
-      "SwapPreview.receive_output_amount"
-    )
+  /** Maps the contract's `Preview { input, fee, output }` struct. */
+  fromContract: (preview) => ({
+    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
+    fee: parseUint256(preview.fee, "SwapPreview.fee"),
+    outputAmount: parseUint256(preview.output, "SwapPreview.output")
   })
 };
+var PauseFlags = (value) => value;
 var SwapStatus = {
-  fromDto: (dto) => ({
-    stopped: parseUint256(BigInt(dto.stopped), "SwapStatus.stopped"),
-    swapLevel: parseUint256(BigInt(dto.swap_level), "SwapStatus.swap_level")
-  })
-};
-var TokenAllowance = {
-  fromDto: (dto) => ({
-    allowance: parseUint256(BigInt(dto.allowance), "TokenAllowance.allowance")
-  })
-};
-var TokenBalance = {
-  fromDto: (dto) => ({
-    balance: parseUint256(BigInt(dto.balance), "TokenBalance.balance")
-  })
+  /**
+   * Maps the contract's `Status { uint32 flags; State state }` struct, where
+   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
+   *
+   * `flags` is carried onto the `paused` arm only. On the other two the
+   * contract sets it to a self-identifying marker rather than to information -
+   * so repeating it would invite a caller to read meaning into a constant.
+   *
+   * @throws ValidationError on a `state` outside the enum. A contract that has
+   * grown a fourth state is one the SDK does not model, and guessing `active`
+   * would let a halted swap read as a live one.
+   */
+  fromContract: (status) => {
+    switch (status.state) {
+      case 0:
+        return { state: "active" };
+      case 1:
+        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
+      case 2:
+        return { state: "stopped" };
+      default:
+        throw new ValidationError(
+          `SwapStatus.state: unknown contract state (${status.state})`
+        );
+    }
+  }
 };
 var AllowWalletResponse = {
   fromDto: (dto) => {
     switch (dto.action) {
       case "broadcast_transaction":
-        return {
-          action: "broadcast_transaction",
-          to: EvmContractAddress(dto.to),
-          data: HexEncodedTransactionData(dto.data)
-        };
-      case "none":
-        return {
-          action: "none",
-          alreadyAllowed: dto.already_allowed
-        };
-      default: {
-        const _exhaustive = dto;
-        return _exhaustive;
-      }
-    }
-  }
-};
-
-// src/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);
-}
+        return {
+          action: "broadcast_transaction",
+          to: EvmContractAddress(dto.to),
+          data: HexEncodedTransactionData(dto.data)
+        };
+      case "none":
+        return {
+          action: "none",
+          alreadyAllowed: dto.already_allowed
+        };
+      default: {
+        const _exhaustive = dto;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/universal/api/frontline/providers/superstate/swap.ts
 async function allowWallet(api, params) {
   const dto = await api.send({
     method: "POST",
@@ -2094,11 +2723,153 @@ async function allowWallet(api, params) {
   });
   return AllowWalletResponse.fromDto(dto);
 }
-function toErc20Asset(dto) {
+
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
+// src/universal/api/rpc/providers/superstate/swap.ts
+async function getSwapAuthorization(clients, params) {
+  return clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "authorized",
+    args: [params.walletAddress]
+  });
+}
+async function getSwapPreview(clients, params) {
+  const preview = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "preview",
+    args: [params.inputToken, params.amount]
+  });
+  return SwapPreview.fromContract(preview);
+}
+async function getSwapStatus(clients, params) {
+  const status = await clients(params.chain).readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "status"
+  });
+  return SwapStatus.fromContract(status);
+}
+async function getSwapOutputToken(clients, params) {
+  const client = clients(params.chain);
+  const tokenAddress = await client.readContract({
+    address: params.contractAddress,
+    abi: SUPERSTATE_SWAP_ABI,
+    functionName: "outputToken"
+  });
+  const token = { address: EvmContractAddress(tokenAddress), abi: ERC20_ABI };
+  const [name, symbol, decimals] = await client.multicall({
+    contracts: [
+      { ...token, functionName: "name" },
+      { ...token, functionName: "symbol" },
+      { ...token, functionName: "decimals" }
+    ],
+    allowFailure: false
+  });
   return {
-    name: dto.name,
-    symbol: AssetSymbol(dto.symbol),
-    decimals: AssetDecimals(dto.decimals)
+    name,
+    symbol: AssetSymbol(symbol),
+    decimals: AssetDecimals(decimals)
   };
 }
 
@@ -2109,28 +2880,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 () => {
@@ -2375,105 +3150,25 @@ var RequirementsNamespaceImpl = class {
   }
 };
 
-// src/universal/core/shared/blockchain/erc20/abi.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "name",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "symbol",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    inputs: [
-      { name: "sender", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      { name: "owner", type: "address", indexed: true },
-      { name: "spender", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      { name: "from", type: "address", indexed: true },
-      { name: "to", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  }
-];
+// src/universal/api/rpc/erc20.ts
+async function getTokenAllowance(clients, params) {
+  const allowance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [params.owner, params.spender]
+  });
+  return parseUint256(allowance, "allowance");
+}
+async function getTokenBalance(clients, params) {
+  const balance = await clients(params.chain).readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [params.owner]
+  });
+  return parseUint256(balance, "balanceOf");
+}
 
 // src/universal/core/shared/blockchain/erc20/erc20-namespace.ts
 var Erc20NamespaceImpl = class {
@@ -2482,21 +3177,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_viem4 = require("viem");
+var import_viem5 = require("viem");
 
 // src/universal/api/frontline/config.ts
 var HEADER_API_VERSION = "X-API-Version";
@@ -2562,9 +3259,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;
@@ -2825,7 +3522,7 @@ function assertOk(response) {
 }
 function checksummed(address) {
   try {
-    return (0, import_viem4.getAddress)(address);
+    return (0, import_viem5.getAddress)(address);
   } catch (_) {
     throw new ValidationError(`Invalid EVM contract address: "${address}"`);
   }
@@ -3073,6 +3770,7 @@ var User = {
   HexEncodedTransactionData,
   HttpError,
   InvariantError,
+  Isin,
   Iso2CountryCode,
   KnownAssetSymbol,
   KycToken,
@@ -3113,6 +3811,7 @@ var User = {
   Participation,
   ParticipationId,
   ParticipationsPaginationParams,
+  PauseFlags,
   Pii,
   PiiAddress,
   PiiJurisdiction,
@@ -3129,20 +3828,18 @@ var User = {
   SUPERSTATE_SUPPORTED_INPUT_ASSETS,
   SUPERSTATE_SWAP_ABI,
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
+  SWAP_LEVEL,
   SWAP_POLL_INTERVAL_MS,
   ShortenedWalletAddress,
   SolanaChain,
   StablecoinSymbol,
   SuperstateSwapNamespaceImpl,
-  SwapAuthorization,
   SwapPreview,
   SwapQuote,
   SwapStatus,
   TOKEN_REGISTRY,
   TermItem,
   Ticker,
-  TokenAllowance,
-  TokenBalance,
   TokenLogo,
   TokenLogoUrl,
   TokenMetadata,
@@ -3181,13 +3878,14 @@ var User = {
   getChainId,
   getNetworkName,
   isChain,
-  isStopped,
+  isSwapAvailable,
   parseBlockchainAmount,
   parseUint256,
   shortenAddress,
   superstateSwapContractAddress,
   swapSpender,
   txExplorerUrl,
-  usdAmount
+  usdAmount,
+  viemChain
 });
 //# sourceMappingURL=index.cjs.map