@rhinestone/deposit-modal 0.8.1 → 0.9.0

package/dist/chunk-A223BLVC.mjs

@@ -0,0 +1,801 @@
+// src/core/caip.ts
+var SOLANA_MAINNET_GENESIS = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_MAINNET_CAIP2 = `solana:${SOLANA_MAINNET_GENESIS}`;
+function toEvmCaip2(chainId) {
+  return `eip155:${chainId}`;
+}
+function targetChainToCaip2(targetChain) {
+  if (targetChain === "solana") return SOLANA_MAINNET_CAIP2;
+  if (targetChain === HYPERCORE_CHAIN_ID) return HYPERCORE_MAINNET_CAIP2;
+  return toEvmCaip2(targetChain);
+}
+function parseEvmChainId(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string") return null;
+  const match = value.match(/^eip155:(\d+)$/);
+  if (!match?.[1]) return null;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isSolanaCaip2(value) {
+  return typeof value === "string" && value.startsWith("solana:");
+}
+function isHyperCoreCaip2(value) {
+  return typeof value === "string" && value.startsWith("hypercore:");
+}
+var HYPERCORE_CHAIN_ID = 1337;
+var HYPERCORE_MAINNET_CAIP2 = "hypercore:mainnet";
+var HYPERCORE_USDC_ADDRESS = "0xb88339CB7199b77E23DB6E890353E22632Ba630f";
+var HYPERCORE_USDT0_ADDRESS = "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb";
+var HYPERCORE_SOURCE_TOKENS = [
+  { symbol: "USDC", address: HYPERCORE_USDC_ADDRESS, decimals: 6 },
+  { symbol: "USDT0", address: HYPERCORE_USDT0_ADDRESS, decimals: 6 }
+];
+var HYPERCORE_MIN_DEPOSIT_USD = 1;
+function isVirtualDestination(targetChain) {
+  return targetChain === "solana" || targetChain === HYPERCORE_CHAIN_ID;
+}
+
+// src/core/solana-tokens.ts
+var SOLANA_TOKENS = [
+  { symbol: "SOL", mint: "native", decimals: 9 },
+  {
+    symbol: "USDC",
+    mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    decimals: 6
+  },
+  {
+    symbol: "USDT",
+    mint: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    decimals: 6
+  }
+];
+function getSolanaTokenBySymbol(symbol) {
+  return SOLANA_TOKENS.find(
+    (t) => t.symbol.toUpperCase() === symbol.toUpperCase()
+  );
+}
+function getSolanaTokenByMint(mint) {
+  return SOLANA_TOKENS.find((t) => t.mint === mint);
+}
+function isNativeSol(token) {
+  return token.mint === "native";
+}
+
+// src/core/icons.ts
+import {
+  arbitrum,
+  base,
+  bsc,
+  gnosis,
+  hyperliquid,
+  katana,
+  mainnet,
+  monad,
+  optimism,
+  plasma,
+  polygon,
+  sonic,
+  soneium,
+  unichain
+} from "viem/chains";
+var ICON_CDN = "https://s3.rhinestone.dev";
+var CHAIN_ICON_SLUGS = {
+  [mainnet.id]: "mainnet",
+  [optimism.id]: "optimism",
+  [base.id]: "base",
+  [arbitrum.id]: "arbitrum",
+  [polygon.id]: "polygon",
+  [bsc.id]: "bsc",
+  [sonic.id]: "sonic",
+  [soneium.id]: "soneium",
+  [plasma.id]: "plasma",
+  [gnosis.id]: "gnosis",
+  [hyperliquid.id]: "hypeevm",
+  [monad.id]: "monad",
+  [unichain.id]: "unichain",
+  [katana.id]: "katana"
+};
+function cdnIconUrl(dir, slug) {
+  return `${ICON_CDN}/${dir}/${slug}.svg`;
+}
+var CHAIN_ICONS = Object.fromEntries(
+  Object.entries(CHAIN_ICON_SLUGS).map(([id, slug]) => [
+    Number(id),
+    cdnIconUrl("chains", slug)
+  ])
+);
+var SOLANA_CHAIN_ICON = cdnIconUrl("chains", "solana");
+function getChainIcon(chainId) {
+  if (chainId === "solana") return SOLANA_CHAIN_ICON;
+  if (chainId === "hypercore" || chainId === HYPERCORE_CHAIN_ID) {
+    return CHAIN_ICONS[hyperliquid.id];
+  }
+  return CHAIN_ICONS[chainId];
+}
+var ICON_SLUG_ALIASES = {
+  "usdc.e": "usdc",
+  wsol: "sol",
+  xdai: "dai"
+};
+function tokenIconUrl(symbol) {
+  const key = symbol.toLowerCase().replace(/₮/g, "t");
+  const slug = ICON_SLUG_ALIASES[key] ?? key;
+  return `https://s3.rhinestone.dev/tokens/${slug}.svg`;
+}
+function getTokenIcon(symbol) {
+  return tokenIconUrl(symbol);
+}
+
+// src/core/constants.ts
+import {
+  arbitrum as arbitrum2,
+  base as base2,
+  bsc as bsc2,
+  gnosis as gnosis2,
+  hyperliquid as hyperliquid2,
+  katana as katana2,
+  mainnet as mainnet2,
+  monad as monad2,
+  optimism as optimism2,
+  plasma as plasma2,
+  polygon as polygon2,
+  sonic as sonic2,
+  soneium as soneium2,
+  unichain as unichain2
+} from "viem/chains";
+var NATIVE_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ALL_CHAINS_BY_ID = {
+  [mainnet2.id]: mainnet2,
+  [base2.id]: base2,
+  [optimism2.id]: optimism2,
+  [arbitrum2.id]: arbitrum2,
+  [polygon2.id]: polygon2,
+  [bsc2.id]: bsc2,
+  [plasma2.id]: plasma2,
+  [soneium2.id]: soneium2,
+  [gnosis2.id]: gnosis2,
+  [sonic2.id]: sonic2,
+  [monad2.id]: monad2,
+  [unichain2.id]: unichain2,
+  [katana2.id]: katana2,
+  [hyperliquid2.id]: hyperliquid2
+};
+var SUPPORTED_TOKEN_MATRIX = {
+  ETH: [
+    mainnet2.id,
+    base2.id,
+    arbitrum2.id,
+    optimism2.id,
+    soneium2.id,
+    unichain2.id,
+    katana2.id
+  ],
+  // Polygon's native gas token is POL, not ETH (address 0x0 on 137 is POL).
+  POL: [polygon2.id],
+  WETH: [
+    mainnet2.id,
+    base2.id,
+    arbitrum2.id,
+    optimism2.id,
+    polygon2.id,
+    soneium2.id,
+    unichain2.id,
+    katana2.id
+  ],
+  USDC: [
+    mainnet2.id,
+    base2.id,
+    arbitrum2.id,
+    optimism2.id,
+    polygon2.id,
+    soneium2.id,
+    gnosis2.id,
+    sonic2.id,
+    monad2.id,
+    unichain2.id,
+    katana2.id,
+    hyperliquid2.id
+  ],
+  USDT: [mainnet2.id, bsc2.id, soneium2.id, katana2.id],
+  USDT0: [arbitrum2.id, optimism2.id, polygon2.id, plasma2.id, monad2.id, unichain2.id]
+};
+var CHAIN_DISPLAY_ORDER = [
+  mainnet2.id,
+  base2.id,
+  arbitrum2.id,
+  optimism2.id,
+  polygon2.id,
+  bsc2.id,
+  plasma2.id,
+  soneium2.id,
+  gnosis2.id,
+  sonic2.id,
+  monad2.id,
+  unichain2.id,
+  katana2.id,
+  hyperliquid2.id
+];
+var supportedChainSet = /* @__PURE__ */ new Set();
+for (const chainIds of Object.values(SUPPORTED_TOKEN_MATRIX)) {
+  for (const chainId of chainIds) {
+    supportedChainSet.add(chainId);
+  }
+}
+var SUPPORTED_CHAIN_IDS = CHAIN_DISPLAY_ORDER.filter(
+  (chainId) => supportedChainSet.has(chainId) && Boolean(ALL_CHAINS_BY_ID[chainId])
+);
+var CHAIN_BY_ID = Object.fromEntries(
+  SUPPORTED_CHAIN_IDS.map((id) => [id, ALL_CHAINS_BY_ID[id]])
+);
+var SOURCE_CHAINS = SUPPORTED_CHAIN_IDS.map(
+  (id) => CHAIN_BY_ID[id]
+);
+var SUPPORTED_CHAINS = SOURCE_CHAINS;
+var SUPPORTED_TOKENS_BY_CHAIN = Object.fromEntries(
+  SUPPORTED_CHAIN_IDS.map((chainId) => {
+    const symbols = Object.entries(SUPPORTED_TOKEN_MATRIX).filter(([, chainIds]) => chainIds.includes(chainId)).map(([symbol]) => symbol);
+    return [chainId, symbols];
+  })
+);
+var chainRegistry = {
+  [mainnet2.id]: {
+    name: mainnet2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        decimals: 18
+      },
+      {
+        symbol: "USDT",
+        address: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+        decimals: 6
+      }
+    ]
+  },
+  [hyperliquid2.id]: {
+    name: "HyperEVM",
+    tokens: [
+      { symbol: "HYPE", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: HYPERCORE_USDC_ADDRESS,
+        decimals: 6
+      }
+    ]
+  },
+  [base2.id]: {
+    name: base2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x4200000000000000000000000000000000000006",
+        decimals: 18
+      }
+    ]
+  },
+  [arbitrum2.id]: {
+    name: arbitrum2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+        decimals: 18
+      },
+      {
+        symbol: "USDT0",
+        address: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+        decimals: 6
+      }
+    ]
+  },
+  [optimism2.id]: {
+    name: optimism2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x4200000000000000000000000000000000000006",
+        decimals: 18
+      },
+      {
+        symbol: "USDT0",
+        address: "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
+        decimals: 6
+      }
+    ]
+  },
+  [polygon2.id]: {
+    name: polygon2.name,
+    tokens: [
+      // Polygon's native gas token is POL (0x0 on 137), not ETH.
+      { symbol: "POL", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+        decimals: 6
+      },
+      // Bridged USDC.e — what Polymarket withdrawals arrive as. Mapped to the
+      // USDC symbol/icon for display and 6 decimals so history rows resolve
+      // correctly. Listed after native USDC so symbol→address lookups (and
+      // the selectable token list, which is driven separately by
+      // SUPPORTED_TOKENS_BY_CHAIN) keep resolving USDC to the native address.
+      {
+        symbol: "USDC",
+        address: "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
+        decimals: 18
+      },
+      {
+        symbol: "USDT0",
+        address: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+        decimals: 6
+      }
+    ]
+  },
+  [bsc2.id]: {
+    name: bsc2.name,
+    tokens: [
+      {
+        symbol: "USDC",
+        address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+        decimals: 18
+      },
+      {
+        symbol: "WETH",
+        address: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+        decimals: 18
+      },
+      {
+        symbol: "USDT",
+        address: "0x55d398326f99059fF775485246999027B3197955",
+        decimals: 18
+      }
+    ]
+  },
+  [plasma2.id]: {
+    name: plasma2.name,
+    tokens: [
+      {
+        symbol: "USDT0",
+        address: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+        decimals: 6
+      }
+    ]
+  },
+  [soneium2.id]: {
+    name: soneium2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0xbA9986D2381edf1DA03B0B9c1f8b00dc4AacC369",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x4200000000000000000000000000000000000006",
+        decimals: 18
+      },
+      {
+        symbol: "USDT",
+        address: "0x3A337a6adA9d885b6Ad95ec48F9b75f197b5AE35",
+        decimals: 6
+      }
+    ]
+  },
+  [gnosis2.id]: {
+    name: gnosis2.name,
+    tokens: [
+      {
+        symbol: "USDC",
+        address: "0x2a22f9c3b484c3629090feed35f17ff8f88f76f0",
+        decimals: 6
+      }
+    ]
+  },
+  [sonic2.id]: {
+    name: sonic2.name,
+    tokens: [
+      {
+        symbol: "USDC",
+        address: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894",
+        decimals: 6
+      }
+    ]
+  },
+  [monad2.id]: {
+    name: monad2.name,
+    tokens: [
+      {
+        symbol: "USDC",
+        address: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+        decimals: 6
+      },
+      {
+        symbol: "USDT0",
+        address: "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+        decimals: 6
+      }
+    ]
+  },
+  [unichain2.id]: {
+    name: unichain2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0x078d782b760474a361dda0af3839290b0ef57ad6",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0x4200000000000000000000000000000000000006",
+        decimals: 18
+      },
+      {
+        symbol: "USDT0",
+        address: "0x9151434b16b9763660705744891fA906F660EcC5",
+        decimals: 6
+      }
+    ]
+  },
+  [katana2.id]: {
+    name: katana2.name,
+    tokens: [
+      { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18 },
+      {
+        symbol: "USDC",
+        address: "0x203a662b0bd271a6ed5a60edfbd04bfce608fd36",
+        decimals: 6
+      },
+      {
+        symbol: "USDT",
+        address: "0x2dca96907fde857dd3d816880a0df407eeb2d2f2",
+        decimals: 6
+      },
+      {
+        symbol: "WETH",
+        address: "0xEE7D8BCFb72bC1880D0Cf19822eB0A2e6577aB62",
+        decimals: 18
+      }
+    ]
+  },
+  // HyperCore (virtual chain 1337) is a USDC-only deposit *destination*. It has
+  // no viem chain / RPC, so it lives only here for name + token resolution —
+  // deliberately absent from the source-chain matrices above.
+  [HYPERCORE_CHAIN_ID]: {
+    name: "HyperCore",
+    // Destination truth: HyperCore delivery is USDC-only. The source path accepts
+    // USDT0 too, but that lives in HYPERCORE_SOURCE_TOKENS (caip.ts) so it can't
+    // leak into destination registration/display via this shared registry.
+    tokens: [{ symbol: "USDC", address: HYPERCORE_USDC_ADDRESS, decimals: 6 }]
+  }
+};
+function getChainId(chain) {
+  return typeof chain === "number" ? chain : chain.id;
+}
+function getChainObject(chain) {
+  if (typeof chain === "number") {
+    return CHAIN_BY_ID[chain];
+  }
+  return chain;
+}
+function normalizeTokenSymbol(symbol) {
+  const trimmed = symbol.trim();
+  const wrapped = trimmed.match(/\(([^)]+)\)/);
+  if (wrapped?.[1]) {
+    return wrapped[1].trim().toUpperCase();
+  }
+  return trimmed.toUpperCase();
+}
+function isSymbolSupportedOnChain(symbol, chainId) {
+  const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId];
+  if (!symbols) return false;
+  return symbols.includes(normalizeTokenSymbol(symbol));
+}
+function getTokenFromRegistry(chainId, symbol) {
+  const chainEntry = chainRegistry[String(chainId)];
+  if (!chainEntry) return void 0;
+  const normalized = normalizeTokenSymbol(symbol);
+  const token = chainEntry.tokens.find(
+    (t) => t.symbol.toUpperCase() === normalized
+  );
+  if (token) {
+    return { address: token.address, decimals: token.decimals };
+  }
+  return void 0;
+}
+function getUsdcAddress(chainId) {
+  const token = getTokenFromRegistry(chainId, "USDC");
+  return token?.address;
+}
+function getUsdcDecimals(chainId) {
+  const token = getTokenFromRegistry(chainId, "USDC");
+  return token?.decimals ?? 6;
+}
+function getTokenAddress(symbol, chainId) {
+  if (symbol.toUpperCase() === "ETH") {
+    if (!isSymbolSupportedOnChain("ETH", chainId)) {
+      return void 0;
+    }
+    return NATIVE_TOKEN_ADDRESS;
+  }
+  if (!isSymbolSupportedOnChain(symbol, chainId)) {
+    return void 0;
+  }
+  const token = getTokenFromRegistry(chainId, symbol);
+  return token?.address;
+}
+function getTokenDecimals(symbol, chainId) {
+  if (symbol.toUpperCase() === "ETH") {
+    return 18;
+  }
+  const token = getTokenFromRegistry(chainId, symbol);
+  return token?.decimals ?? 18;
+}
+function getTargetTokenSymbolsForChain(chainId) {
+  const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId] ?? [];
+  return [...symbols];
+}
+function getSupportedTokenSymbolsForChain(chainId) {
+  return getTargetTokenSymbolsForChain(chainId);
+}
+function getSupportedChainIds() {
+  return [...SUPPORTED_CHAIN_IDS];
+}
+function isSupportedTokenAddressForChain(token, chainId) {
+  const normalized = token.toLowerCase();
+  if (normalized === NATIVE_TOKEN_ADDRESS) {
+    return Boolean(SUPPORTED_TOKENS_BY_CHAIN[chainId]);
+  }
+  const symbol = getTokenSymbol(token, chainId);
+  if (!symbol || symbol === "Token") return false;
+  if (!isSymbolSupportedOnChain(symbol, chainId)) return false;
+  const expected = getTokenFromRegistry(chainId, symbol);
+  if (!expected) return false;
+  return expected.address.toLowerCase() === normalized;
+}
+function getSupportedTargetTokens(chainId) {
+  const symbols = getSupportedTokenSymbolsForChain(chainId);
+  const options = [];
+  for (const symbol of symbols) {
+    const address = getTokenAddress(symbol, chainId);
+    if (!address) continue;
+    options.push({
+      symbol,
+      address,
+      decimals: getTokenDecimals(symbol, chainId)
+    });
+  }
+  return options;
+}
+function findTokenDecimals(token, chainId) {
+  const normalized = token.toLowerCase();
+  if (normalized === NATIVE_TOKEN_ADDRESS) {
+    return 18;
+  }
+  if (chainId) {
+    const chainEntry = chainRegistry[String(chainId)];
+    if (chainEntry) {
+      const found = chainEntry.tokens.find(
+        (t) => t.address.toLowerCase() === normalized
+      );
+      if (found) return found.decimals;
+    }
+  }
+  for (const chainEntry of Object.values(chainRegistry)) {
+    const found = chainEntry.tokens.find(
+      (t) => t.address.toLowerCase() === normalized
+    );
+    if (found) return found.decimals;
+  }
+  return void 0;
+}
+function getTokenDecimalsByAddress(token, chainId) {
+  return findTokenDecimals(token, chainId) ?? 18;
+}
+function findChainIdForToken(address) {
+  const normalized = address.toLowerCase();
+  for (const [chainIdStr, chainEntry] of Object.entries(chainRegistry)) {
+    for (const token of chainEntry.tokens) {
+      if (token.address.toLowerCase() === normalized) {
+        return Number(chainIdStr);
+      }
+    }
+  }
+  return void 0;
+}
+function isRegistryTokenOnChain(token, chainId) {
+  const normalized = token.toLowerCase();
+  if (normalized === NATIVE_TOKEN_ADDRESS) return true;
+  const chainEntry = chainRegistry[String(chainId)];
+  return chainEntry ? chainEntry.tokens.some((t) => t.address.toLowerCase() === normalized) : false;
+}
+var NATIVE_SYMBOL_BY_CHAIN = {
+  [bsc2.id]: "BNB",
+  [plasma2.id]: "XPL",
+  [polygon2.id]: "POL",
+  [gnosis2.id]: "XDAI",
+  [sonic2.id]: "S",
+  [monad2.id]: "MON",
+  [hyperliquid2.id]: "HYPE"
+};
+function getNativeSymbol(chainId) {
+  return chainId != null && NATIVE_SYMBOL_BY_CHAIN[chainId] || "ETH";
+}
+function getTokenSymbol(token, chainId) {
+  const normalized = token.toLowerCase();
+  if (normalized === NATIVE_TOKEN_ADDRESS) {
+    return getNativeSymbol(chainId);
+  }
+  if (chainId) {
+    const chainEntry = chainRegistry[String(chainId)];
+    if (chainEntry) {
+      const found = chainEntry.tokens.find(
+        (t) => t.address.toLowerCase() === normalized
+      );
+      if (found) return found.symbol;
+    }
+  }
+  for (const chainEntry of Object.values(chainRegistry)) {
+    const found = chainEntry.tokens.find(
+      (t) => t.address.toLowerCase() === normalized
+    );
+    if (found) return found.symbol;
+  }
+  return "Token";
+}
+function getTargetTokenSymbol(token, chain) {
+  if (chain === "solana") {
+    return getSolanaTokenByMint(String(token))?.symbol ?? "Token";
+  }
+  return getTokenSymbol(token, chain);
+}
+function isStablecoinSymbol(symbol) {
+  return /^(usdc|usdt|usdt0|dai|usd)$/i.test(symbol);
+}
+var CHAIN_BADGES = {
+  [mainnet2.id]: { shortLabel: "ETH", color: "#627EEA", bg: "#EEF2FF" },
+  [base2.id]: { shortLabel: "Base", color: "#0052FF", bg: "#E7F0FF" },
+  [optimism2.id]: { shortLabel: "OP", color: "#FF0420", bg: "#FFE9EC" },
+  [arbitrum2.id]: { shortLabel: "Arb", color: "#28A0F0", bg: "#E6F6FF" },
+  [polygon2.id]: { shortLabel: "Matic", color: "#8247E5", bg: "#EFE7FF" },
+  [bsc2.id]: { shortLabel: "BSC", color: "#F3BA2F", bg: "#FFF8E0" },
+  [plasma2.id]: { shortLabel: "Plasma", color: "#6C47FF", bg: "#EDE7FF" },
+  [soneium2.id]: { shortLabel: "Soneium", color: "#0D0D0D", bg: "#E8E8E8" },
+  [sonic2.id]: { shortLabel: "Sonic", color: "#5B6DEF", bg: "#EDEFFE" },
+  [gnosis2.id]: { shortLabel: "Gnosis", color: "#3E6957", bg: "#E5F0EB" },
+  [hyperliquid2.id]: { shortLabel: "Hyper", color: "#5BE7C4", bg: "#E5FFF8" },
+  [monad2.id]: { shortLabel: "Monad", color: "#6E54FF", bg: "#EEEBFF" },
+  [unichain2.id]: { shortLabel: "Uni", color: "#F50DB4", bg: "#FFE5F5" },
+  [katana2.id]: { shortLabel: "Katana", color: "#0441B2", bg: "#E5EEFC" },
+  [HYPERCORE_CHAIN_ID]: {
+    shortLabel: "HyperCore",
+    color: "#5BE7C4",
+    bg: "#E5FFF8"
+  }
+};
+function resolveDisplayChainId(chainId) {
+  return chainId === "hypercore" ? HYPERCORE_CHAIN_ID : chainId;
+}
+var HYPERCORE_EXPLORER_URL = "https://app.hyperliquid.xyz/explorer";
+function getChainName(chainId) {
+  if (chainId === "solana") return "Solana";
+  const id = resolveDisplayChainId(chainId);
+  const chain = CHAIN_BY_ID[id];
+  if (chain) return chain.name;
+  const chainEntry = chainRegistry[String(id)];
+  if (chainEntry) return chainEntry.name;
+  return `Chain ${id}`;
+}
+function getChainBadge(chainId) {
+  if (chainId === "solana") {
+    return { shortLabel: "SOL", color: "#9945FF", bg: "#F3EEFF" };
+  }
+  return CHAIN_BADGES[resolveDisplayChainId(chainId)] || {
+    shortLabel: "Net",
+    color: "#64748B",
+    bg: "#F1F5F9"
+  };
+}
+function getExplorerUrl(chainId) {
+  if (chainId === "solana") return "https://solscan.io";
+  if (chainId === "hypercore") return HYPERCORE_EXPLORER_URL;
+  return CHAIN_BY_ID[chainId]?.blockExplorers?.default?.url;
+}
+function getExplorerTxUrl(chainId, txHash) {
+  if (chainId === "solana") return `https://solscan.io/tx/${txHash}`;
+  if (chainId === "hypercore" && !txHash.startsWith("0x")) return void 0;
+  const url = getExplorerUrl(chainId);
+  if (!url) return void 0;
+  return `${url}/tx/${txHash}`;
+}
+function getExplorerName(chainId) {
+  if (chainId === "solana") return "Solscan";
+  if (chainId === "hypercore") return "Hyperliquid Explorer";
+  return CHAIN_BY_ID[chainId]?.blockExplorers?.default?.name ?? "Explorer";
+}
+
+export {
+  toEvmCaip2,
+  targetChainToCaip2,
+  parseEvmChainId,
+  isSolanaCaip2,
+  isHyperCoreCaip2,
+  HYPERCORE_CHAIN_ID,
+  HYPERCORE_MAINNET_CAIP2,
+  HYPERCORE_USDC_ADDRESS,
+  HYPERCORE_USDT0_ADDRESS,
+  HYPERCORE_SOURCE_TOKENS,
+  HYPERCORE_MIN_DEPOSIT_USD,
+  isVirtualDestination,
+  SOLANA_TOKENS,
+  getSolanaTokenBySymbol,
+  getSolanaTokenByMint,
+  isNativeSol,
+  ICON_CDN,
+  cdnIconUrl,
+  getChainIcon,
+  tokenIconUrl,
+  getTokenIcon,
+  NATIVE_TOKEN_ADDRESS,
+  CHAIN_BY_ID,
+  SOURCE_CHAINS,
+  SUPPORTED_CHAINS,
+  chainRegistry,
+  getChainId,
+  getChainObject,
+  getUsdcAddress,
+  getUsdcDecimals,
+  getTokenAddress,
+  getTokenDecimals,
+  getTargetTokenSymbolsForChain,
+  getSupportedTokenSymbolsForChain,
+  getSupportedChainIds,
+  isSupportedTokenAddressForChain,
+  getSupportedTargetTokens,
+  findTokenDecimals,
+  getTokenDecimalsByAddress,
+  findChainIdForToken,
+  isRegistryTokenOnChain,
+  getNativeSymbol,
+  getTokenSymbol,
+  getTargetTokenSymbol,
+  isStablecoinSymbol,
+  getChainName,
+  getChainBadge,
+  getExplorerUrl,
+  getExplorerTxUrl,
+  getExplorerName
+};