@rhinestone/deposit-modal 0.10.0 → 0.11.0

package/dist/{chunk-A223BLVC.mjs → chunk-53IFZGSF.mjs}

@@ -6,9 +6,13 @@ function toEvmCaip2(chainId) {
 }
 function targetChainToCaip2(targetChain) {
   if (targetChain === "solana") return SOLANA_MAINNET_CAIP2;
-  if (targetChain === HYPERCORE_CHAIN_ID) return HYPERCORE_MAINNET_CAIP2;
+  if (isHyperCoreDestination(targetChain)) return HYPERCORE_SPOT_CAIP2;
   return toEvmCaip2(targetChain);
 }
+function targetChainToAccountKey(targetChain) {
+  if (isHyperCoreDestination(targetChain)) return HYPERCORE_MAINNET_CAIP2;
+  return targetChainToCaip2(targetChain);
+}
 function parseEvmChainId(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -27,6 +31,13 @@ function isHyperCoreCaip2(value) {
 }
 var HYPERCORE_CHAIN_ID = 1337;
 var HYPERCORE_MAINNET_CAIP2 = "hypercore:mainnet";
+var HYPERCORE_SPOT_CAIP2 = "hypercore:spot";
+function targetChainToChainId(targetChain) {
+  return isHyperCoreDestination(targetChain) ? "hypercore" : targetChain;
+}
+function isHyperCoreDestination(targetChain) {
+  return targetChain === HYPERCORE_SPOT_CAIP2 || targetChain === HYPERCORE_CHAIN_ID;
+}
 var HYPERCORE_USDC_ADDRESS = "0xb88339CB7199b77E23DB6E890353E22632Ba630f";
 var HYPERCORE_USDT0_ADDRESS = "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb";
 var HYPERCORE_SOURCE_TOKENS = [
@@ -35,7 +46,7 @@ var HYPERCORE_SOURCE_TOKENS = [
 ];
 var HYPERCORE_MIN_DEPOSIT_USD = 1;
 function isVirtualDestination(targetChain) {
-  return targetChain === "solana" || targetChain === HYPERCORE_CHAIN_ID;
+  return targetChain === "solana" || isHyperCoreDestination(targetChain);
 }
 
 // src/core/solana-tokens.ts
@@ -81,6 +92,29 @@ import {
   soneium,
   unichain
 } from "viem/chains";
+
+// src/core/runtime-chain-meta.ts
+var byChainId = /* @__PURE__ */ new Map();
+function setRuntimeChainMeta(entries) {
+  for (const entry of entries) {
+    byChainId.set(entry.chainId, {
+      name: entry.name,
+      iconUrl: entry.iconUrl,
+      nativeSymbol: entry.nativeSymbol
+    });
+  }
+}
+function getRuntimeNativeSymbol(chainId) {
+  return byChainId.get(chainId)?.nativeSymbol;
+}
+function getRuntimeChainName(chainId) {
+  return byChainId.get(chainId)?.name;
+}
+function getRuntimeChainIconUrl(chainId) {
+  return byChainId.get(chainId)?.iconUrl;
+}
+
+// src/core/icons.ts
 var ICON_CDN = "https://s3.rhinestone.dev";
 var CHAIN_ICON_SLUGS = {
   [mainnet.id]: "mainnet",
@@ -96,7 +130,13 @@ var CHAIN_ICON_SLUGS = {
   [hyperliquid.id]: "hypeevm",
   [monad.id]: "monad",
   [unichain.id]: "unichain",
-  [katana.id]: "katana"
+  [katana.id]: "katana",
+  // Live deposit sources that predate this map being catalog-backed. Kept as
+  // plain ids rather than viem imports: this is the FALLBACK for chains the
+  // backend has not annotated with `iconUrl` yet, so it should not grow a
+  // build-time dependency on a chain definition to name a file.
+  43114: "avalanche",
+  4663: "robinhood"
 };
 function cdnIconUrl(dir, slug) {
   return `${ICON_CDN}/${dir}/${slug}.svg`;
@@ -113,12 +153,18 @@ function getChainIcon(chainId) {
   if (chainId === "hypercore" || chainId === HYPERCORE_CHAIN_ID) {
     return CHAIN_ICONS[hyperliquid.id];
   }
-  return CHAIN_ICONS[chainId];
+  return CHAIN_ICONS[chainId] ?? getRuntimeChainIconUrl(chainId);
 }
 var ICON_SLUG_ALIASES = {
   "usdc.e": "usdc",
   wsol: "sol",
-  xdai: "dai"
+  xdai: "dai",
+  // A wrapped token is the same asset and the CDN hosts only the underlying
+  // mark, so these fall back to it rather than to a text badge. `weth` is the
+  // one the deposit flow offers on nearly every chain, and it has been showing
+  // as text since the icons moved to the CDN.
+  weth: "eth",
+  wavax: "avax"
 };
 function tokenIconUrl(symbol) {
   const key = symbol.toLowerCase().replace(/₮/g, "t");
@@ -146,6 +192,70 @@ import {
   soneium as soneium2,
   unichain as unichain2
 } from "viem/chains";
+
+// src/core/runtime-token-meta.ts
+var bySymbol = /* @__PURE__ */ new Map();
+var byAddress = /* @__PURE__ */ new Map();
+var symbolsByChain = /* @__PURE__ */ new Map();
+function symbolKey(chainId, symbol) {
+  return `${chainId}:${symbol.trim().toUpperCase()}`;
+}
+function addressKey(chainId, address) {
+  return `${chainId}:${address.toLowerCase()}`;
+}
+function setRuntimeTokens(tokens) {
+  for (const token of tokens) {
+    const sKey = symbolKey(token.chainId, token.symbol);
+    if (!bySymbol.has(sKey)) {
+      bySymbol.set(sKey, token);
+      const list = symbolsByChain.get(token.chainId);
+      if (list) list.push(token.symbol);
+      else symbolsByChain.set(token.chainId, [token.symbol]);
+    }
+    byAddress.set(addressKey(token.chainId, token.address), token);
+  }
+}
+function publishShortlistTokens(shortlist) {
+  const tokens = [];
+  for (const [chainKey, entries] of Object.entries(shortlist)) {
+    const chainId = Number(chainKey);
+    if (!Number.isInteger(chainId)) continue;
+    for (const entry of entries) {
+      if (!/^0x[a-fA-F0-9]{40}$/.test(entry.address)) continue;
+      tokens.push({
+        chainId,
+        symbol: entry.symbol,
+        address: entry.address,
+        decimals: entry.decimals
+      });
+    }
+  }
+  setRuntimeTokens(tokens);
+}
+function getRuntimeToken(chainId, symbol) {
+  return bySymbol.get(symbolKey(chainId, symbol));
+}
+function getRuntimeTokenByAddress(chainId, address) {
+  return byAddress.get(addressKey(chainId, address));
+}
+function getRuntimeTokenSymbols(chainId) {
+  return symbolsByChain.get(chainId) ?? [];
+}
+function findRuntimeDecimalsByAddress(address) {
+  return findByAddress(address)?.decimals;
+}
+function findRuntimeSymbolByAddress(address) {
+  return findByAddress(address)?.symbol;
+}
+function findByAddress(address) {
+  const suffix = `:${address.toLowerCase()}`;
+  for (const [key, token] of byAddress) {
+    if (key.endsWith(suffix)) return token;
+  }
+  return void 0;
+}
+
+// src/core/constants.ts
 var NATIVE_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ALL_CHAINS_BY_ID = {
   [mainnet2.id]: mainnet2,
@@ -520,13 +630,14 @@ function normalizeTokenSymbol(symbol) {
   return trimmed.toUpperCase();
 }
 function isSymbolSupportedOnChain(symbol, chainId) {
+  const normalized = normalizeTokenSymbol(symbol);
   const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId];
-  if (!symbols) return false;
-  return symbols.includes(normalizeTokenSymbol(symbol));
+  if (symbols?.includes(normalized)) return true;
+  return getRuntimeToken(chainId, normalized) !== void 0;
 }
 function getTokenFromRegistry(chainId, symbol) {
   const chainEntry = chainRegistry[String(chainId)];
-  if (!chainEntry) return void 0;
+  if (!chainEntry) return runtimeToken(chainId, normalizeTokenSymbol(symbol));
   const normalized = normalizeTokenSymbol(symbol);
   const token = chainEntry.tokens.find(
     (t) => t.symbol.toUpperCase() === normalized
@@ -534,7 +645,11 @@ function getTokenFromRegistry(chainId, symbol) {
   if (token) {
     return { address: token.address, decimals: token.decimals };
   }
-  return void 0;
+  return runtimeToken(chainId, normalized);
+}
+function runtimeToken(chainId, symbol) {
+  const token = getRuntimeToken(chainId, symbol);
+  return token ? { address: token.address, decimals: token.decimals } : void 0;
 }
 function getUsdcAddress(chainId) {
   const token = getTokenFromRegistry(chainId, "USDC");
@@ -565,8 +680,9 @@ function getTokenDecimals(symbol, chainId) {
   return token?.decimals ?? 18;
 }
 function getTargetTokenSymbolsForChain(chainId) {
-  const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId] ?? [];
-  return [...symbols];
+  const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId];
+  if (symbols?.length) return [...symbols];
+  return getRuntimeTokenSymbols(chainId);
 }
 function getSupportedTokenSymbolsForChain(chainId) {
   return getTargetTokenSymbolsForChain(chainId);
@@ -587,7 +703,13 @@ function isSupportedTokenAddressForChain(token, chainId) {
   return expected.address.toLowerCase() === normalized;
 }
 function getSupportedTargetTokens(chainId) {
-  const symbols = getSupportedTokenSymbolsForChain(chainId);
+  return toTokenOptions(getSupportedTokenSymbolsForChain(chainId), chainId);
+}
+function getBundledTargetTokens(chainId) {
+  const symbols = SUPPORTED_TOKENS_BY_CHAIN[chainId];
+  return symbols?.length ? toTokenOptions([...symbols], chainId) : [];
+}
+function toTokenOptions(symbols, chainId) {
   const options = [];
   for (const symbol of symbols) {
     const address = getTokenAddress(symbol, chainId);
@@ -620,7 +742,11 @@ function findTokenDecimals(token, chainId) {
     );
     if (found) return found.decimals;
   }
-  return void 0;
+  if (chainId) {
+    const onChain = getRuntimeTokenByAddress(chainId, normalized);
+    if (onChain) return onChain.decimals;
+  }
+  return findRuntimeDecimalsByAddress(normalized);
 }
 function getTokenDecimalsByAddress(token, chainId) {
   return findTokenDecimals(token, chainId) ?? 18;
@@ -652,7 +778,10 @@ var NATIVE_SYMBOL_BY_CHAIN = {
   [hyperliquid2.id]: "HYPE"
 };
 function getNativeSymbol(chainId) {
-  return chainId != null && NATIVE_SYMBOL_BY_CHAIN[chainId] || "ETH";
+  if (chainId == null) return "ETH";
+  const bundled = NATIVE_SYMBOL_BY_CHAIN[chainId];
+  if (bundled) return bundled;
+  return getRuntimeNativeSymbol(chainId) ?? "ETH";
 }
 function getTokenSymbol(token, chainId) {
   const normalized = token.toLowerCase();
@@ -674,13 +803,17 @@ function getTokenSymbol(token, chainId) {
     );
     if (found) return found.symbol;
   }
-  return "Token";
+  if (chainId) {
+    const onChain = getRuntimeTokenByAddress(chainId, normalized);
+    if (onChain) return onChain.symbol;
+  }
+  return findRuntimeSymbolByAddress(normalized) ?? "Token";
 }
 function getTargetTokenSymbol(token, chain) {
   if (chain === "solana") {
     return getSolanaTokenByMint(String(token))?.symbol ?? "Token";
   }
-  return getTokenSymbol(token, chain);
+  return getTokenSymbol(token, resolveDisplayChainId(chain));
 }
 function isStablecoinSymbol(symbol) {
   return /^(usdc|usdt|usdt0|dai|usd)$/i.test(symbol);
@@ -717,17 +850,30 @@ function getChainName(chainId) {
   if (chain) return chain.name;
   const chainEntry = chainRegistry[String(id)];
   if (chainEntry) return chainEntry.name;
+  const runtimeName = getRuntimeChainName(id);
+  if (runtimeName) return runtimeName;
   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"
-  };
+  const id = resolveDisplayChainId(chainId);
+  const curated = CHAIN_BADGES[id];
+  if (curated) return curated;
+  const name = getRuntimeChainName(id);
+  if (!name) {
+    return { shortLabel: "Net", color: "#64748B", bg: "#F1F5F9" };
+  }
+  return { shortLabel: name, ...badgeColorsFor(name) };
+}
+function badgeColorsFor(name) {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = hash * 31 + name.charCodeAt(i) | 0;
+  }
+  const hue = Math.abs(hash) % 360;
+  return { color: `hsl(${hue} 55% 38%)`, bg: `hsl(${hue} 70% 95%)` };
 }
 function getExplorerUrl(chainId) {
   if (chainId === "solana") return "https://solscan.io";
@@ -748,13 +894,18 @@ function getExplorerName(chainId) {
 }
 
 export {
+  SOLANA_MAINNET_CAIP2,
   toEvmCaip2,
   targetChainToCaip2,
+  targetChainToAccountKey,
   parseEvmChainId,
   isSolanaCaip2,
   isHyperCoreCaip2,
   HYPERCORE_CHAIN_ID,
   HYPERCORE_MAINNET_CAIP2,
+  HYPERCORE_SPOT_CAIP2,
+  targetChainToChainId,
+  isHyperCoreDestination,
   HYPERCORE_USDC_ADDRESS,
   HYPERCORE_USDT0_ADDRESS,
   HYPERCORE_SOURCE_TOKENS,
@@ -764,12 +915,16 @@ export {
   getSolanaTokenBySymbol,
   getSolanaTokenByMint,
   isNativeSol,
+  setRuntimeChainMeta,
+  setRuntimeTokens,
+  publishShortlistTokens,
   ICON_CDN,
   cdnIconUrl,
   getChainIcon,
   tokenIconUrl,
   getTokenIcon,
   NATIVE_TOKEN_ADDRESS,
+  CHAIN_DISPLAY_ORDER,
   CHAIN_BY_ID,
   SOURCE_CHAINS,
   SUPPORTED_CHAINS,
@@ -785,6 +940,7 @@ export {
   getSupportedChainIds,
   isSupportedTokenAddressForChain,
   getSupportedTargetTokens,
+  getBundledTargetTokens,
   findTokenDecimals,
   getTokenDecimalsByAddress,
   findChainIdForToken,