decane-connect-kit 0.0.1 → 1.0.1

package/dist/index.js

@@ -32,8 +32,12 @@ function createRegistry(emitter) {
     };
     if (incoming.chain === "evm") {
       account.evmProvider = incoming.provider;
-    } else {
+    } else if (incoming.chain === "solana") {
       account.solanaProvider = incoming.provider;
+    } else if (incoming.chain === "tron") {
+      account.tronProvider = incoming.provider;
+    } else if (incoming.chain === "bitcoin") {
+      account.bitcoinProvider = incoming.provider;
     }
     return account;
   }
@@ -44,12 +48,10 @@ function createRegistry(emitter) {
         incoming.chain
       ].sort();
     }
-    if (incoming.chain === "evm") {
-      existing.evmProvider = incoming.provider;
-    }
-    if (incoming.chain === "solana") {
-      existing.solanaProvider = incoming.provider;
-    }
+    if (incoming.chain === "evm") existing.evmProvider = incoming.provider;
+    if (incoming.chain === "solana") existing.solanaProvider = incoming.provider;
+    if (incoming.chain === "tron") existing.tronProvider = incoming.provider;
+    if (incoming.chain === "bitcoin") existing.bitcoinProvider = incoming.provider;
     if (!existing.icon && incoming.icon) existing.icon = incoming.icon;
   }
   function registerOrMerge(incoming) {
@@ -96,9 +98,9 @@ function createRegistry(emitter) {
       all: () => [...wallets],
       evm: () => wallets.filter((w) => w.chainSupport.includes("evm")),
       solana: () => wallets.filter((w) => w.chainSupport.includes("solana")),
-      multiChain: () => wallets.filter(
-        (w) => w.chainSupport.includes("evm") && w.chainSupport.includes("solana")
-      ),
+      tron: () => wallets.filter((w) => w.chainSupport.includes("tron")),
+      bitcoin: () => wallets.filter((w) => w.chainSupport.includes("bitcoin")),
+      multiChain: () => wallets.filter((w) => w.chainSupport.length >= 2),
       byId: (id) => wallets.find((w) => w.id === id)
     }
   };
@@ -681,11 +683,37 @@ var BUILT_IN_CHAINS = [
     name: "Solana Devnet",
     nativeCurrency: SOL,
     blockExplorerUrl: "https://solscan.io/?cluster=devnet"
+  },
+  // ── Tron ─────────────────────────────────────────────────────────────────────
+  {
+    id: "tron:mainnet",
+    type: "tron",
+    name: "Tron",
+    nativeCurrency: { name: "Tronix", symbol: "TRX", decimals: 6 },
+    blockExplorerUrl: "https://tronscan.org"
+  },
+  {
+    id: "tron:shasta",
+    type: "tron",
+    name: "Tron Shasta Testnet",
+    nativeCurrency: { name: "Tronix", symbol: "TRX", decimals: 6 },
+    blockExplorerUrl: "https://shasta.tronscan.org",
+    isCustom: true
+  },
+  // ── Bitcoin ───────────────────────────────────────────────────────────────────
+  {
+    id: "bip122:mainnet",
+    type: "bitcoin",
+    name: "Bitcoin",
+    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 8 },
+    blockExplorerUrl: "https://blockstream.info"
   }
 ];
 function getChainType(caip2Id) {
   if (caip2Id.startsWith("eip155:")) return "evm";
   if (caip2Id.startsWith("solana:")) return "solana";
+  if (caip2Id.startsWith("tron:")) return "tron";
+  if (caip2Id.startsWith("bip122:")) return "bitcoin";
   throw new Error(`Cannot determine chain type from: ${caip2Id}`);
 }
 function toCAIP10(chainId, address) {
@@ -701,6 +729,14 @@ var SOLANA_METHODS = /* @__PURE__ */ new Set([
   "wallet_signMessage"
   // wallet_signTypedData is EVM-only — never included here
 ]);
+var TRON_METHODS = /* @__PURE__ */ new Set([
+  "wallet_sendTransaction",
+  "wallet_signMessage"
+]);
+var BITCOIN_METHODS = /* @__PURE__ */ new Set([
+  "wallet_sendTransaction",
+  "wallet_signMessage"
+]);
 var CHAINS = {
   // Tier-1
   ETHEREUM: "eip155:1",
@@ -766,13 +802,17 @@ var CHAINS = {
   LOCALHOST: "eip155:31337",
   // Solana
   SOLANA: "solana:mainnet",
-  SOLANA_DEVNET: "solana:devnet"
+  SOLANA_DEVNET: "solana:devnet",
+  // Tron
+  TRON: "tron:mainnet",
+  // Bitcoin
+  BITCOIN: "bip122:mainnet"
 };
 function validateCustomChain(chain) {
   if (!chain || typeof chain !== "object") return false;
   const c = chain;
   if (typeof c.id !== "string" || !c.id) return false;
-  if (c.type !== "evm" && c.type !== "solana") return false;
+  if (c.type !== "evm" && c.type !== "solana" && c.type !== "tron" && c.type !== "bitcoin") return false;
   if (typeof c.name !== "string" || !c.name) return false;
   if (!c.nativeCurrency || typeof c.nativeCurrency !== "object") return false;
   if (c.type === "evm" && (typeof c.chainId !== "number" || !c.id.startsWith("eip155:")))
@@ -991,7 +1031,12 @@ async function walletStandardRequest(wallet, method, payload, account) {
       );
   }
 }
+function isSolanaAccount(a) {
+  return !a.chains?.length || a.chains.some((c) => c.startsWith("solana:"));
+}
 async function getSolanaAddress(wallet) {
+  const pre = wallet.accounts.find(isSolanaAccount);
+  if (pre) return base58.encode(pre.publicKey);
   const connectFeature = wallet.features["standard:connect"];
   if (!connectFeature) {
     throw new DecaneError(
@@ -1000,13 +1045,157 @@ async function getSolanaAddress(wallet) {
     );
   }
   const { accounts } = await connectFeature.connect();
-  if (!accounts?.[0]) {
+  const solanaAccount = accounts.find(isSolanaAccount);
+  if (!solanaAccount) {
     throw new DecaneError(
       4001 /* USER_REJECTED */,
       "No Solana accounts returned"
     );
   }
-  return base58.encode(accounts[0].publicKey);
+  return base58.encode(solanaAccount.publicKey);
+}
+
+// src/tron/adapter.ts
+function getTronWeb() {
+  if (typeof window === "undefined") return void 0;
+  const win = window;
+  return win.tronLink?.tronWeb ?? win.tronWeb;
+}
+async function getTronAddress(provider) {
+  const addr = getTronWeb()?.defaultAddress?.base58;
+  if (addr) return addr;
+  try {
+    const result = await provider.request({ method: "tron_requestAccounts" });
+    const accounts = result;
+    if (accounts?.[0]) return accounts[0];
+  } catch {
+  }
+  const result2 = await provider.request({ method: "tron_accounts" }).catch(() => null);
+  const accounts2 = result2;
+  if (accounts2?.[0]) return accounts2[0];
+  throw new DecaneError(4001 /* USER_REJECTED */, "No Tron accounts returned");
+}
+async function tronRequest(provider, method, payload, account) {
+  switch (method) {
+    case "wallet_signMessage":
+      return provider.request({
+        method: "tron_signMessage",
+        params: { message: payload }
+      });
+    case "wallet_sendTransaction": {
+      const tronWeb = getTronWeb();
+      const p = payload;
+      const toAddress = p.to;
+      const sunAmount = typeof p.value === "string" ? parseInt(p.value, 10) : p.value ?? 0;
+      let unsignedTx;
+      if (tronWeb?.transactionBuilder?.sendTrx) {
+        if (p.data && p.data !== "0x") {
+          const res = await tronWeb.transactionBuilder.triggerSmartContract(
+            toAddress,
+            "transfer(address,uint256)",
+            { callValue: 0, feeLimit: 1e8 },
+            [],
+            account
+          );
+          unsignedTx = res.transaction;
+        } else {
+          unsignedTx = await tronWeb.transactionBuilder.sendTrx(toAddress, sunAmount, account);
+        }
+      } else {
+        const host = tronWeb?.fullNode?.host ?? "https://api.trongrid.io";
+        const endpoint = p.data && p.data !== "0x" ? `${host}/wallet/triggersmartcontract` : `${host}/wallet/createtransaction`;
+        const body = p.data && p.data !== "0x" ? {
+          owner_address: account,
+          contract_address: toAddress,
+          function_selector: "transfer(address,uint256)",
+          fee_limit: 1e8,
+          call_value: 0,
+          visible: true
+        } : {
+          owner_address: account,
+          to_address: toAddress,
+          amount: sunAmount,
+          visible: true
+        };
+        const res = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          throw new DecaneError(
+            5022 /* PROVIDER_ERROR */,
+            `Failed to build Tron transaction: ${res.statusText}`
+          );
+        }
+        const json = await res.json();
+        unsignedTx = json.transaction ?? json;
+      }
+      let signedTx;
+      if (tronWeb?.trx?.sign) {
+        signedTx = await tronWeb.trx.sign(unsignedTx);
+      } else {
+        signedTx = await provider.request({
+          method: "tron_signTransaction",
+          params: unsignedTx
+        });
+      }
+      let txid;
+      if (tronWeb?.trx?.sendRawTransaction) {
+        const result = await tronWeb.trx.sendRawTransaction(signedTx);
+        txid = result?.txid;
+      } else {
+        const result = await provider.request({
+          method: "tron_sendRawTransaction",
+          params: signedTx
+        });
+        txid = result?.txid;
+      }
+      if (!txid) {
+        throw new DecaneError(5022 /* PROVIDER_ERROR */, "Tron transaction broadcast failed");
+      }
+      return txid;
+    }
+    default:
+      throw new DecaneError(
+        5030 /* METHOD_NOT_SUPPORTED */,
+        `Tron adapter: unsupported method ${method}`
+      );
+  }
+}
+
+// src/bitcoin/adapter.ts
+async function getBitcoinAddress(provider) {
+  const result = await provider.requestAccounts();
+  if (!result || result.length === 0) {
+    throw new DecaneError(4001 /* USER_REJECTED */, "No Bitcoin accounts returned");
+  }
+  const first = result[0];
+  return typeof first === "string" ? first : first.address;
+}
+async function bitcoinRequest(provider, method, payload, account) {
+  switch (method) {
+    case "wallet_signMessage":
+      return provider.signMessage(payload);
+    case "wallet_sendTransaction": {
+      const { to, value } = payload;
+      if (provider.sendBitcoin) {
+        return provider.sendBitcoin(to, value);
+      }
+      if (provider.send) {
+        return provider.send({ to, value, from: account });
+      }
+      throw new DecaneError(
+        5030 /* METHOD_NOT_SUPPORTED */,
+        "Bitcoin wallet does not support sendBitcoin"
+      );
+    }
+    default:
+      throw new DecaneError(
+        5030 /* METHOD_NOT_SUPPORTED */,
+        `Bitcoin adapter: unsupported method ${method}`
+      );
+  }
 }
 
 // src/core/router.ts
@@ -1057,20 +1246,23 @@ function createRouter(opts) {
       const chainType = getChainType(chainId);
       if (chainType === "evm" && !connectedWallet.evmProvider) continue;
       if (chainType === "solana" && !connectedWallet.solanaProvider) continue;
+      if (chainType === "tron" && !connectedWallet.tronProvider) continue;
+      if (chainType === "bitcoin" && !connectedWallet.bitcoinProvider) continue;
       let address;
       if (chainType === "evm") {
         address = await getEvmAddress(connectedWallet.evmProvider);
         if (chain.isCustom) {
-          await addEthereumChain(
-            connectedWallet.evmProvider,
-            chain
-          ).catch(() => {
+          await addEthereumChain(connectedWallet.evmProvider, chain).catch(() => {
           });
         }
-      } else {
+      } else if (chainType === "solana") {
         address = await getSolanaAddress(connectedWallet.solanaProvider);
+      } else if (chainType === "tron") {
+        address = await getTronAddress(connectedWallet.tronProvider);
+      } else {
+        address = await getBitcoinAddress(connectedWallet.bitcoinProvider);
       }
-      const methodSet = chainType === "evm" ? EVM_METHODS : SOLANA_METHODS;
+      const methodSet = chainType === "evm" ? EVM_METHODS : chainType === "solana" ? SOLANA_METHODS : chainType === "tron" ? TRON_METHODS : BITCOIN_METHODS;
       const grantedMethods = (scope?.methods ?? []).filter(
         (m) => methodSet.has(m)
       );
@@ -1149,19 +1341,13 @@ function createRouter(opts) {
       );
     }
     if (chainType === "evm") {
-      return eip1193Request(
-        wallet.evmProvider,
-        method,
-        payload,
-        account
-      );
+      return eip1193Request(wallet.evmProvider, method, payload, account);
+    } else if (chainType === "solana") {
+      return walletStandardRequest(wallet.solanaProvider, method, payload, account);
+    } else if (chainType === "tron") {
+      return tronRequest(wallet.tronProvider, method, payload, account);
     } else {
-      return walletStandardRequest(
-        wallet.solanaProvider,
-        method,
-        payload,
-        account
-      );
+      return bitcoinRequest(wallet.bitcoinProvider, method, payload, account);
     }
   }
   return { request };
@@ -1216,6 +1402,12 @@ function createProvider(opts) {
     get multiChainWallets() {
       return registry.get.multiChain();
     },
+    get tronWallets() {
+      return registry.get.tron();
+    },
+    get bitcoinWallets() {
+      return registry.get.bitcoin();
+    },
     // ── Connection ──────────────────────────────────────────────────────────
     async connect(wallet, preferredChain) {
       if (session.get()) {
@@ -1224,13 +1416,19 @@ function createProvider(opts) {
       }
       _connectedWallet = wallet;
       const support = wallet.chainSupport;
-      if (support.includes("evm") && preferredChain !== "solana") {
+      const hasEvm = support.includes("evm") && preferredChain !== "solana" && preferredChain !== "tron" && preferredChain !== "bitcoin";
+      const hasSol = support.includes("solana") && preferredChain !== "evm" && preferredChain !== "tron" && preferredChain !== "bitcoin";
+      const hasTron = support.includes("tron") && preferredChain !== "evm" && preferredChain !== "solana" && preferredChain !== "bitcoin";
+      const hasBitcoin = support.includes("bitcoin") && preferredChain !== "evm" && preferredChain !== "solana" && preferredChain !== "tron";
+      if (hasEvm) {
         _activeChain = config.defaultChain?.startsWith("eip155:") ? config.defaultChain : "eip155:1";
-      } else {
+      } else if (hasSol) {
         _activeChain = "solana:mainnet";
+      } else if (hasTron) {
+        _activeChain = "tron:mainnet";
+      } else if (hasBitcoin) {
+        _activeChain = "bip122:mainnet";
       }
-      const hasEvm = support.includes("evm") && preferredChain !== "solana";
-      const hasSol = support.includes("solana") && preferredChain !== "evm";
       const required = {};
       const optional = {};
       if (hasEvm) {
@@ -1254,6 +1452,34 @@ function createProvider(opts) {
           _activeChain = solChain;
         }
       }
+      if (hasTron) {
+        const tronChain = "tron:mainnet";
+        const scope = {
+          methods: ["wallet_sendTransaction", "wallet_signMessage"],
+          accounts: [],
+          events: []
+        };
+        if (hasEvm || hasSol) {
+          optional[tronChain] = scope;
+        } else {
+          required[tronChain] = scope;
+          _activeChain = tronChain;
+        }
+      }
+      if (hasBitcoin) {
+        const btcChain = "bip122:mainnet";
+        const scope = {
+          methods: ["wallet_sendTransaction", "wallet_signMessage"],
+          accounts: [],
+          events: []
+        };
+        if (hasEvm || hasSol || hasTron) {
+          optional[btcChain] = scope;
+        } else {
+          required[btcChain] = scope;
+          _activeChain = btcChain;
+        }
+      }
       await router.request({
         method: "wallet_requestPermissions",
         params: [{ requiredScopes: required, optionalScopes: optional }, wallet.id]
@@ -1321,6 +1547,58 @@ function createProvider(opts) {
   return provider;
 }
 
+// src/evm/bitcoinSnap.ts
+var BITCOIN_SNAP_IDS = [
+  "npm:@metamask/bitcoin-snap",
+  "npm:@consensys/btc-snap"
+];
+async function detectBitcoinSnap(provider) {
+  try {
+    const snaps = await provider.request({ method: "wallet_getSnaps" });
+    if (!snaps) return null;
+    for (const id of BITCOIN_SNAP_IDS) {
+      const snap = snaps[id];
+      if (snap && snap.blocked !== true) return id;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function makeBitcoinSnapProvider(snapId, evmProvider) {
+  function invoke(method, params) {
+    return evmProvider.request({
+      method: "wallet_invokeSnap",
+      params: [{ snapId, request: { method, params } }]
+    });
+  }
+  return {
+    async requestAccounts() {
+      const result = await invoke("btc_getAddress").catch(() => invoke("btc_getPublicKey"));
+      if (typeof result === "string") return [result];
+      if (Array.isArray(result)) return result;
+      return [];
+    },
+    async signMessage(message) {
+      return invoke("btc_signMessage", [message]);
+    },
+    async sendBitcoin(to, value) {
+      return invoke("btc_sendBitcoin", [{ to, satoshis: value }]);
+    }
+  };
+}
+async function tryRegisterBitcoinSnap(registry, name, icon, rdns, evmProvider) {
+  const snapId = await detectBitcoinSnap(evmProvider);
+  if (!snapId) return;
+  registry.registerOrMerge({
+    chain: "bitcoin",
+    name,
+    icon,
+    rdns,
+    provider: makeBitcoinSnapProvider(snapId, evmProvider)
+  });
+}
+
 // src/evm/discovery.ts
 function startEvmDiscovery(registry) {
   if (typeof window === "undefined") return;
@@ -1340,6 +1618,14 @@ function startEvmDiscovery(registry) {
         uuid: info.uuid,
         provider
       });
+      tryRegisterBitcoinSnap(
+        registry,
+        info.name,
+        info.icon,
+        info.rdns,
+        provider
+      ).catch(() => {
+      });
     }
   );
   window.dispatchEvent(new CustomEvent("eip6963:requestProvider"));
@@ -1380,6 +1666,53 @@ function startSolanaDiscovery(registry) {
   );
 }
 
+// src/tron/discovery.ts
+var TRONLINK_RDNS = "link.tron.tronlink";
+var TRONLINK_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiI+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9IiNGRjAwMTMiLz48cG9seWdvbiBwb2ludHM9IjEyLDkgMjMsMTYgMTIsMjMiIGZpbGw9IndoaXRlIi8+PC9zdmc+";
+function startTronDiscovery(registry) {
+  let registered = false;
+  function tryRegister() {
+    if (registered || !window.tronLink) return;
+    registered = true;
+    registry.registerOrMerge({
+      chain: "tron",
+      name: "TronLink",
+      icon: TRONLINK_ICON,
+      rdns: TRONLINK_RDNS,
+      provider: window.tronLink
+    });
+  }
+  tryRegister();
+  window.addEventListener("tronLink#initialized", tryRegister, { once: true });
+  const start = Date.now();
+  const poll = setInterval(() => {
+    tryRegister();
+    if (registered || Date.now() - start > 3e3) clearInterval(poll);
+  }, 200);
+}
+
+// src/bitcoin/discovery.ts
+var BTC_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiI+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9IiNGNzkzMUEiLz48dGV4dCB4PSIxNi41IiB5PSIyMiIgdGV4dC1hbmNob3I9Im1pZGRsZSIgZm9udC1zaXplPSIxNiIgZm9udC13ZWlnaHQ9IjcwMCIgZmlsbD0id2hpdGUiIGZvbnQtZmFtaWx5PSJBcmlhbCxzeXN0ZW0tdWkiPuKmojwvdGV4dD48L3N2Zz4=";
+function startBitcoinDiscovery(registry) {
+  setTimeout(() => {
+    const candidates = [
+      { name: "Unisat", rdns: "io.unisat.wallet", provider: window.unisat },
+      // OKX shares rdns with its EVM provider — merges into the EVM entry automatically
+      { name: "OKX Wallet", rdns: "com.okex.okxwallet", provider: window.okxwallet?.bitcoin }
+    ];
+    for (const { name, rdns, provider } of candidates) {
+      if (!provider) continue;
+      registry.registerOrMerge({
+        chain: "bitcoin",
+        name,
+        icon: BTC_ICON,
+        rdns,
+        provider
+      });
+    }
+  }, 150);
+}
+
 // src/factory.ts
 function createDecane(config = {}) {
   const emitter = createEmitter();
@@ -1393,6 +1726,8 @@ function createDecane(config = {}) {
   const router = createRouter({ registry, session, chainStore });
   startEvmDiscovery(registry);
   startSolanaDiscovery(registry);
+  startTronDiscovery(registry);
+  startBitcoinDiscovery(registry);
   return createProvider({ config, registry, session, chainStore, router, emitter });
 }
 
@@ -1560,6 +1895,67 @@ function WalletIcon({ src, name, size = 36 }) {
     initial
   );
 }
+function EthCircle({ size }) {
+  const s = size;
+  return /* @__PURE__ */ React.createElement("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none" }, /* @__PURE__ */ React.createElement("circle", { cx: "8", cy: "8", r: "8", fill: "#627EEA" }), /* @__PURE__ */ React.createElement("polygon", { points: "8,2.5 11.5,8 8,9.8 4.5,8", fill: "white", fillOpacity: "0.9" }), /* @__PURE__ */ React.createElement("polygon", { points: "8,9.8 11.5,8 8,13.5", fill: "white", fillOpacity: "0.6" }), /* @__PURE__ */ React.createElement("polygon", { points: "8,9.8 4.5,8 8,13.5", fill: "white", fillOpacity: "0.8" }), /* @__PURE__ */ React.createElement("polygon", { points: "8,2.5 8,9.8 4.5,8", fill: "white", fillOpacity: "0.6" }));
+}
+function SolCircle({ size }) {
+  const s = size;
+  return /* @__PURE__ */ React.createElement("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none" }, /* @__PURE__ */ React.createElement("circle", { cx: "8", cy: "8", r: "8", fill: "#9945FF" }), /* @__PURE__ */ React.createElement("rect", { x: "4", y: "4.5", width: "7", height: "1.5", rx: "0.75", fill: "white", fillOpacity: "0.95" }), /* @__PURE__ */ React.createElement("rect", { x: "4", y: "7.25", width: "7", height: "1.5", rx: "0.75", fill: "white", fillOpacity: "0.95" }), /* @__PURE__ */ React.createElement("rect", { x: "4", y: "10", width: "5.5", height: "1.5", rx: "0.75", fill: "white", fillOpacity: "0.95" }));
+}
+function TronCircle({ size }) {
+  const s = size;
+  return /* @__PURE__ */ React.createElement("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none" }, /* @__PURE__ */ React.createElement("circle", { cx: "8", cy: "8", r: "8", fill: "#FF0013" }), /* @__PURE__ */ React.createElement("polygon", { points: "6,4.5 12,8 6,11.5", fill: "white", fillOpacity: "0.95" }));
+}
+function BitcoinCircle({ size }) {
+  const s = size;
+  return /* @__PURE__ */ React.createElement("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none" }, /* @__PURE__ */ React.createElement("circle", { cx: "8", cy: "8", r: "8", fill: "#F7931A" }), /* @__PURE__ */ React.createElement(
+    "text",
+    {
+      x: "8.3",
+      y: "11.5",
+      textAnchor: "middle",
+      fontSize: "8",
+      fontWeight: "700",
+      fill: "white",
+      fontFamily: "Arial, system-ui"
+    },
+    "\u20BF"
+  ));
+}
+function ChainCircleIcon({ chain, size }) {
+  switch (chain) {
+    case "evm":
+      return /* @__PURE__ */ React.createElement(EthCircle, { size });
+    case "solana":
+      return /* @__PURE__ */ React.createElement(SolCircle, { size });
+    case "tron":
+      return /* @__PURE__ */ React.createElement(TronCircle, { size });
+    case "bitcoin":
+      return /* @__PURE__ */ React.createElement(BitcoinCircle, { size });
+  }
+}
+var CHAIN_ORDER = ["evm", "solana", "tron", "bitcoin"];
+function ChainIconStack({ support, size = 16 }) {
+  const ordered = CHAIN_ORDER.filter((c) => support.includes(c));
+  if (ordered.length === 0) return null;
+  const overlap = Math.round(size * 0.35);
+  return /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", flexShrink: 0 } }, ordered.map((chain, i) => /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      key: chain,
+      style: {
+        marginLeft: i === 0 ? 0 : `-${overlap}px`,
+        zIndex: ordered.length - i,
+        position: "relative",
+        borderRadius: "50%",
+        lineHeight: 0,
+        boxShadow: i > 0 ? `0 0 0 1.5px var(--dc-bg, #fff)` : void 0
+      }
+    },
+    /* @__PURE__ */ React.createElement(ChainCircleIcon, { chain, size })
+  )));
+}
 
 // src/ui/WalletSelector.tsx
 var FONT_URL = "https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700;800&display=swap";
@@ -1586,21 +1982,6 @@ function injectFont() {
   link.href = FONT_URL;
   document.head.appendChild(link);
 }
-var badgeBase = {
-  display: "inline-flex",
-  alignItems: "center",
-  padding: "3px 8px",
-  borderRadius: 20,
-  fontSize: 10,
-  fontWeight: 700,
-  letterSpacing: "0.04em",
-  textTransform: "uppercase"
-};
-function ChainBadges({ chainSupport }) {
-  const hasEvm = chainSupport.includes("evm");
-  const hasSol = chainSupport.includes("solana");
-  return /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4 } }, hasEvm && /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-evm)", color: "var(--dc-badge-evm-text)" } }, "EVM"), hasSol && /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-sol)", color: "var(--dc-badge-sol-text)", border: "1px solid var(--dc-border)" } }, "SVM"));
-}
 function WalletRow({ wallet, onClick }) {
   const [hovered, setHovered] = useState(false);
   const [focused, setFocused] = useState(false);
@@ -1630,7 +2011,7 @@ function WalletRow({ wallet, onClick }) {
     },
     /* @__PURE__ */ React2.createElement(WalletIcon, { src: wallet.icon || void 0, name: wallet.name, size: 38 }),
     /* @__PURE__ */ React2.createElement("span", { style: { flex: 1, fontSize: 14, fontWeight: 600, color: "var(--dc-text)", letterSpacing: "-0.01em" } }, wallet.name),
-    /* @__PURE__ */ React2.createElement(ChainBadges, { chainSupport: wallet.chainSupport }),
+    /* @__PURE__ */ React2.createElement(ChainIconStack, { support: wallet.chainSupport, size: 16 }),
     /* @__PURE__ */ React2.createElement(
       "svg",
       {
@@ -1757,17 +2138,19 @@ function WalletSelector({
     const cs = w.chainSupport;
     if (networks === "evm") return cs.includes("evm");
     if (networks === "solana") return cs.includes("solana");
+    if (networks === "tron") return cs.includes("tron");
+    if (networks === "bitcoin") return cs.includes("bitcoin");
     return true;
   });
-  const baseWallets = filter === "evm" ? networkWallets.filter((w) => w.chainSupport.includes("evm")) : filter === "solana" ? networkWallets.filter((w) => w.chainSupport.includes("solana")) : networkWallets;
+  const baseWallets = filter === "evm" ? networkWallets.filter((w) => w.chainSupport.includes("evm")) : filter === "solana" ? networkWallets.filter((w) => w.chainSupport.includes("solana")) : filter === "tron" ? networkWallets.filter((w) => w.chainSupport.includes("tron")) : filter === "bitcoin" ? networkWallets.filter((w) => w.chainSupport.includes("bitcoin")) : networkWallets;
   const filtered = q ? baseWallets.filter((w) => w.name.toLowerCase().includes(q)) : baseWallets;
   function handleWalletClick(wallet) {
     const cs = wallet.chainSupport;
-    const isMulti = cs.includes("evm") && cs.includes("solana");
+    const isMulti = cs.length >= 2;
     if (isMulti && networks === "all") {
       setPendingWallet(wallet);
     } else {
-      const preference = networks === "evm" ? "evm" : networks === "solana" ? "solana" : void 0;
+      const preference = networks === "evm" ? "evm" : networks === "solana" ? "solana" : networks === "tron" ? "tron" : networks === "bitcoin" ? "bitcoin" : void 0;
       onConnect(wallet, preference);
       onClose();
     }
@@ -1902,28 +2285,44 @@ function WalletSelector({
           },
           /* @__PURE__ */ React2.createElement(WalletIcon, { src: pendingWallet.icon || void 0, name: pendingWallet.name, size: 36 }),
           /* @__PURE__ */ React2.createElement("div", null, /* @__PURE__ */ React2.createElement("div", { style: { fontSize: 14, fontWeight: 700, color: "var(--dc-text)" } }, pendingWallet.name), /* @__PURE__ */ React2.createElement("div", { style: { fontSize: 11, color: "var(--dc-text-muted)", marginTop: 2 } }, "Multi-chain wallet detected"))
-        ), /* @__PURE__ */ React2.createElement("div", { style: { padding: "0 12px 20px", display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React2.createElement(
+        ), /* @__PURE__ */ React2.createElement("div", { style: { padding: "0 12px 20px", display: "flex", flexDirection: "column", gap: 8 } }, pendingWallet.chainSupport.includes("evm") && /* @__PURE__ */ React2.createElement(
           ChainOption,
           {
             label: "EVM networks",
             description: "Connect your Ethereum-compatible address only",
-            badges: /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-evm)", color: "var(--dc-badge-evm-text)" } }, "EVM"),
+            badges: /* @__PURE__ */ React2.createElement(ChainIconStack, { support: ["evm"], size: 18 }),
             onClick: () => handleChainChoice("evm")
           }
-        ), /* @__PURE__ */ React2.createElement(
+        ), pendingWallet.chainSupport.includes("solana") && /* @__PURE__ */ React2.createElement(
           ChainOption,
           {
             label: "Solana network",
             description: "Connect your Solana address only",
-            badges: /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-sol)", color: "var(--dc-badge-sol-text)", border: "1px solid var(--dc-border)" } }, "SVM"),
+            badges: /* @__PURE__ */ React2.createElement(ChainIconStack, { support: ["solana"], size: 18 }),
             onClick: () => handleChainChoice("solana")
           }
+        ), pendingWallet.chainSupport.includes("tron") && /* @__PURE__ */ React2.createElement(
+          ChainOption,
+          {
+            label: "Tron network",
+            description: "Connect your Tron address only",
+            badges: /* @__PURE__ */ React2.createElement(ChainIconStack, { support: ["tron"], size: 18 }),
+            onClick: () => handleChainChoice("tron")
+          }
+        ), pendingWallet.chainSupport.includes("bitcoin") && /* @__PURE__ */ React2.createElement(
+          ChainOption,
+          {
+            label: "Bitcoin network",
+            description: "Connect your Bitcoin address only",
+            badges: /* @__PURE__ */ React2.createElement(ChainIconStack, { support: ["bitcoin"], size: 18 }),
+            onClick: () => handleChainChoice("bitcoin")
+          }
         ), /* @__PURE__ */ React2.createElement(
           ChainOption,
           {
-            label: "Both networks",
-            description: "Connect EVM and Solana addresses together",
-            badges: /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4 } }, /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-evm)", color: "var(--dc-badge-evm-text)" } }, "EVM"), /* @__PURE__ */ React2.createElement("span", { style: { ...badgeBase, background: "var(--dc-badge-sol)", color: "var(--dc-badge-sol-text)", border: "1px solid var(--dc-border)" } }, "SVM")),
+            label: "All networks",
+            description: "Connect all supported addresses together",
+            badges: /* @__PURE__ */ React2.createElement(ChainIconStack, { support: pendingWallet.chainSupport, size: 18 }),
             onClick: () => handleChainChoice(void 0)
           }
         )))
@@ -1998,7 +2397,7 @@ function WalletSelector({
               e.currentTarget.style.borderColor = "var(--dc-border)";
             }
           }
-        )), networks === "all" && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4, marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(FilterTab, { label: "All", active: filter === "all", onClick: () => setFilter("all") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "EVM", active: filter === "evm", onClick: () => setFilter("evm") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "Solana", active: filter === "solana", onClick: () => setFilter("solana") }))), /* @__PURE__ */ React2.createElement("div", { style: { overflowY: "auto", flex: 1, padding: "0 12px 20px" } }, filtered.length > 0 ? /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((w) => /* @__PURE__ */ React2.createElement(WalletRow, { key: w.id, wallet: w, onClick: () => handleWalletClick(w) }))) : /* @__PURE__ */ React2.createElement("div", { style: { textAlign: "center", padding: "32px 16px", color: "var(--dc-text-muted)", fontSize: 13 } }, q ? `No wallets matching "${q}"` : "No wallets detected")), /* @__PURE__ */ React2.createElement("div", { style: { padding: "10px 20px 14px", borderTop: "1px solid var(--dc-border)", textAlign: "center", fontSize: 11, color: "var(--dc-text-muted)" } }, "Don't see your wallet? Make sure it's installed and unlocked"))
+        )), networks === "all" && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4, marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(FilterTab, { label: "All", active: filter === "all", onClick: () => setFilter("all") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "EVM", active: filter === "evm", onClick: () => setFilter("evm") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "Solana", active: filter === "solana", onClick: () => setFilter("solana") }), provider.tronWallets && provider.tronWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Tron", active: filter === "tron", onClick: () => setFilter("tron") }), provider.bitcoinWallets && provider.bitcoinWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Bitcoin", active: filter === "bitcoin", onClick: () => setFilter("bitcoin") }))), /* @__PURE__ */ React2.createElement("div", { style: { overflowY: "auto", flex: 1, padding: "0 12px 20px" } }, filtered.length > 0 ? /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((w) => /* @__PURE__ */ React2.createElement(WalletRow, { key: w.id, wallet: w, onClick: () => handleWalletClick(w) }))) : /* @__PURE__ */ React2.createElement("div", { style: { textAlign: "center", padding: "32px 16px", color: "var(--dc-text-muted)", fontSize: 13 } }, q ? `No wallets matching "${q}"` : "No wallets detected")), /* @__PURE__ */ React2.createElement("div", { style: { padding: "10px 20px 14px", borderTop: "1px solid var(--dc-border)", textAlign: "center", fontSize: 11, color: "var(--dc-text-muted)" } }, "Don't see your wallet? Make sure it's installed and unlocked"))
       )
     )
   );
@@ -2060,6 +2459,11 @@ function useDecaneContext() {
 
 // src/ui/hooks.ts
 import { useState as useState3, useEffect as useEffect2, useCallback as useCallback3 } from "react";
+function toDecaneError(err) {
+  if (err instanceof DecaneError) return err;
+  const msg = err instanceof Error ? err.message : err?.message != null ? String(err.message) : String(err);
+  return new DecaneError(5022 /* PROVIDER_ERROR */, msg);
+}
 function useDecane() {
   const { provider, theme, setTheme } = useDecaneContext();
   const [, forceUpdate] = useState3(0);
@@ -2137,7 +2541,7 @@ function useChainSwitch() {
         });
         forceUpdate((n) => n + 1);
       } catch (err) {
-        const e = err instanceof DecaneError ? err : new DecaneError(5022 /* PROVIDER_ERROR */, String(err));
+        const e = toDecaneError(err);
         setError(e);
         throw err;
       } finally {
@@ -2188,7 +2592,7 @@ function useSignMessage() {
         setSignature(sig);
         return sig;
       } catch (err) {
-        const e = err instanceof DecaneError ? err : new DecaneError(5022 /* PROVIDER_ERROR */, String(err));
+        const e = toDecaneError(err);
         setError(e);
         throw err;
       } finally {
@@ -2226,7 +2630,7 @@ function useSendTransaction() {
         setTxHash(hash);
         return hash;
       } catch (err) {
-        const e = err instanceof DecaneError ? err : new DecaneError(5022 /* PROVIDER_ERROR */, String(err));
+        const e = toDecaneError(err);
         setError(e);
         throw err;
       } finally {
@@ -2263,7 +2667,7 @@ function useSignTypedData() {
         setSignature(sig);
         return sig;
       } catch (err) {
-        const e = err instanceof DecaneError ? err : new DecaneError(5022 /* PROVIDER_ERROR */, String(err));
+        const e = toDecaneError(err);
         setError(e);
         throw err;
       } finally {