@enclave-hq/wallet-sdk 1.2.3 → 1.2.5

package/dist/react/index.js

@@ -1,17 +1,589 @@
 'use strict';
 
-var React = require('react');
-var EventEmitter = require('eventemitter3');
 var chainUtils = require('@enclave-hq/chain-utils');
+var React2 = require('react');
+var EventEmitter = require('eventemitter3');
 var viem = require('viem');
 var accounts = require('viem/accounts');
+var EthereumProvider = require('@walletconnect/ethereum-provider');
+var walletconnectTron = require('@tronweb3/walletconnect-tron');
+var QRCode = require('qrcode');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React__default = /*#__PURE__*/_interopDefault(React);
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var EthereumProvider__default = /*#__PURE__*/_interopDefault(EthereumProvider);
+var QRCode__default = /*#__PURE__*/_interopDefault(QRCode);
 
-// src/react/WalletContext.tsx
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ChainType;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    ChainType = chainUtils.ChainType;
+  }
+});
+
+// src/adapters/deep-link/providers/tokenpocket.ts
+var tokenpocket_exports = {};
+__export(tokenpocket_exports, {
+  TokenPocketDeepLinkProvider: () => TokenPocketDeepLinkProvider
+});
+var TokenPocketDeepLinkProvider;
+var init_tokenpocket = __esm({
+  "src/adapters/deep-link/providers/tokenpocket.ts"() {
+    init_types();
+    TokenPocketDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "TokenPocket";
+        this.icon = "https://tokenpocket.pro/icon.png";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+        this.callbackUrl = options?.callbackUrl;
+        this.callbackSchema = options?.callbackSchema;
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      /**
+       * Generate unique actionId
+       */
+      generateActionId() {
+        return `web-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      }
+      /**
+       * Get callback configuration
+       */
+      getCallbackConfig() {
+        if (this.callbackSchema) {
+          return { callbackSchema: this.callbackSchema };
+        }
+        if (this.callbackUrl) {
+          return { callbackUrl: this.callbackUrl };
+        }
+        if (typeof window !== "undefined" && window.location) {
+          return {
+            callbackSchema: `${window.location.protocol}//${window.location.host}${window.location.pathname}`
+          };
+        }
+        return {};
+      }
+      /**
+       * Get blockchain configuration based on chain type
+       */
+      getBlockchainConfig(chainId, chainType) {
+        if (chainType === ChainType.TRON) {
+          return {
+            chainId: String(chainId),
+            network: "tron"
+          };
+        } else if (chainType === ChainType.EVM) {
+          return {
+            chainId: String(chainId),
+            network: "ethereum"
+          };
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+      }
+      buildSignMessageLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        const param = {
+          action: "sign",
+          actionId,
+          message: params.message,
+          hash: false,
+          signType: params.chainType === ChainType.TRON ? "ethPersonalSign" : "ethPersonalSign",
+          memo: `${params.chainType} message signature`,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.1.8",
+          expired: 0,
+          ...callback
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildSignTransactionLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        let transactionData;
+        if (typeof params.transaction === "string") {
+          transactionData = params.transaction;
+        } else {
+          transactionData = JSON.stringify(params.transaction);
+        }
+        const param = {
+          action: "pushTransaction",
+          actionId,
+          txData: transactionData,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.1.8",
+          expired: 0,
+          ...callback
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildConnectLink(params) {
+        const actionId = this.generateActionId();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        const param = {
+          action: "login",
+          actionId,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.0",
+          expired: 1602
+          // 30 minutes
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/tronlink.ts
+var tronlink_exports = {};
+__export(tronlink_exports, {
+  TronLinkDeepLinkProvider: () => TronLinkDeepLinkProvider
+});
+var TronLinkDeepLinkProvider;
+var init_tronlink = __esm({
+  "src/adapters/deep-link/providers/tronlink.ts"() {
+    init_types();
+    TronLinkDeepLinkProvider = class {
+      constructor() {
+        this.name = "TronLink";
+        this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+        this.supportedChainTypes = [ChainType.TRON];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const encodedMessage = encodeURIComponent(params.message);
+        const url = `tronlink://signMessage?message=${encodedMessage}`;
+        const actionId = `tronlink-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const encodedData = encodeURIComponent(transactionData);
+        const url = `tronlink://signTransaction?transaction=${encodedData}`;
+        const actionId = `tronlink-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const url = `tronlink://open?action=connect&network=tron`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(_urlParams) {
+        return {
+          actionId: null,
+          result: null,
+          error: null
+        };
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/imtoken.ts
+var imtoken_exports = {};
+__export(imtoken_exports, {
+  ImTokenDeepLinkProvider: () => ImTokenDeepLinkProvider
+});
+var ImTokenDeepLinkProvider;
+var init_imtoken = __esm({
+  "src/adapters/deep-link/providers/imtoken.ts"() {
+    init_types();
+    ImTokenDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "ImToken";
+        this.icon = "https://token.im/static/img/logo.png";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+        this.callbackUrl = options?.callbackUrl;
+        this.callbackSchema = options?.callbackSchema;
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      /**
+       * Generate unique actionId
+       */
+      generateActionId() {
+        return `imtoken-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      }
+      /**
+       * Get callback configuration
+       */
+      getCallbackConfig() {
+        if (this.callbackSchema) {
+          return { callbackSchema: this.callbackSchema };
+        }
+        if (this.callbackUrl) {
+          return { callbackUrl: this.callbackUrl };
+        }
+        if (typeof window !== "undefined" && window.location) {
+          return {
+            callbackSchema: `${window.location.protocol}//${window.location.host}${window.location.pathname}`
+          };
+        }
+        return {};
+      }
+      buildSignMessageLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildSignTransactionLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildConnectLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/metamask.ts
+var metamask_exports = {};
+__export(metamask_exports, {
+  MetaMaskDeepLinkProvider: () => MetaMaskDeepLinkProvider
+});
+var MetaMaskDeepLinkProvider;
+var init_metamask = __esm({
+  "src/adapters/deep-link/providers/metamask.ts"() {
+    init_types();
+    MetaMaskDeepLinkProvider = class {
+      constructor() {
+        this.name = "MetaMask";
+        this.icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+        this.supportedChainTypes = [ChainType.EVM];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        const actionId = `metamask-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        const actionId = `metamask-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/okx.ts
+var okx_exports = {};
+__export(okx_exports, {
+  OKXDeepLinkProvider: () => OKXDeepLinkProvider
+});
+var OKXDeepLinkProvider;
+var init_okx = __esm({
+  "src/adapters/deep-link/providers/okx.ts"() {
+    init_types();
+    OKXDeepLinkProvider = class {
+      constructor() {
+        this.name = "OKX";
+        this.icon = "https://www.okx.com/favicon.ico";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        const actionId = `okx-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        const actionId = `okx-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
 var TypedEventEmitter = class {
   constructor() {
     this.emitter = new EventEmitter__default.default();
@@ -40,7 +612,12 @@ var TypedEventEmitter = class {
     return this;
   }
 };
-var ChainType = chainUtils.ChainType;
+
+// src/core/adapter-registry.ts
+init_types();
+
+// src/adapters/base/wallet-adapter.ts
+init_types();
 
 // src/core/errors.ts
 var WalletSDKError = class _WalletSDKError extends Error {
@@ -111,6 +688,18 @@ var MethodNotSupportedError = class extends WalletSDKError {
     this.name = "MethodNotSupportedError";
   }
 };
+var ConfigurationError = class extends WalletSDKError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", details);
+    this.name = "ConfigurationError";
+  }
+};
+var NetworkError = class extends WalletSDKError {
+  constructor(message, details) {
+    super(message, "NETWORK_ERROR", details);
+    this.name = "NetworkError";
+  }
+};
 
 // src/adapters/base/wallet-adapter.ts
 var WalletAdapter = class extends EventEmitter__default.default {
@@ -120,6 +709,13 @@ var WalletAdapter = class extends EventEmitter__default.default {
     this.state = "disconnected" /* DISCONNECTED */;
     this.currentAccount = null;
   }
+  /**
+   * Check if the wallet is currently connected
+   * @returns true if the wallet is connected (state is CONNECTED and has an account)
+   */
+  isConnected() {
+    return this.state === "connected" /* CONNECTED */ && this.currentAccount !== null;
+  }
   /**
    * Get the signer's address (implements ISigner interface)
    * Returns the native address of the current account
@@ -189,6 +785,7 @@ var WalletAdapter = class extends EventEmitter__default.default {
 };
 
 // src/adapters/base/browser-wallet-adapter.ts
+init_types();
 var BrowserWalletAdapter = class extends WalletAdapter {
   /**
    * 检查钱包是否可用
@@ -222,6 +819,9 @@ var BrowserWalletAdapter = class extends WalletAdapter {
   }
 };
 
+// src/adapters/evm/metamask.ts
+init_types();
+
 // src/utils/address/universal-address.ts
 function createUniversalAddress(chainId, address) {
   return `${chainId}:${address}`;
@@ -246,7 +846,12 @@ var CHAIN_INFO = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrls: ["https://eth.llamarpc.com"],
+    // 使用支持浏览器 CORS 的公共 RPC，避免 dapp 域名被跨域拦截（如 eth.llamarpc.com 无 CORS 头）
+    rpcUrls: [
+      "https://cloudflare-eth.com",
+      "https://rpc.ankr.com/eth",
+      "https://eth.llamarpc.com"
+    ],
     blockExplorerUrls: ["https://etherscan.io"]
   },
   // EVM Testnets
@@ -466,6 +1071,7 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
    */
   async connect(chainId) {
     await this.ensureAvailable();
+    const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId;
     try {
       this.setState("connecting" /* CONNECTING */);
       const provider = this.getBrowserProvider();
@@ -479,10 +1085,10 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
         method: "eth_chainId"
       });
       const parsedChainId = parseInt(currentChainId, 16);
-      if (chainId && chainId !== parsedChainId) {
-        await this.switchChain(chainId);
+      if (targetChainId && targetChainId !== parsedChainId) {
+        await this.switchChain(targetChainId);
       }
-      const finalChainId = chainId || parsedChainId;
+      const finalChainId = targetChainId || parsedChainId;
       const viemChain = this.getViemChain(finalChainId);
       this.walletClient = viem.createWalletClient({
         account: accounts[0],
@@ -644,6 +1250,56 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
       }]
     });
   }
+  /**
+   * 请求切换账户
+   * 弹出 MetaMask 账户选择界面，让用户选择或切换到目标地址
+   * @param targetAddress 目标地址（可选），如果提供，会在切换后验证是否匹配
+   * @returns 切换后的账户信息
+   */
+  async requestSwitchAccount(targetAddress) {
+    const provider = this.getBrowserProvider();
+    if (!provider) {
+      throw new Error("MetaMask provider not available");
+    }
+    try {
+      await provider.request({
+        method: "wallet_requestPermissions",
+        params: [{ eth_accounts: {} }]
+      });
+      const accounts = await provider.request({
+        method: "eth_accounts"
+      });
+      if (!accounts || accounts.length === 0) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      const address = formatEVMAddress(accounts[0]);
+      if (targetAddress && address.toLowerCase() !== targetAddress.toLowerCase()) {
+        throw new Error(`\u8BF7\u5728 MetaMask \u4E2D\u9009\u62E9\u5730\u5740 ${targetAddress.slice(0, 6)}...${targetAddress.slice(-4)}\uFF0C\u5F53\u524D\u9009\u62E9\u7684\u662F ${address.slice(0, 6)}...${address.slice(-4)}`);
+      }
+      const chainId = this.currentAccount?.chainId || 1;
+      const account = {
+        universalAddress: createUniversalAddress(chainId, address),
+        nativeAddress: address,
+        chainId,
+        chainType: ChainType.EVM,
+        isActive: true
+      };
+      this.setAccount(account);
+      this.emitAccountChanged(account);
+      const viemChain = this.getViemChain(chainId);
+      this.walletClient = viem.createWalletClient({
+        account: address,
+        chain: viemChain,
+        transport: viem.custom(provider)
+      });
+      return account;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
   /**
    * 读取合约
    */
@@ -868,6 +1524,47 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
 };
 
 // src/adapters/tron/tronlink.ts
+init_types();
+var TronApiRateLimiter = class {
+  constructor(minIntervalMs = 600) {
+    this.lastCallTime = 0;
+    this.minInterval = minIntervalMs;
+  }
+  /**
+   * 等待直到可以进行下一次 API 调用
+   */
+  async waitForNextCall() {
+    const now = Date.now();
+    const timeSinceLastCall = now - this.lastCallTime;
+    if (timeSinceLastCall < this.minInterval) {
+      const waitTime = this.minInterval - timeSinceLastCall;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    this.lastCallTime = Date.now();
+  }
+};
+var tronApiRateLimiter = new TronApiRateLimiter(600);
+async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 500) {
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const errorMsg = error?.message || String(error);
+      const errorLower = errorMsg.toLowerCase();
+      const isRateLimitError = error?.response?.status === 429 || error?.status === 429 || errorLower.includes("429") || errorLower.includes("rate limit") || errorLower.includes("too many requests") || error?.code === "ERR_BAD_REQUEST" && error?.response?.status === 429;
+      if (isRateLimitError && attempt < maxRetries - 1) {
+        const delay = initialDelay * Math.pow(2, attempt);
+        console.warn(`[TronLink] \u9047\u5230\u901F\u7387\u9650\u5236 (429)\uFF0C\u7B49\u5F85 ${delay}ms \u540E\u91CD\u8BD5 (${attempt + 1}/${maxRetries})...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
 var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   constructor() {
     super(...arguments);
@@ -915,6 +1612,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
    */
   async connect(chainId) {
     await this.ensureAvailable();
+    const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId;
     try {
       this.setState("connecting" /* CONNECTING */);
       const w = window;
@@ -969,7 +1667,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       if (!address) {
         throw new Error("Failed to get Tron address. Please make sure your wallet is unlocked and try again.");
       }
-      const tronChainId = chainId || _TronLinkAdapter.TRON_MAINNET_CHAIN_ID;
+      const tronChainId = targetChainId || _TronLinkAdapter.TRON_MAINNET_CHAIN_ID;
       const account = {
         universalAddress: createUniversalAddress(tronChainId, address),
         nativeAddress: address,
@@ -1044,10 +1742,12 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   /**
    * 读取合约
    * 参考 webserver 的实现，使用 TronWeb 合约实例的标准 call() 方法
+   * 带 TronGrid 限流 + 429 重试
    */
   async readContract(params) {
     this.ensureConnected();
-    try {
+    await tronApiRateLimiter.waitForNextCall();
+    const doRead = async () => {
       const tronWeb = this.getTronWeb();
       if (!this.currentAccount) {
         throw new Error("No account connected");
@@ -1062,19 +1762,17 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
         return result;
       } catch (method1Error) {
         console.warn("\u26A0\uFE0F [\u65B9\u6CD51] TronWeb\u6807\u51C6\u65B9\u6CD5\u5931\u8D25\uFF0C\u5C1D\u8BD5\u65B9\u6CD52:", method1Error.message);
-        try {
-          const contract2 = await tronWeb.contract().at(params.address);
-          const method2 = contract2[params.functionName];
-          if (!method2 || typeof method2 !== "function") {
-            throw new Error(`Function ${params.functionName} not found in contract`);
-          }
-          const result = await method2(...params.args || []).call();
-          return result;
-        } catch (method2Error) {
-          console.error("\u26A0\uFE0F [\u65B9\u6CD52] \u4E5F\u5931\u8D25:", method2Error.message);
-          throw method1Error;
+        const contract2 = await tronWeb.contract().at(params.address);
+        const method2 = contract2[params.functionName];
+        if (!method2 || typeof method2 !== "function") {
+          throw new Error(`Function ${params.functionName} not found in contract`);
         }
+        const result = await method2(...params.args || []).call();
+        return result;
       }
+    };
+    try {
+      return await retryWithBackoff(doRead, 3, 800);
     } catch (error) {
       console.error("Read contract error:", error);
       throw new Error(`Failed to read contract: ${error.message || "Unknown error"}`);
@@ -1085,6 +1783,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
    */
   async writeContract(params) {
     this.ensureConnected();
+    await tronApiRateLimiter.waitForNextCall();
     try {
       const tronWeb = this.getTronWeb();
       console.log("[TronLink] writeContract params:", {
@@ -1110,29 +1809,171 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       }
       console.log("[TronLink] Function ABI:", functionAbi);
       console.log("[TronLink] Calling with args:", params.args);
+      const TRON_FEE_LIMIT = 1e8;
       const options = {
-        feeLimit: params.gas || 1e8,
-        // 默认 100 TRX 的能量限制
+        feeLimit: TRON_FEE_LIMIT,
+        // 固定为 100 TRX 的能量限制
         callValue: params.value || 0
         // 发送的 TRX 数量（单位：SUN）
       };
-      const parameter = functionAbi.inputs.map((input, index) => ({
-        type: input.type,
-        value: params.args[index]
-      }));
-      console.log("[TronLink] Transaction options:", options);
-      console.log("[TronLink] Parameters:", parameter);
-      const functionSelector = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
-      console.log("[TronLink] Function selector:", functionSelector);
-      console.log("[TronLink] Transaction options:", options);
-      console.log("[TronLink] Parameters:", parameter);
-      const tx = await tronWeb.transactionBuilder.triggerSmartContract(
-        params.address,
-        functionSelector,
-        options,
-        parameter,
-        this.currentAccount.nativeAddress
-      );
+      const hasTupleArray = functionAbi.inputs.some((input) => input.type === "tuple[]");
+      console.log("[TronLink] \u68C0\u67E5 tuple[] \u7C7B\u578B:", {
+        hasTupleArray,
+        inputs: functionAbi.inputs.map((i) => ({ name: i.name, type: i.type }))
+      });
+      let tx;
+      if (hasTupleArray) {
+        console.log("[TronLink] \u68C0\u6D4B\u5230 tuple[] \u53C2\u6570\uFF0C\u4F7F\u7528\u624B\u52A8\u7F16\u7801\u65B9\u5F0F");
+        const processedArgs = params.args.map((argValue, index) => {
+          const input = functionAbi.inputs[index];
+          if (input.type === "address" && typeof argValue === "string") {
+            if (argValue.startsWith("T") && argValue.length === 34) {
+              const hexAddress = tronWeb.address.toHex(argValue);
+              return hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+            }
+            return argValue.startsWith("0x") ? argValue : `0x${argValue}`;
+          }
+          if (input.type === "tuple[]" && Array.isArray(argValue)) {
+            return argValue.map((tupleItem) => {
+              if (input.components && Array.isArray(input.components)) {
+                const processedTuple = {};
+                input.components.forEach((component) => {
+                  let value = tupleItem[component.name];
+                  if (component.type === "address" && typeof value === "string") {
+                    if (value.startsWith("T") && value.length === 34) {
+                      const hexAddress = tronWeb.address.toHex(value);
+                      value = hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+                    } else if (!value.startsWith("0x")) {
+                      value = `0x${value}`;
+                    }
+                  }
+                  processedTuple[component.name] = value;
+                });
+                return processedTuple;
+              }
+              return tupleItem;
+            });
+          }
+          if (input.type === "tuple" && typeof argValue === "object" && !Array.isArray(argValue)) {
+            if (input.components && Array.isArray(input.components)) {
+              const processedTuple = {};
+              input.components.forEach((component) => {
+                let value = argValue[component.name];
+                if (component.type === "address" && typeof value === "string") {
+                  if (value.startsWith("T") && value.length === 34) {
+                    const hexAddress = tronWeb.address.toHex(value);
+                    value = hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+                  } else if (!value.startsWith("0x")) {
+                    value = `0x${value}`;
+                  }
+                }
+                processedTuple[component.name] = value;
+              });
+              return processedTuple;
+            }
+          }
+          return argValue;
+        });
+        console.log("[TronLink] \u5904\u7406\u540E\u7684\u53C2\u6570\uFF08\u7528\u4E8E viem \u7F16\u7801\uFF09:", processedArgs);
+        const encodedData = viem.encodeFunctionData({
+          abi: [functionAbi],
+          functionName: params.functionName,
+          args: processedArgs
+        });
+        console.log("[TronLink] \u7F16\u7801\u540E\u7684\u6570\u636E:", encodedData);
+        const functionSelector = encodedData.slice(0, 10);
+        const parameterData = encodedData.slice(10);
+        console.log("[TronLink] \u51FD\u6570\u9009\u62E9\u5668:", functionSelector);
+        console.log("[TronLink] \u53C2\u6570\u6570\u636E:", parameterData);
+        const functionSignature = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
+        const parameterHexClean = parameterData.startsWith("0x") ? parameterData.slice(2) : parameterData;
+        console.log("[TronLink] \u4F7F\u7528 TronWeb triggerSmartContract (rawParameter)...", {
+          contractAddress: params.address,
+          functionSelector: functionSignature,
+          encodedDataLength: parameterHexClean.length
+        });
+        tx = await retryWithBackoff(
+          () => tronWeb.transactionBuilder.triggerSmartContract(
+            params.address,
+            // Base58 格式的合约地址
+            functionSignature,
+            // 函数签名（用于识别函数）
+            {
+              feeLimit: options.feeLimit,
+              callValue: options.callValue,
+              rawParameter: parameterHexClean
+              // 使用 rawParameter 直接提供编码后的数据
+            },
+            [],
+            // parameter 留空（因为使用 rawParameter）
+            this.currentAccount.nativeAddress
+            // Base58 格式的发送地址
+          ),
+          3,
+          // 最多重试 3 次
+          500
+          // 初始延迟 500ms
+        );
+        console.log("[TronLink] \u4F7F\u7528 TronWeb API \u6784\u5EFA\u7684\u4EA4\u6613:", tx);
+      } else {
+        const parameter = functionAbi.inputs.map((input, index) => {
+          const argValue = params.args[index];
+          if (input.type === "tuple" && typeof argValue === "object" && !Array.isArray(argValue)) {
+            if (input.components && Array.isArray(input.components)) {
+              return {
+                type: input.type,
+                value: input.components.map((component) => ({
+                  type: component.type,
+                  value: argValue[component.name]
+                }))
+              };
+            }
+          }
+          if (input.type === "address" && typeof argValue === "string") {
+            if (argValue.startsWith("T") && argValue.length === 34) {
+              return {
+                type: input.type,
+                value: argValue
+              };
+            }
+            try {
+              const base58Address = tronWeb.address.fromHex(argValue.startsWith("0x") ? argValue : `0x${argValue}`);
+              return {
+                type: input.type,
+                value: base58Address
+              };
+            } catch (e) {
+              return {
+                type: input.type,
+                value: argValue
+              };
+            }
+          }
+          return {
+            type: input.type,
+            value: argValue
+          };
+        });
+        console.log("[TronLink] Transaction options:", options);
+        console.log("[TronLink] Parameters:", parameter);
+        const functionSelector = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
+        console.log("[TronLink] Function selector:", functionSelector);
+        console.log("[TronLink] Transaction options:", options);
+        console.log("[TronLink] Parameters:", parameter);
+        tx = await retryWithBackoff(
+          () => tronWeb.transactionBuilder.triggerSmartContract(
+            params.address,
+            functionSelector,
+            options,
+            parameter,
+            this.currentAccount.nativeAddress
+          ),
+          3,
+          // 最多重试 3 次
+          500
+          // 初始延迟 500ms
+        );
+      }
       console.log("[TronLink] Transaction built:", tx);
       if (!tx || !tx.transaction) {
         throw new Error("Failed to build transaction");
@@ -1172,6 +2013,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       const maxAttempts = 60;
       while (attempts < maxAttempts) {
         try {
+          await tronApiRateLimiter.waitForNextCall();
           const txInfo = await tronWeb.trx.getTransactionInfo(txHash);
           if (txInfo && txInfo.id) {
             const receipt = {
@@ -1299,6 +2141,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
 // Tron 主网链 ID
 _TronLinkAdapter.TRON_MAINNET_CHAIN_ID = 195;
 var TronLinkAdapter = _TronLinkAdapter;
+init_types();
 var EVMPrivateKeyAdapter = class extends WalletAdapter {
   constructor() {
     super(...arguments);
@@ -1312,27 +2155,28 @@ var EVMPrivateKeyAdapter = class extends WalletAdapter {
   /**
    * 连接（导入私钥）
    */
-  async connect(chainId = 1) {
+  async connect(chainId) {
     if (!this.privateKey) {
       throw new Error("Private key not set. Call setPrivateKey() first.");
     }
     try {
       this.setState("connecting" /* CONNECTING */);
       const account = accounts.privateKeyToAccount(this.privateKey);
+      const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId || 1;
       this.walletClient = viem.createWalletClient({
         account,
-        chain: this.getViemChain(chainId),
+        chain: this.getViemChain(targetChainId),
         transport: viem.http()
       });
       this.publicClient = viem.createPublicClient({
-        chain: this.getViemChain(chainId),
+        chain: this.getViemChain(targetChainId),
         transport: viem.http()
       });
       const address = formatEVMAddress(account.address);
       const accountInfo = {
-        universalAddress: createUniversalAddress(chainId, address),
+        universalAddress: createUniversalAddress(targetChainId, address),
         nativeAddress: address,
-        chainId,
+        chainId: targetChainId,
         chainType: ChainType.EVM,
         isActive: true
       };
@@ -1544,38 +2388,2094 @@ var EVMPrivateKeyAdapter = class extends WalletAdapter {
     };
   }
 };
-
-// src/core/adapter-registry.ts
-var AdapterRegistry = class {
-  constructor() {
-    this.adapters = /* @__PURE__ */ new Map();
-    this.registerDefaultAdapters();
-  }
-  /**
-   * Register default adapters
-   */
-  registerDefaultAdapters() {
-    this.register("metamask" /* METAMASK */, () => new MetaMaskAdapter());
-    this.register("private-key" /* PRIVATE_KEY */, () => new EVMPrivateKeyAdapter());
-    this.register("tronlink" /* TRONLINK */, () => new TronLinkAdapter());
-  }
-  /**
-   * Register adapter
-   */
-  register(type, factory) {
-    this.adapters.set(type, factory);
-  }
-  /**
-   * Get adapter
-   */
-  getAdapter(type) {
-    const factory = this.adapters.get(type);
-    if (!factory) {
-      return null;
-    }
-    return factory();
-  }
-  /**
+init_types();
+var _WalletConnectAdapter = class _WalletConnectAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect" /* WALLETCONNECT */;
+    this.chainType = ChainType.EVM;
+    this.name = "WalletConnect";
+    this.icon = "https://avatars.githubusercontent.com/u/37784886";
+    this.provider = null;
+    this.walletClient = null;
+    this.publicClient = null;
+    this.supportedChains = [];
+    /**
+     * Handle accounts changed
+     */
+    this.handleAccountsChanged = (accounts) => {
+      if (accounts.length === 0) {
+        this.setState("disconnected" /* DISCONNECTED */);
+        this.setAccount(null);
+        this.emitAccountChanged(null);
+      } else {
+        const address = formatEVMAddress(accounts[0]);
+        const account = {
+          universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
+          nativeAddress: address,
+          chainId: this.currentAccount.chainId,
+          chainType: ChainType.EVM,
+          isActive: true
+        };
+        this.setAccount(account);
+        this.emitAccountChanged(account);
+      }
+    };
+    /**
+     * Handle chain changed
+     */
+    this.handleChainChanged = (chainIdHex) => {
+      const chainId = parseInt(chainIdHex, 16);
+      if (this.currentAccount) {
+        const account = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(account);
+        this.emitChainChanged(chainId);
+        const viemChain = this.getViemChain(chainId);
+        const chainInfo = getChainInfo(chainId);
+        const primaryRpcUrl = chainInfo?.rpcUrls[0];
+        if (this.provider) {
+          this.walletClient = viem.createWalletClient({
+            account: this.currentAccount.nativeAddress,
+            chain: viemChain,
+            transport: viem.custom(this.provider)
+          });
+          this.publicClient = viem.createPublicClient({
+            chain: viemChain,
+            transport: primaryRpcUrl ? viem.http(primaryRpcUrl) : viem.custom(this.provider)
+          });
+        }
+      }
+    };
+    /**
+     * Handle disconnect
+     */
+    this.handleDisconnect = () => {
+      this.setState("disconnected" /* DISCONNECTED */);
+      this.setAccount(null);
+      if (_WalletConnectAdapter.providerInstance === this.provider) {
+        _WalletConnectAdapter.providerInstance = null;
+        _WalletConnectAdapter.providerProjectId = null;
+      }
+      this.provider = null;
+      this.walletClient = null;
+      this.publicClient = null;
+      this.emitDisconnected();
+    };
+    if (!projectId) {
+      throw new ConfigurationError("WalletConnect projectId is required");
+    }
+    this.projectId = projectId;
+  }
+  /**
+   * Check if WalletConnect is available
+   * WalletConnect is always available (it's a web-based connection)
+   * Also works in Telegram Mini Apps
+   */
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running in Telegram environment (Mini App or Web)
+   * Both Telegram Mini App (in client) and Telegram Web (web.telegram.org) 
+   * provide window.Telegram.WebApp API, so they are treated the same way.
+   * 
+   * Reference: https://docs.reown.com/appkit/integrations/telegram-mini-apps
+   */
+  isTelegramMiniApp() {
+    if (typeof window === "undefined") return false;
+    const tg = window.Telegram?.WebApp;
+    if (!tg) return false;
+    const platform = tg.platform || "unknown";
+    console.log("[WalletConnect] Telegram environment detected:", {
+      platform,
+      version: tg.version,
+      isMiniApp: platform !== "web",
+      // Mini App if not web platform
+      isWeb: platform === "web"
+      // Telegram Web if web platform
+    });
+    return true;
+  }
+  /**
+   * Get Telegram WebApp instance if available
+   */
+  getTelegramWebApp() {
+    if (typeof window === "undefined") return null;
+    return window.Telegram?.WebApp || null;
+  }
+  /**
+   * Close Telegram deep link popup (wc:// links)
+   * In Telegram Mini Apps, WalletConnect may open a wc:// deep link popup
+   * that doesn't automatically close after the operation completes.
+   * This method attempts to close it by:
+   * 1. Trying to close any open windows/popups
+   * 2. Using Telegram WebApp API if available
+   * 3. Navigating back or closing the popup
+   */
+  closeTelegramDeepLinkPopup() {
+    if (!this.isTelegramMiniApp()) {
+      return;
+    }
+    try {
+      const tg = this.getTelegramWebApp();
+      if (!tg) {
+        return;
+      }
+      if (typeof window !== "undefined") {
+        window.focus();
+        if (tg.BackButton && tg.BackButton.isVisible) {
+          console.log("[WalletConnect] Closing Telegram deep link popup via BackButton");
+        }
+        setTimeout(() => {
+          if (document.hasFocus()) {
+            console.log("[WalletConnect] Main window has focus, popup likely closed");
+          } else {
+            window.focus();
+            console.log("[WalletConnect] Attempted to focus main window to close popup");
+          }
+        }, 500);
+        const handleVisibilityChange = () => {
+          if (document.visibilityState === "visible") {
+            console.log("[WalletConnect] Page became visible, popup may have closed");
+            document.removeEventListener("visibilitychange", handleVisibilityChange);
+          }
+        };
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+        setTimeout(() => {
+          document.removeEventListener("visibilitychange", handleVisibilityChange);
+        }, 2e3);
+      }
+    } catch (error) {
+      console.warn("[WalletConnect] Error closing Telegram deep link popup:", error);
+    }
+  }
+  /**
+   * Connect wallet
+   * 
+   * @param chainId - Single chain ID or array of chain IDs to request
+   *                  If array is provided, wallet will be requested to connect to multiple chains
+   *                  When multiple chains are requested, the wallet can switch between them
+   *                  Default: 1 (Ethereum Mainnet)
+   * 
+   * @example
+   * // Single chain
+   * await adapter.connect(1) // Ethereum only
+   * 
+   * @example
+   * // Multiple chains
+   * await adapter.connect([1, 56, 137]) // Ethereum, BSC, Polygon
+   */
+  async connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("WalletConnect requires a browser environment");
+    }
+    if (_WalletConnectAdapter.providerInstance && _WalletConnectAdapter.providerProjectId === this.projectId) {
+      const existingProvider = _WalletConnectAdapter.providerInstance;
+      if (existingProvider.accounts && existingProvider.accounts.length > 0) {
+        this.provider = existingProvider;
+        let targetChains;
+        if (Array.isArray(chainId)) {
+          targetChains = chainId.length > 0 ? chainId : [1];
+        } else if (chainId) {
+          targetChains = [chainId];
+        } else {
+          targetChains = [1];
+        }
+        const existingChains = this.supportedChains || [];
+        const mergedChains = [.../* @__PURE__ */ new Set([...existingChains, ...targetChains])];
+        this.supportedChains = mergedChains;
+        const currentChainId = existingProvider.chainId || targetChains[0];
+        const address = formatEVMAddress(existingProvider.accounts[0]);
+        const account = {
+          universalAddress: createUniversalAddress(currentChainId, address),
+          nativeAddress: address,
+          chainId: currentChainId,
+          chainType: ChainType.EVM,
+          isActive: true
+        };
+        this.setState("connected" /* CONNECTED */);
+        this.setAccount(account);
+        if (!this.walletClient) {
+          const viemChain = this.getViemChain(currentChainId);
+          this.walletClient = viem.createWalletClient({
+            account: existingProvider.accounts[0],
+            chain: viemChain,
+            transport: viem.custom(existingProvider)
+          });
+          const chainInfo = getChainInfo(currentChainId);
+          const primaryRpcUrl = chainInfo?.rpcUrls[0];
+          this.publicClient = viem.createPublicClient({
+            chain: viemChain,
+            transport: primaryRpcUrl ? viem.http(primaryRpcUrl) : viem.custom(existingProvider)
+          });
+          this.setupEventListeners();
+        }
+        console.log("[WalletConnect] Reusing existing provider session");
+        return account;
+      }
+    }
+    if (this.state === "connected" /* CONNECTED */ && this.currentAccount && this.provider) {
+      if (this.provider.accounts && this.provider.accounts.length > 0) {
+        let targetChains;
+        if (Array.isArray(chainId)) {
+          targetChains = chainId.length > 0 ? chainId : [1];
+        } else if (chainId) {
+          targetChains = [chainId];
+        } else {
+          targetChains = [1];
+        }
+        const existingChains = this.supportedChains || [];
+        const mergedChains = [.../* @__PURE__ */ new Set([...existingChains, ...targetChains])];
+        this.supportedChains = mergedChains;
+        console.log("[WalletConnect] Already connected, reusing existing connection");
+        return this.currentAccount;
+      } else {
+        this.setState("disconnected" /* DISCONNECTED */);
+        this.setAccount(null);
+        this.provider = null;
+      }
+    }
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      let targetChains;
+      if (Array.isArray(chainId)) {
+        targetChains = chainId.length > 0 ? chainId : [1];
+      } else if (chainId) {
+        targetChains = [chainId];
+      } else {
+        targetChains = [1];
+      }
+      this.supportedChains = targetChains;
+      const primaryChain = targetChains[0];
+      const optionalChains = targetChains.slice(1);
+      const isTelegram = this.isTelegramMiniApp();
+      const telegramWebApp = this.getTelegramWebApp();
+      let appUrl = "";
+      if (typeof window !== "undefined") {
+        try {
+          if (window.location && window.location.origin) {
+            appUrl = window.location.origin;
+          } else if (window.location && window.location.href) {
+            const url = new URL(window.location.href);
+            appUrl = url.origin;
+          }
+        } catch (error) {
+          console.warn("[WalletConnect] Failed to get origin from window.location:", error);
+        }
+        if (!appUrl) {
+          appUrl = "https://enclave.network";
+        }
+      } else {
+        appUrl = "https://enclave.network";
+      }
+      if (!appUrl || !appUrl.startsWith("http://") && !appUrl.startsWith("https://")) {
+        appUrl = "https://enclave.network";
+      }
+      const icons = [
+        "https://walletconnect.com/walletconnect-logo.svg",
+        "https://avatars.githubusercontent.com/u/37784886"
+        // WalletConnect GitHub avatar
+      ];
+      const initOptions = {
+        projectId: this.projectId,
+        chains: [primaryChain],
+        // Primary chain (required)
+        showQrModal: true,
+        // QR modal works in Telegram Mini Apps
+        metadata: {
+          name: "Enclave Wallet SDK",
+          description: "Multi-chain wallet adapter for Enclave",
+          url: appUrl,
+          icons
+        }
+      };
+      if (isTelegram && telegramWebApp) {
+        const platform = telegramWebApp.platform || "unknown";
+        const isMiniApp = platform !== "web";
+        console.log("[WalletConnect] Detected Telegram environment:", {
+          platform,
+          isMiniApp,
+          isWeb: platform === "web"
+        });
+        if (telegramWebApp.isExpanded === false) {
+          telegramWebApp.expand();
+        }
+      }
+      if (optionalChains.length > 0) {
+        initOptions.optionalChains = optionalChains;
+      } else {
+        initOptions.optionalChains = [primaryChain];
+      }
+      const hasExistingProvider = _WalletConnectAdapter.providerInstance && _WalletConnectAdapter.providerProjectId === this.projectId;
+      const needsReinit = hasExistingProvider && _WalletConnectAdapter.providerChains !== null && JSON.stringify(_WalletConnectAdapter.providerChains.sort()) !== JSON.stringify(targetChains.sort());
+      if (needsReinit) {
+        console.log("[WalletConnect] Provider initialized with different chains, reinitializing...", {
+          existing: _WalletConnectAdapter.providerChains,
+          requested: targetChains
+        });
+        const existingProvider = _WalletConnectAdapter.providerInstance;
+        if (existingProvider) {
+          try {
+            if (existingProvider.accounts && existingProvider.accounts.length > 0) {
+              await existingProvider.disconnect();
+            }
+          } catch (error) {
+            console.warn("[WalletConnect] Error disconnecting existing provider:", error);
+          }
+        }
+        _WalletConnectAdapter.providerInstance = null;
+        _WalletConnectAdapter.providerChains = null;
+      }
+      if (_WalletConnectAdapter.providerInstance && _WalletConnectAdapter.providerProjectId === this.projectId) {
+        this.provider = _WalletConnectAdapter.providerInstance;
+        console.log("[WalletConnect] Reusing existing provider instance");
+        if (this.provider.accounts && this.provider.accounts.length > 0) {
+          console.log("[WalletConnect] Provider already has accounts, skipping enable()");
+        } else {
+          const hasSession = this.provider.session !== void 0 && this.provider.session !== null;
+          console.log("[WalletConnect] Provider has no accounts, calling enable() to show QR modal");
+          console.log("[WalletConnect] Provider state:", {
+            accounts: this.provider.accounts,
+            chainId: this.provider.chainId,
+            hasSession,
+            sessionTopic: this.provider.session?.topic
+          });
+          if (hasSession && (!this.provider.accounts || this.provider.accounts.length === 0)) {
+            console.log("[WalletConnect] Found stale session, disconnecting before reconnecting...");
+            try {
+              await this.provider.disconnect();
+              await new Promise((resolve) => setTimeout(resolve, 100));
+            } catch (disconnectError) {
+              console.warn("[WalletConnect] Error disconnecting stale session:", disconnectError);
+            }
+          }
+          try {
+            console.log("[WalletConnect] Calling enable()...");
+            const enableResult = await this.provider.enable();
+            console.log("[WalletConnect] enable() completed, result:", enableResult);
+            console.log("[WalletConnect] Provider state after enable():", {
+              accounts: this.provider.accounts,
+              chainId: this.provider.chainId,
+              session: this.provider.session ? {
+                topic: this.provider.session.topic,
+                namespaces: this.provider.session.namespaces ? Object.keys(this.provider.session.namespaces) : "none"
+              } : "none"
+            });
+          } catch (error) {
+            console.error("[WalletConnect] enable() error:", error);
+            if (error.code === 4001 || error.message?.includes("rejected") || error.message?.includes("User rejected")) {
+              throw new ConnectionRejectedError(this.type);
+            }
+            throw error;
+          }
+        }
+      } else if (_WalletConnectAdapter.providerInstance && _WalletConnectAdapter.providerProjectId === this.projectId) {
+        this.provider = _WalletConnectAdapter.providerInstance;
+        console.log("[WalletConnect] Reusing existing provider instance (not connected)");
+        if (this.provider.accounts && this.provider.accounts.length > 0) {
+          console.log("[WalletConnect] Provider already has accounts after init, skipping enable()");
+        } else {
+          const hasSession = this.provider.session !== void 0 && this.provider.session !== null;
+          console.log("[WalletConnect] Provider has no accounts, calling enable() to show QR modal");
+          console.log("[WalletConnect] Provider state:", {
+            accounts: this.provider.accounts,
+            chainId: this.provider.chainId,
+            hasSession,
+            sessionTopic: this.provider.session?.topic
+          });
+          if (hasSession && (!this.provider.accounts || this.provider.accounts.length === 0)) {
+            console.log("[WalletConnect] Found stale session after init, disconnecting before reconnecting...");
+            try {
+              await this.provider.disconnect();
+              await new Promise((resolve) => setTimeout(resolve, 100));
+            } catch (disconnectError) {
+              console.warn("[WalletConnect] Error disconnecting stale session:", disconnectError);
+            }
+          }
+          try {
+            await this.provider.enable();
+          } catch (error) {
+            console.error("[WalletConnect] enable() error:", error);
+            if (error.code === 4001 || error.message?.includes("rejected") || error.message?.includes("User rejected")) {
+              throw new ConnectionRejectedError(this.type);
+            }
+            throw error;
+          }
+        }
+      } else if (_WalletConnectAdapter.isInitializing && _WalletConnectAdapter.initPromise) {
+        console.log("[WalletConnect] Waiting for ongoing initialization...");
+        this.provider = await _WalletConnectAdapter.initPromise;
+        _WalletConnectAdapter.providerInstance = this.provider;
+        _WalletConnectAdapter.providerProjectId = this.projectId;
+        _WalletConnectAdapter.providerChains = targetChains;
+        if (this.provider.accounts && this.provider.accounts.length > 0) {
+          console.log("[WalletConnect] Provider already has accounts after init, skipping enable()");
+        } else {
+          try {
+            await this.provider.enable();
+          } catch (error) {
+            if (error.code === 4001 || error.message?.includes("rejected") || error.message?.includes("User rejected")) {
+              throw new ConnectionRejectedError(this.type);
+            }
+            throw error;
+          }
+        }
+      } else {
+        console.log("[WalletConnect] Initializing new provider with chains:", {
+          primary: primaryChain,
+          optional: optionalChains,
+          all: targetChains
+        });
+        _WalletConnectAdapter.isInitializing = true;
+        _WalletConnectAdapter.initPromise = EthereumProvider__default.default.init(initOptions);
+        try {
+          this.provider = await _WalletConnectAdapter.initPromise;
+          _WalletConnectAdapter.providerInstance = this.provider;
+          _WalletConnectAdapter.providerProjectId = this.projectId;
+          _WalletConnectAdapter.providerChains = targetChains;
+          if (this.provider.accounts && this.provider.accounts.length > 0) {
+            console.log("[WalletConnect] Provider has restored session, skipping enable()");
+          } else {
+            const hasSession = this.provider.session !== void 0 && this.provider.session !== null;
+            console.log("[WalletConnect] New provider initialized, calling enable() to show QR modal");
+            console.log("[WalletConnect] Provider state:", {
+              accounts: this.provider.accounts,
+              chainId: this.provider.chainId,
+              hasSession,
+              sessionTopic: this.provider.session?.topic
+            });
+            if (hasSession && (!this.provider.accounts || this.provider.accounts.length === 0)) {
+              console.log("[WalletConnect] Found stale session after init, disconnecting before reconnecting...");
+              try {
+                await this.provider.disconnect();
+                await new Promise((resolve) => setTimeout(resolve, 100));
+              } catch (disconnectError) {
+                console.warn("[WalletConnect] Error disconnecting stale session:", disconnectError);
+              }
+            }
+            try {
+              await this.provider.enable();
+            } catch (error) {
+              console.error("[WalletConnect] enable() error:", error);
+              if (error.code === 4001 || error.message?.includes("rejected") || error.message?.includes("User rejected")) {
+                throw new ConnectionRejectedError(this.type);
+              }
+              throw error;
+            }
+          }
+        } finally {
+          _WalletConnectAdapter.isInitializing = false;
+          _WalletConnectAdapter.initPromise = null;
+        }
+      }
+      let accounts = this.provider.accounts;
+      if (!accounts || accounts.length === 0) {
+        console.log("[WalletConnect] provider.accounts is empty, checking session.namespaces.eip155.accounts...");
+        const session = this.provider.session;
+        if (session && session.namespaces?.eip155?.accounts) {
+          const sessionAccounts = session.namespaces.eip155.accounts.map((acc) => {
+            const parts = acc.split(":");
+            if (parts.length >= 3 && parts[0] === "eip155") {
+              return parts[2];
+            }
+            return null;
+          }).filter((addr) => addr !== null && addr.startsWith("0x"));
+          if (sessionAccounts.length > 0) {
+            const uniqueAccounts = [...new Set(sessionAccounts)];
+            console.log("[WalletConnect] Found accounts in session.namespaces.eip155.accounts:", {
+              raw: session.namespaces.eip155.accounts,
+              extracted: uniqueAccounts,
+              chains: session.namespaces.eip155.chains
+            });
+            accounts = uniqueAccounts;
+          }
+        }
+      }
+      if (!accounts || accounts.length === 0) {
+        console.log("[WalletConnect] Accounts not available, waiting for provider.accounts to populate...");
+        const maxWaitTime = 3e3;
+        const checkInterval = 100;
+        const maxChecks = maxWaitTime / checkInterval;
+        for (let i = 0; i < maxChecks; i++) {
+          await new Promise((resolve) => setTimeout(resolve, checkInterval));
+          accounts = this.provider.accounts;
+          if (accounts && accounts.length > 0) {
+            console.log(`[WalletConnect] Accounts available after ${(i + 1) * checkInterval}ms`);
+            break;
+          }
+        }
+      }
+      if (!accounts || accounts.length === 0) {
+        const session = this.provider.session;
+        const providerState = {
+          providerAccounts: this.provider.accounts,
+          providerChainId: this.provider.chainId,
+          session: session ? {
+            exists: true,
+            topic: session.topic,
+            namespaces: session.namespaces ? Object.keys(session.namespaces) : "none",
+            eip155Namespace: session.namespaces?.eip155 ? {
+              accounts: session.namespaces.eip155.accounts,
+              // CAIP-10 format
+              chains: session.namespaces.eip155.chains,
+              // CAIP-2 format
+              methods: session.namespaces.eip155.methods,
+              events: session.namespaces.eip155.events
+            } : "none",
+            // Log full session structure for debugging
+            fullSession: JSON.stringify(session, null, 2)
+          } : "none",
+          // Check if provider has any other properties that might contain accounts
+          providerKeys: Object.keys(this.provider)
+        };
+        console.error("[WalletConnect] No accounts available after enable() and wait", providerState);
+        console.error("[WalletConnect] Full provider object:", this.provider);
+        console.error("[WalletConnect] Full session object:", session);
+        console.error("[WalletConnect] Session namespaces structure:", session?.namespaces);
+        throw new Error("WalletConnect connection established but no accounts available. Please check session.namespaces.eip155.accounts in the console logs above.");
+      }
+      const currentChainId = this.provider.chainId || targetChains[0];
+      const viemChain = this.getViemChain(currentChainId);
+      this.walletClient = viem.createWalletClient({
+        account: accounts[0],
+        chain: viemChain,
+        transport: viem.custom(this.provider)
+      });
+      const chainInfo = getChainInfo(currentChainId);
+      const primaryRpcUrl = chainInfo?.rpcUrls[0];
+      this.publicClient = viem.createPublicClient({
+        chain: viemChain,
+        transport: primaryRpcUrl ? viem.http(primaryRpcUrl) : viem.custom(this.provider)
+      });
+      const address = formatEVMAddress(accounts[0]);
+      const account = {
+        universalAddress: createUniversalAddress(currentChainId, address),
+        nativeAddress: address,
+        chainId: currentChainId,
+        chainType: ChainType.EVM,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      const origin = typeof window !== "undefined" && window.location ? window.location.origin : "";
+      const errorCode = error?.code;
+      const errorMessage = error?.message || String(error);
+      const isOriginNotAllowed = errorCode === 3e3 || /origin not allowed/i.test(errorMessage) || /Unauthorized:\s*origin not allowed/i.test(errorMessage);
+      const session = this.provider?.session;
+      const providerState = this.provider ? {
+        accounts: this.provider.accounts,
+        chainId: this.provider.chainId,
+        session: session ? {
+          exists: true,
+          topic: session.topic,
+          namespaces: session.namespaces ? Object.keys(session.namespaces) : "none",
+          eip155Namespace: session.namespaces?.eip155 ? {
+            accounts: session.namespaces.eip155.accounts,
+            chains: session.namespaces.eip155.chains,
+            methods: session.namespaces.eip155.methods,
+            events: session.namespaces.eip155.events
+          } : "none"
+        } : "none",
+        providerKeys: Object.keys(this.provider)
+      } : "no provider";
+      console.error("[WalletConnect] Connection error:", {
+        error,
+        code: error.code,
+        message: error.message,
+        stack: error.stack,
+        providerState
+      });
+      if (this.provider) {
+        console.error("[WalletConnect] Full provider object:", this.provider);
+        console.error("[WalletConnect] Full session object:", session);
+      }
+      if (error.code === 4001 || error.message && (error.message.includes("User rejected") || error.message.includes("rejected by user") || error.message.includes("User cancelled"))) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      if (isOriginNotAllowed) {
+        throw new ConfigurationError(
+          `WalletConnect relayer rejected this origin (code 3000: Unauthorized: origin not allowed).
+
+Fix:
+1) Open WalletConnect Cloud \u2192 your project (${this.projectId})
+2) Add this site origin to the allowlist:
+   - ${origin || "(unknown origin)"}
+
+Common dev origins to allow:
+- http://localhost:5173
+- http://192.168.0.221:5173 (your LAN dev URL)
+- https://wallet-test.enclave-hq.com (your Cloudflare Tunnel/custom domain)
+
+Original error: ${errorMessage}`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    if (this.provider) {
+      try {
+        await this.provider.disconnect();
+      } catch (error) {
+        console.warn("[WalletConnect] Error during disconnect:", error);
+      }
+      if (_WalletConnectAdapter.providerInstance === this.provider) {
+        _WalletConnectAdapter.providerInstance = null;
+        _WalletConnectAdapter.providerProjectId = null;
+        _WalletConnectAdapter.providerChains = null;
+      }
+      this.provider = null;
+    }
+    this.removeEventListeners();
+    this.walletClient = null;
+    this.publicClient = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * Sign message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const signature = await this.provider.request({
+        method: "personal_sign",
+        params: [message, this.currentAccount.nativeAddress]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sign TypedData (EIP-712)
+   */
+  async signTypedData(typedData) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const signature = await this.provider.request({
+        method: "eth_signTypedData_v4",
+        params: [this.currentAccount.nativeAddress, JSON.stringify(typedData)]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sign transaction
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const tx = {
+        from: this.currentAccount.nativeAddress,
+        to: transaction.to,
+        value: transaction.value ? `0x${BigInt(transaction.value).toString(16)}` : void 0,
+        data: transaction.data || "0x",
+        gas: transaction.gas ? `0x${BigInt(transaction.gas).toString(16)}` : void 0,
+        gasPrice: transaction.gasPrice && transaction.gasPrice !== "auto" ? `0x${BigInt(transaction.gasPrice).toString(16)}` : void 0,
+        maxFeePerGas: transaction.maxFeePerGas ? `0x${BigInt(transaction.maxFeePerGas).toString(16)}` : void 0,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? `0x${BigInt(transaction.maxPriorityFeePerGas).toString(16)}` : void 0,
+        nonce: transaction.nonce !== void 0 ? `0x${transaction.nonce.toString(16)}` : void 0,
+        chainId: transaction.chainId || this.currentAccount.chainId
+      };
+      const signature = await this.provider.request({
+        method: "eth_signTransaction",
+        params: [tx]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError("Transaction signature was rejected by user");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get supported chains from current connection
+   * Returns the chains that were requested during connection
+   */
+  getSupportedChains() {
+    return [...this.supportedChains];
+  }
+  /**
+   * Switch chain
+   * 
+   * Note: WalletConnect v2 with mobile wallets may not support chain switching reliably.
+   * Some wallets may ignore the switch request or fail silently.
+   * It's recommended to include all needed chains in the initial connection.
+   * 
+   * Reference: https://specs.walletconnect.com/2.0/specs/clients/sign/namespaces
+   */
+  async switchChain(chainId) {
+    if (!this.provider) {
+      throw new Error("Provider not initialized");
+    }
+    const session = this.provider.session;
+    const supportedChains = session?.namespaces?.eip155?.chains || [];
+    const targetChainCAIP = `eip155:${chainId}`;
+    const isChainApproved = supportedChains.includes(targetChainCAIP);
+    if (!isChainApproved) {
+      console.warn(`[WalletConnect] Chain ${chainId} (${targetChainCAIP}) not in session approved chains:`, supportedChains);
+      console.warn("[WalletConnect] Chain switching may fail. Consider including all chains in initial connection.");
+    }
+    try {
+      console.log(`[WalletConnect] Attempting to switch to chain ${chainId} (${targetChainCAIP})`);
+      const result = await this.provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: `0x${chainId.toString(16)}` }]
+      });
+      if (result !== null && result !== void 0) {
+        console.warn("[WalletConnect] wallet_switchEthereumChain returned non-null result:", result);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      const currentChainId = this.provider.chainId;
+      if (currentChainId !== chainId) {
+        console.warn(`[WalletConnect] Chain switch may have failed. Expected ${chainId}, got ${currentChainId}`);
+        console.warn("[WalletConnect] Some mobile wallets may not support chain switching via WalletConnect.");
+        console.warn("[WalletConnect] User may need to manually switch chains in the wallet app.");
+      }
+      if (this.currentAccount) {
+        const updatedAccount = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(updatedAccount);
+        this.emitChainChanged(chainId);
+        const viemChain = this.getViemChain(chainId);
+        const chainInfo = getChainInfo(chainId);
+        const primaryRpcUrl = chainInfo?.rpcUrls[0];
+        this.walletClient = viem.createWalletClient({
+          account: this.currentAccount.nativeAddress,
+          chain: viemChain,
+          transport: viem.custom(this.provider)
+        });
+        this.publicClient = viem.createPublicClient({
+          chain: viemChain,
+          transport: primaryRpcUrl ? viem.http(primaryRpcUrl) : viem.custom(this.provider)
+        });
+      }
+    } catch (error) {
+      console.error("[WalletConnect] Chain switch error:", {
+        chainId,
+        errorCode: error.code,
+        errorMessage: error.message,
+        supportedChains
+      });
+      if (error.code === 4902) {
+        console.log(`[WalletConnect] Chain ${chainId} not found in wallet, attempting to add...`);
+        const chainInfo = getChainInfo(chainId);
+        if (chainInfo) {
+          try {
+            await this.addChain({
+              chainId: chainInfo.id,
+              chainName: chainInfo.name,
+              nativeCurrency: chainInfo.nativeCurrency,
+              rpcUrls: chainInfo.rpcUrls,
+              blockExplorerUrls: chainInfo.blockExplorerUrls
+            });
+            console.log(`[WalletConnect] Chain added, attempting to switch again...`);
+            await this.switchChain(chainId);
+          } catch (addError) {
+            console.error("[WalletConnect] Failed to add chain:", addError);
+            throw new Error(`Failed to add chain ${chainId}: ${addError.message}`);
+          }
+        } else {
+          throw new Error(`Chain ${chainId} not supported`);
+        }
+      } else if (error.code === 4001) {
+        throw new Error("User rejected chain switch");
+      } else if (error.code === 4100) {
+        throw new Error("Wallet does not support wallet_switchEthereumChain. Please switch chains manually in your wallet app.");
+      } else {
+        console.warn("[WalletConnect] Chain switch may not be supported by this wallet. User may need to switch manually.");
+        throw error;
+      }
+    }
+  }
+  /**
+   * Add chain
+   */
+  async addChain(chainConfig) {
+    if (!this.provider) {
+      throw new Error("Provider not initialized");
+    }
+    await this.provider.request({
+      method: "wallet_addEthereumChain",
+      params: [{
+        chainId: `0x${chainConfig.chainId.toString(16)}`,
+        chainName: chainConfig.chainName,
+        nativeCurrency: chainConfig.nativeCurrency,
+        rpcUrls: chainConfig.rpcUrls,
+        blockExplorerUrls: chainConfig.blockExplorerUrls
+      }]
+    });
+  }
+  /**
+   * Read contract
+   */
+  async readContract(params) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const result = await this.publicClient.readContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {}
+    });
+    return result;
+  }
+  /**
+   * Write contract
+   */
+  async writeContract(params) {
+    this.ensureConnected();
+    if (!this.walletClient) {
+      throw new Error("Wallet client not initialized");
+    }
+    try {
+      const txOptions = {
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        ...params.args ? { args: params.args } : {},
+        value: params.value ? BigInt(params.value) : void 0,
+        gas: params.gas ? BigInt(params.gas) : void 0
+      };
+      if (params.maxFeePerGas || params.maxPriorityFeePerGas) {
+        if (params.maxFeePerGas) {
+          txOptions.maxFeePerGas = BigInt(params.maxFeePerGas);
+        }
+        if (params.maxPriorityFeePerGas) {
+          txOptions.maxPriorityFeePerGas = BigInt(params.maxPriorityFeePerGas);
+        }
+      } else if (params.gasPrice && params.gasPrice !== "auto") {
+        txOptions.gasPrice = BigInt(params.gasPrice);
+      } else {
+        if (this.publicClient) {
+          try {
+            const feesPerGas = await this.publicClient.estimateFeesPerGas().catch(() => null);
+            if (feesPerGas) {
+              const minPriorityFeeWei = BigInt(1e8);
+              const maxPriorityFeePerGas = feesPerGas.maxPriorityFeePerGas > minPriorityFeeWei ? feesPerGas.maxPriorityFeePerGas : minPriorityFeeWei;
+              const adjustedMaxFeePerGas = feesPerGas.maxFeePerGas > maxPriorityFeePerGas ? feesPerGas.maxFeePerGas : maxPriorityFeePerGas + BigInt(1e9);
+              txOptions.maxFeePerGas = adjustedMaxFeePerGas;
+              txOptions.maxPriorityFeePerGas = maxPriorityFeePerGas;
+            } else {
+              const gasPrice = await this.publicClient.getGasPrice();
+              txOptions.gasPrice = gasPrice;
+            }
+          } catch (err) {
+          }
+        }
+      }
+      const txHash = await this.walletClient.writeContract(txOptions);
+      this.closeTelegramDeepLinkPopup();
+      return txHash;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError("Transaction was rejected by user");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Estimate gas
+   */
+  async estimateGas(params) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const gas = await this.publicClient.estimateContractGas({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {},
+      value: params.value ? BigInt(params.value) : void 0,
+      account: this.currentAccount.nativeAddress
+    });
+    return gas;
+  }
+  /**
+   * Wait for transaction
+   */
+  async waitForTransaction(txHash, confirmations = 1) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      confirmations
+    });
+    if (receipt.status === "reverted") {
+      throw new TransactionFailedError(txHash, "Transaction reverted");
+    }
+    return {
+      transactionHash: receipt.transactionHash,
+      blockNumber: Number(receipt.blockNumber),
+      blockHash: receipt.blockHash,
+      from: receipt.from,
+      to: receipt.to || void 0,
+      status: receipt.status === "success" ? "success" : "failed",
+      gasUsed: receipt.gasUsed.toString(),
+      effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+      logs: receipt.logs
+    };
+  }
+  /**
+   * Get provider
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Get signer
+   */
+  getSigner() {
+    return this.walletClient;
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    if (!this.provider) return;
+    this.provider.on("accountsChanged", this.handleAccountsChanged);
+    this.provider.on("chainChanged", this.handleChainChanged);
+    this.provider.on("disconnect", this.handleDisconnect);
+  }
+  /**
+   * Remove event listeners
+   */
+  removeEventListeners() {
+    if (!this.provider) return;
+    this.provider.removeListener("accountsChanged", this.handleAccountsChanged);
+    this.provider.removeListener("chainChanged", this.handleChainChanged);
+    this.provider.removeListener("disconnect", this.handleDisconnect);
+  }
+  /**
+   * Get viem chain config
+   */
+  getViemChain(chainId) {
+    const chainInfo = getChainInfo(chainId);
+    if (chainInfo) {
+      return {
+        id: chainId,
+        name: chainInfo.name,
+        network: chainInfo.name.toLowerCase().replace(/\s+/g, "-"),
+        nativeCurrency: chainInfo.nativeCurrency,
+        rpcUrls: {
+          default: { http: chainInfo.rpcUrls },
+          public: { http: chainInfo.rpcUrls }
+        },
+        blockExplorers: chainInfo.blockExplorerUrls ? {
+          default: { name: "Explorer", url: chainInfo.blockExplorerUrls[0] }
+        } : void 0
+      };
+    }
+    return {
+      id: chainId,
+      name: `Chain ${chainId}`,
+      network: `chain-${chainId}`,
+      nativeCurrency: {
+        name: "ETH",
+        symbol: "ETH",
+        decimals: 18
+      },
+      rpcUrls: {
+        default: { http: [] },
+        public: { http: [] }
+      }
+    };
+  }
+};
+// Store supported chains from connection
+// Static provider instance to avoid multiple initializations
+_WalletConnectAdapter.providerInstance = null;
+_WalletConnectAdapter.providerProjectId = null;
+_WalletConnectAdapter.providerChains = null;
+// Store the chains used during initialization
+_WalletConnectAdapter.isInitializing = false;
+_WalletConnectAdapter.initPromise = null;
+var WalletConnectAdapter = _WalletConnectAdapter;
+
+// src/adapters/tron/wallet-connect.ts
+var wallet_connect_exports = {};
+__export(wallet_connect_exports, {
+  WalletConnectTronAdapter: () => WalletConnectTronAdapter
+});
+init_types();
+var _WalletConnectTronAdapter = class _WalletConnectTronAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect-tron" /* WALLETCONNECT_TRON */;
+    this.chainType = ChainType.TRON;
+    this.name = "WalletConnect (Tron)";
+    this.icon = "https://avatars.githubusercontent.com/u/37784886";
+    this.wallet = null;
+    this.currentAddress = null;
+    if (!projectId) {
+      throw new ConfigurationError("WalletConnect projectId is required");
+    }
+    this.projectId = projectId;
+  }
+  /**
+   * Check if WalletConnect is available
+   */
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running in Telegram environment (Mini App or Web)
+   * Both Telegram Mini App (in client) and Telegram Web (web.telegram.org) 
+   * provide window.Telegram.WebApp API, so they are treated the same way.
+   */
+  isTelegramMiniApp() {
+    if (typeof window === "undefined") return false;
+    const tg = window.Telegram?.WebApp;
+    if (!tg) return false;
+    const platform = tg.platform || "unknown";
+    console.log("[WalletConnect Tron] Telegram environment detected:", {
+      platform,
+      version: tg.version,
+      isMiniApp: platform !== "web",
+      // Mini App if not web platform
+      isWeb: platform === "web"
+      // Telegram Web if web platform
+    });
+    return true;
+  }
+  /**
+   * Restore session from existing wallet (for storage restoration)
+   */
+  async restoreSession(chainId) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    try {
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        return null;
+      }
+      const status = await this.wallet.checkConnectStatus();
+      if (status && status.address) {
+        this.currentAddress = status.address;
+        const account = {
+          universalAddress: createUniversalAddress(targetChainId, status.address),
+          nativeAddress: status.address,
+          chainId: targetChainId,
+          chainType: ChainType.TRON,
+          isActive: true
+        };
+        this.setState("connected" /* CONNECTED */);
+        this.setAccount(account);
+        this.setupEventListeners();
+        return account;
+      }
+      return null;
+    } catch (error) {
+      console.debug("[WalletConnect Tron] Restore session failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Initialize WalletConnect wallet instance
+   * @param chainId - Optional chain ID to determine network (default: Mainnet)
+   */
+  initializeWallet(chainId) {
+    if (_WalletConnectTronAdapter.walletInstance && _WalletConnectTronAdapter.walletProjectId === this.projectId) {
+      return;
+    }
+    let appUrl = "";
+    if (typeof window !== "undefined") {
+      try {
+        if (window.location && window.location.origin) {
+          appUrl = window.location.origin;
+        } else if (window.location && window.location.href) {
+          const url = new URL(window.location.href);
+          appUrl = url.origin;
+        }
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Failed to get origin from window.location:", error);
+      }
+      if (appUrl && (appUrl.includes("serveo.net") || appUrl.includes("loca.lt") || appUrl.includes("ngrok.io") || appUrl.includes("ngrok-free.app") || appUrl.includes("cloudflared.io"))) {
+        console.log("[WalletConnect Tron] Detected tunnel service URL:", appUrl);
+        console.log("[WalletConnect Tron] \u26A0\uFE0F Make sure this URL is added to WalletConnect Cloud project allowlist");
+      }
+      if (!appUrl) {
+        const tg = window.Telegram?.WebApp;
+        if (tg && tg.initDataUnsafe?.start_param) {
+          appUrl = "https://enclave.network";
+        } else {
+          appUrl = "https://enclave.network";
+        }
+      }
+    } else {
+      appUrl = "https://enclave.network";
+    }
+    if (!appUrl || !appUrl.startsWith("http://") && !appUrl.startsWith("https://")) {
+      appUrl = "https://enclave.network";
+    }
+    const icons = [
+      "https://walletconnect.com/walletconnect-logo.svg",
+      "https://avatars.githubusercontent.com/u/37784886"
+      // WalletConnect GitHub avatar
+    ];
+    let network = walletconnectTron.WalletConnectChainID.Mainnet;
+    if (chainId !== void 0) {
+      if (chainId === 195 || chainId === _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID) {
+        network = walletconnectTron.WalletConnectChainID.Mainnet;
+      } else if (chainId === 201910292) {
+        network = walletconnectTron.WalletConnectChainID.Shasta;
+      } else if (chainId === 2494104990) {
+        network = walletconnectTron.WalletConnectChainID.Nile;
+      }
+    }
+    const metadataInfo = {
+      name: "Enclave Wallet SDK",
+      description: "Multi-chain wallet adapter for Enclave",
+      url: appUrl,
+      icons,
+      network,
+      chainId,
+      isTelegram: this.isTelegramMiniApp(),
+      projectId: this.projectId,
+      urlValid: appUrl && (appUrl.startsWith("http://") || appUrl.startsWith("https://")),
+      iconsValid: icons && icons.length > 0 && icons.every((icon) => icon && icon.startsWith("http")),
+      currentLocation: typeof window !== "undefined" ? window.location.href : "N/A",
+      telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A"
+    };
+    console.log("[WalletConnect Tron] Initializing with metadata:", metadataInfo);
+    if (!metadataInfo.urlValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid URL in metadata:", appUrl);
+    }
+    if (!metadataInfo.iconsValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid icons in metadata:", icons);
+    }
+    console.log("[WalletConnect Tron] Initializing wallet...", {
+      network,
+      chainId,
+      note: "If no wallets are in WalletConnect Explorer for TRON, QR code will be displayed for scanning"
+    });
+    _WalletConnectTronAdapter.walletInstance = new walletconnectTron.WalletConnectWallet({
+      network,
+      options: {
+        projectId: this.projectId,
+        metadata: {
+          name: "Enclave Wallet SDK",
+          description: "Multi-chain wallet adapter for Enclave",
+          url: appUrl,
+          icons
+        }
+      },
+      // Theme configuration
+      themeMode: "light",
+      themeVariables: {
+        "--w3m-z-index": 1e4
+        // Ensure modal appears above Telegram UI
+      },
+      // Web3Modal configuration for recommended wallets
+      // According to official docs: https://developers.tron.network/docs/walletconnect-tron
+      // Note: If no wallets are registered in WalletConnect Explorer for TRON,
+      // explorerRecommendedWalletIds will have no effect, and QR code will be shown instead.
+      // @ts-ignore - web3ModalConfig is supported but may not be in TypeScript types
+      web3ModalConfig: {
+        themeMode: "light",
+        themeVariables: {
+          "--w3m-z-index": 1e4
+        },
+        /**
+         * Recommended Wallets are fetched from WalletConnect explore api:
+         * https://walletconnect.com/explorer?type=wallet&version=2
+         * 
+         * IMPORTANT: If wallets are not registered in Explorer for TRON, this list will be ignored.
+         * The AppKit will show a QR code instead, which users can scan with any WalletConnect-compatible wallet.
+         * 
+         * Wallet IDs (for reference, may not work if not in Explorer):
+         * - TokenPocket: 20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66
+         * - TronLink: 1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369
+         */
+        explorerRecommendedWalletIds: [
+          // These IDs are kept for when wallets register in WalletConnect Explorer
+          // Currently, if no TRON wallets are in Explorer, QR code will be shown
+          "20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66",
+          // TokenPocket
+          "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369",
+          // TronLink
+          "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0"
+          // TokenPocket (backup)
+        ]
+      }
+    });
+    _WalletConnectTronAdapter.walletProjectId = this.projectId;
+  }
+  /**
+   * Connect wallet
+   */
+  async connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("WalletConnect requires a browser environment");
+    }
+    const currentState = this.state;
+    if (currentState === "connecting" /* CONNECTING */) {
+      console.warn("[WalletConnect Tron] Connection already in progress, waiting...");
+      let attempts = 0;
+      while (this.state === "connecting" /* CONNECTING */ && attempts < 50) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        attempts++;
+      }
+      if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+        return this.currentAccount;
+      }
+      if (this.state === "connecting" /* CONNECTING */) {
+        throw new Error("Connection timeout - previous connection attempt is still pending");
+      }
+    }
+    if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+      return this.currentAccount;
+    }
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        throw new Error("Failed to initialize WalletConnect wallet");
+      }
+      let network = walletconnectTron.WalletConnectChainID.Mainnet;
+      if (targetChainId === 195) {
+        network = walletconnectTron.WalletConnectChainID.Mainnet;
+      } else if (targetChainId === 201910292) {
+        network = walletconnectTron.WalletConnectChainID.Shasta;
+      } else if (targetChainId === 2494104990) {
+        network = walletconnectTron.WalletConnectChainID.Nile;
+      }
+      let address;
+      try {
+        console.log("[WalletConnect Tron] Attempting to connect...", {
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp(),
+          projectId: this.projectId
+        });
+        const result = await this.wallet.connect();
+        address = result.address;
+        if (!address) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        console.log("[WalletConnect Tron] Connection successful:", {
+          address,
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp()
+        });
+      } catch (error) {
+        const errorMessage = error.message || String(error);
+        const errorCode = error.code || error.error?.code;
+        const origin = typeof window !== "undefined" && window.location ? window.location.origin : "";
+        let detailedError = errorMessage;
+        if (error.error) {
+          if (typeof error.error === "string") {
+            detailedError = error.error;
+          } else if (error.error.message) {
+            detailedError = error.error.message;
+          } else if (error.error.data) {
+            detailedError = JSON.stringify(error.error.data);
+          }
+        }
+        const isNoWalletFound = errorMessage.includes("\u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305") || errorMessage.includes("No matching wallet") || errorMessage.includes("No wallet found") || errorMessage.includes("\u627E\u4E0D\u5230\u94B1\u5305") || errorMessage.includes("not found") || errorMessage.includes("no matching");
+        const isTimeout = errorMessage.includes("timeout") || errorMessage.includes("\u8D85\u65F6") || errorCode === "TIMEOUT";
+        const isRejected = errorMessage.includes("rejected") || errorMessage.includes("\u62D2\u7EDD") || errorCode === 4001;
+        const isOriginNotAllowed = errorCode === 3e3 || /origin not allowed/i.test(errorMessage) || /Unauthorized:\s*origin not allowed/i.test(errorMessage);
+        const currentMetadata = this.wallet ? {
+          // Try to get metadata from wallet instance if available
+          projectId: this.projectId,
+          network
+        } : null;
+        const errorDetails = {
+          error: errorMessage,
+          detailedError,
+          code: errorCode,
+          isTelegram: this.isTelegramMiniApp(),
+          network,
+          chainId: targetChainId,
+          projectId: this.projectId,
+          metadata: currentMetadata,
+          // Get URL from window.location if available
+          currentUrl: typeof window !== "undefined" ? window.location.href : "N/A",
+          telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A",
+          errorType: isNoWalletFound ? "NO_WALLET_FOUND" : isTimeout ? "TIMEOUT" : isRejected ? "REJECTED" : "UNKNOWN"
+        };
+        console.error("[WalletConnect Tron] Connection error - Full details:", errorDetails);
+        console.error("[WalletConnect Tron] Error object:", error);
+        console.error("[WalletConnect Tron] Error stack:", error.stack);
+        if (isNoWalletFound) {
+          const noWalletErrorDetails = [
+            `
+=== WalletConnect Tron: No Matching Wallet Found ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            ``,
+            `Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            ``,
+            `Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `  - Metadata URL: ${typeof window !== "undefined" ? window.location.origin : "N/A"}`,
+            ``,
+            `Possible Causes:`,
+            `  1. No WalletConnect-compatible wallet (TokenPocket, etc.) installed on device`,
+            `  2. Wallet app not opened or not responding to deep link (wc://)`,
+            `  3. Deep link handling issue in Telegram Mini App environment`,
+            `  4. WalletConnect session timeout (user took too long to approve)`,
+            `  5. Network connectivity issue preventing WalletConnect relay connection`,
+            ``,
+            `Solutions:`,
+            `  1. Ensure TokenPocket or other WalletConnect-compatible wallet is installed`,
+            `  2. Try opening the wallet app manually before connecting`,
+            `  3. In Telegram Mini App, ensure the deep link popup is not blocked`,
+            `  4. Try connecting again (may need to wait a few seconds)`,
+            `  5. Check network connection and WalletConnect relay server accessibility`,
+            ``,
+            `For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(noWalletErrorDetails);
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron: \u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305 (No matching wallet found)
+
+\u53EF\u80FD\u7684\u539F\u56E0\uFF1A
+1. \u8BBE\u5907\u4E0A\u672A\u5B89\u88C5\u652F\u6301 WalletConnect \u7684\u94B1\u5305\uFF08\u5982 TokenPocket\uFF09
+2. \u94B1\u5305\u5E94\u7528\u672A\u6253\u5F00\u6216\u672A\u54CD\u5E94 deep link (wc://)
+3. \u5728 Telegram Mini App \u4E2D\uFF0Cdeep link \u5904\u7406\u53EF\u80FD\u6709\u95EE\u9898
+4. \u8FDE\u63A5\u8D85\u65F6\uFF08\u7528\u6237\u672A\u53CA\u65F6\u6279\u51C6\uFF09
+5. \u7F51\u7EDC\u8FDE\u63A5\u95EE\u9898
+
+\u89E3\u51B3\u65B9\u6848\uFF1A
+1. \u786E\u4FDD\u5DF2\u5B89\u88C5 TokenPocket \u6216\u5176\u4ED6\u652F\u6301 WalletConnect \u7684\u94B1\u5305
+2. \u5C1D\u8BD5\u624B\u52A8\u6253\u5F00\u94B1\u5305\u5E94\u7528\u540E\u518D\u8FDE\u63A5
+3. \u5728 Telegram Mini App \u4E2D\uFF0C\u786E\u4FDD deep link \u5F39\u7A97\u672A\u88AB\u963B\u6B62
+4. \u7A0D\u7B49\u51E0\u79D2\u540E\u91CD\u8BD5\u8FDE\u63A5
+5. \u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u548C WalletConnect \u4E2D\u7EE7\u670D\u52A1\u5668\u53EF\u8BBF\u95EE\u6027
+
+\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\u65E5\u5FD7\u3002`
+          );
+        }
+        if (errorMessage.includes("Invalid") || errorMessage.includes("Configuration") || errorMessage.includes("App Config") || errorMessage.includes("Invalid App")) {
+          const configErrorDetails = [
+            `
+=== WalletConnect Tron Configuration Error ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            `
+Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            `
+Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `
+Possible Causes:`,
+            `  1. Deep link (wc://) handling issue in Telegram Mini App`,
+            `  2. Invalid metadata configuration (URL or icons not accessible)`,
+            `  3. Network/chainId mismatch`,
+            `  4. WalletConnect project ID not configured correctly`,
+            `  5. Domain not added to WalletConnect Cloud allowlist`,
+            `
+Please check:`,
+            `  - WalletConnect Project ID is valid and active`,
+            `  - Domain is added to WalletConnect Cloud allowlist (for serveo.net, etc.)`,
+            `  - Metadata URL is accessible: Check console for metadata logs`,
+            `  - Icons are accessible: Check console for icon URLs`,
+            `  - Network matches chainId: Expected ${network} for chainId ${targetChainId}`,
+            `
+For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(configErrorDetails);
+          throw new ConfigurationError(
+            `WalletConnect Tron connection failed: ${errorMessage}
+
+Configuration Details:
+- Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}
+- Platform: ${errorDetails.telegramPlatform}
+- Origin: ${origin || "(unknown)"}
+- Project ID: ${this.projectId ? "Set" : "Missing"}
+- Network: ${network}
+- Chain ID: ${targetChainId}
+
+This "Invalid App Configuration" error may be caused by:
+1. Deep link (wc://) handling issue in Telegram Mini App
+2. Invalid metadata configuration (URL or icons)
+3. Network/chainId mismatch
+4. Domain not added to WalletConnect Cloud allowlist
+
+Please check the console for detailed error information.`
+          );
+        }
+        if (isOriginNotAllowed) {
+          throw new ConfigurationError(
+            `WalletConnect Tron relayer rejected this origin (code 3000: Unauthorized: origin not allowed).
+
+Fix:
+1) Open WalletConnect Cloud \u2192 your project (${this.projectId})
+2) Add this site origin to the allowlist:
+   - ${origin || "(unknown origin)"}
+
+Common dev origins to allow:
+- http://localhost:5173
+- http://192.168.0.221:5173 (your LAN dev URL)
+- https://wallet-test.enclave-hq.com (your Cloudflare Tunnel/custom domain)
+
+Original error: ${errorMessage}`
+          );
+        }
+        if (isTimeout) {
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron connection timeout. Please try again and ensure your wallet app is open and ready.`
+          );
+        }
+        if (isRejected) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        throw error;
+      }
+      this.currentAddress = address;
+      const account = {
+        universalAddress: createUniversalAddress(targetChainId, address),
+        nativeAddress: address,
+        chainId: targetChainId,
+        chainType: ChainType.TRON,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      this.currentAddress = null;
+      if (error.message?.includes("rejected") || error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    this.removeEventListeners();
+    if (this.wallet) {
+      try {
+        await this.wallet.disconnect();
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Error during disconnect:", error);
+      }
+    }
+    this.wallet = null;
+    this.currentAddress = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * Sign message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      const signature = await this.wallet.signMessage(message);
+      if (typeof signature === "string") {
+        return signature;
+      } else if (signature && typeof signature === "object") {
+        if ("signature" in signature) {
+          return signature.signature;
+        } else if ("result" in signature) {
+          return signature.result;
+        } else {
+          return JSON.stringify(signature);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign message error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError();
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signMessage is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign message failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Sign transaction
+   * 
+   * @param transaction - Tron transaction object
+   *                      Can be created using TronWeb (if available) or any TRON transaction builder
+   *                      Format: { raw_data: {...}, raw_data_hex: "...", txID: "..." }
+   * @returns Signed transaction object or signature
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      if (!transaction) {
+        throw new Error("Transaction object is required");
+      }
+      console.log("[WalletConnect Tron] Signing transaction:", {
+        hasRawData: !!transaction.raw_data,
+        hasRawDataHex: !!transaction.raw_data_hex,
+        hasTxID: !!transaction.txID
+      });
+      const result = await this.wallet.signTransaction(transaction);
+      if (typeof result === "string") {
+        return result;
+      } else if (result && typeof result === "object") {
+        if ("txID" in result && typeof result.txID === "string") {
+          return result.txID;
+        } else if ("txid" in result && typeof result.txid === "string") {
+          return result.txid;
+        } else if ("signature" in result) {
+          return JSON.stringify(result);
+        } else {
+          return JSON.stringify(result);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign transaction error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else if (error?.data?.message) {
+        errorMessage = error.data.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError("Transaction signature was rejected by user");
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || errorMessage?.includes("Not support") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signTransaction is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign transaction failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Read contract (not supported by WalletConnect)
+   */
+  async readContract(_params) {
+    this.ensureConnected();
+    throw new Error("WalletConnect Tron does not support direct contract reading. Please use direct Tron RPC calls or a wallet extension (like TronLink) for read operations.");
+  }
+  /**
+   * Write contract (not yet implemented)
+   */
+  async writeContract(_params) {
+    throw new Error("Contract write not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Estimate gas (not yet implemented)
+   */
+  async estimateGas(_params) {
+    throw new Error("Gas estimation not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Wait for transaction (not yet implemented)
+   */
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new Error("Transaction waiting not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.on("accountsChanged", (accounts) => {
+      if (accounts && accounts.length > 0 && accounts[0] !== this.currentAddress) {
+        const newAddress = accounts[0];
+        this.currentAddress = newAddress;
+        if (this.currentAccount) {
+          const newAccount = {
+            ...this.currentAccount,
+            nativeAddress: newAddress,
+            universalAddress: createUniversalAddress(this.currentAccount.chainId, newAddress)
+          };
+          this.setAccount(newAccount);
+          this.emit("accountChanged", newAccount);
+        }
+      } else if (!accounts || accounts.length === 0) {
+        this.disconnect();
+      }
+    });
+    this.wallet.on("disconnect", () => {
+      this.disconnect();
+    });
+  }
+  /**
+   * Remove event listeners
+   */
+  removeEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.removeAllListeners("accountsChanged");
+    this.wallet.removeAllListeners("disconnect");
+  }
+  /**
+   * Get provider (returns wallet instance)
+   */
+  getProvider() {
+    return this.wallet;
+  }
+  /**
+   * Clear static wallet instance (for complete cleanup)
+   */
+  static clearWalletInstance() {
+    if (_WalletConnectTronAdapter.walletInstance) {
+      _WalletConnectTronAdapter.walletInstance.disconnect().catch(() => {
+      });
+      _WalletConnectTronAdapter.walletInstance = null;
+      _WalletConnectTronAdapter.walletProjectId = null;
+    }
+  }
+};
+// Tron 主网链 ID
+_WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID = 195;
+// Static wallet instance to avoid multiple initializations
+_WalletConnectTronAdapter.walletInstance = null;
+_WalletConnectTronAdapter.walletProjectId = null;
+var WalletConnectTronAdapter = _WalletConnectTronAdapter;
+
+// src/internal/walletconnect-tron-loader.esm.ts
+function loadWalletConnectTronModule() {
+  return wallet_connect_exports;
+}
+
+// src/adapters/deep-link/adapter.ts
+init_types();
+var _DeepLinkAdapter = class _DeepLinkAdapter extends WalletAdapter {
+  constructor(config) {
+    super();
+    this.currentChainId = null;
+    this.currentChainType = null;
+    this.provider = this.createProvider(config);
+    this.name = `${this.provider.name} (Deep Link)`;
+    this.icon = this.provider.icon;
+    if (this.provider.supportedChainTypes.includes(ChainType.EVM)) {
+      this.chainType = ChainType.EVM;
+      this.type = "deep-link-evm" /* DEEP_LINK_EVM */;
+    } else if (this.provider.supportedChainTypes.includes(ChainType.TRON)) {
+      this.chainType = ChainType.TRON;
+      this.type = "deep-link-tron" /* DEEP_LINK_TRON */;
+    } else {
+      this.chainType = ChainType.EVM;
+      this.type = "deep-link-evm" /* DEEP_LINK_EVM */;
+    }
+    if (typeof window !== "undefined") {
+      this.setupCallbackHandler();
+    }
+  }
+  /**
+   * Create provider instance based on type
+   */
+  createProvider(config) {
+    switch (config.providerType) {
+      case "tokenpocket" /* TOKENPOCKET */: {
+        const { TokenPocketDeepLinkProvider: TokenPocketDeepLinkProvider2 } = (init_tokenpocket(), __toCommonJS(tokenpocket_exports));
+        return new TokenPocketDeepLinkProvider2({
+          callbackUrl: config.callbackUrl,
+          callbackSchema: config.callbackSchema
+        });
+      }
+      case "tronlink" /* TRONLINK */: {
+        const { TronLinkDeepLinkProvider: TronLinkDeepLinkProvider2 } = (init_tronlink(), __toCommonJS(tronlink_exports));
+        return new TronLinkDeepLinkProvider2();
+      }
+      case "imtoken" /* IMTOKEN */: {
+        const { ImTokenDeepLinkProvider: ImTokenDeepLinkProvider2 } = (init_imtoken(), __toCommonJS(imtoken_exports));
+        return new ImTokenDeepLinkProvider2({
+          callbackUrl: config.callbackUrl,
+          callbackSchema: config.callbackSchema
+        });
+      }
+      case "metamask" /* METAMASK */: {
+        const { MetaMaskDeepLinkProvider: MetaMaskDeepLinkProvider2 } = (init_metamask(), __toCommonJS(metamask_exports));
+        return new MetaMaskDeepLinkProvider2();
+      }
+      case "okx" /* OKX */: {
+        const { OKXDeepLinkProvider: OKXDeepLinkProvider2 } = (init_okx(), __toCommonJS(okx_exports));
+        return new OKXDeepLinkProvider2();
+      }
+      default:
+        throw new Error(`Unsupported deep link provider type: ${config.providerType}`);
+    }
+  }
+  /**
+   * Setup callback handler for deep link results
+   */
+  setupCallbackHandler() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const handleUrlChange = () => {
+      const urlParams = new URLSearchParams(window.location.search);
+      const result = this.provider.parseCallbackResult(urlParams);
+      if (result.actionId && _DeepLinkAdapter.pendingActions.has(result.actionId)) {
+        const callback = _DeepLinkAdapter.pendingActions.get(result.actionId);
+        if (result.error) {
+          callback.reject(new Error(result.error));
+        } else if (result.result) {
+          callback.resolve(result.result);
+        }
+        _DeepLinkAdapter.pendingActions.delete(result.actionId);
+      }
+    };
+    window.addEventListener("popstate", handleUrlChange);
+    window.addEventListener("hashchange", handleUrlChange);
+    handleUrlChange();
+  }
+  /**
+   * Check if deep link is available
+   */
+  async isAvailable() {
+    return this.provider.isAvailable();
+  }
+  /**
+   * Connect to wallet via deep link
+   * 
+   * Note: Deep links typically don't support persistent connections
+   * This method may throw ConnectionRejectedError as deep links are
+   * primarily used for signing operations, not connection
+   */
+  async connect(chainId) {
+    const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId || 1;
+    let chainType;
+    if (targetChainId === 195) {
+      chainType = ChainType.TRON;
+    } else {
+      chainType = ChainType.EVM;
+    }
+    if (!this.provider.supportedChainTypes.includes(chainType)) {
+      throw new Error(
+        `Provider ${this.provider.name} does not support chain type ${chainType}`
+      );
+    }
+    if (this.provider.buildConnectLink) {
+      const linkInfo = this.provider.buildConnectLink({
+        chainId: targetChainId,
+        chainType
+      });
+      if (linkInfo.actionId) {
+        return new Promise((resolve, reject) => {
+          _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, {
+            resolve: (result) => {
+              const address = result?.address || result?.account || result;
+              if (!address || typeof address !== "string") {
+                reject(new ConnectionRejectedError("Invalid connection result: no address found"));
+                return;
+              }
+              const account = {
+                universalAddress: createUniversalAddress(targetChainId, address),
+                nativeAddress: address,
+                chainId: targetChainId,
+                chainType,
+                isActive: true
+              };
+              this.setState("connected" /* CONNECTED */);
+              this.setAccount(account);
+              this.emit("connected", account);
+              resolve(account);
+            },
+            reject: (error) => {
+              this.setState("disconnected" /* DISCONNECTED */);
+              reject(error);
+            }
+          });
+          window.location.href = linkInfo.url;
+          setTimeout(() => {
+            if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+              _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+              this.setState("disconnected" /* DISCONNECTED */);
+              reject(new ConnectionRejectedError("Deep link connection timeout"));
+            }
+          }, 3e4);
+        });
+      } else {
+        window.location.href = linkInfo.url;
+        throw new ConnectionRejectedError(
+          "Deep link connection initiated. Please complete the connection in your wallet app."
+        );
+      }
+    } else {
+      throw new ConnectionRejectedError(
+        `Deep link connection is not supported by ${this.provider.name}. Deep links are primarily used for signing operations.`
+      );
+    }
+  }
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect() {
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.currentChainId = null;
+    this.currentChainType = null;
+    this.emitDisconnected();
+  }
+  /**
+   * Sign a message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    if (!this.currentChainId || !this.currentChainType) {
+      throw new WalletNotConnectedError(this.type);
+    }
+    const linkInfo = this.provider.buildSignMessageLink({
+      message,
+      chainId: this.currentChainId,
+      chainType: this.currentChainType
+    });
+    if (linkInfo.callbackSchema || linkInfo.callbackUrl) {
+      return new Promise((resolve, reject) => {
+        _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, { resolve, reject });
+        window.location.href = linkInfo.url;
+        setTimeout(() => {
+          if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+            _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+            reject(new SignatureRejectedError("Message signature timeout"));
+          }
+        }, 3e4);
+      });
+    } else {
+      window.location.href = linkInfo.url;
+      throw new SignatureRejectedError(
+        "Deep link signature initiated. Please complete the signature in your wallet app."
+      );
+    }
+  }
+  /**
+   * Sign a transaction
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    if (!this.currentChainId || !this.currentChainType) {
+      throw new WalletNotConnectedError(this.type);
+    }
+    const linkInfo = this.provider.buildSignTransactionLink({
+      transaction,
+      chainId: this.currentChainId,
+      chainType: this.currentChainType
+    });
+    if (linkInfo.callbackSchema || linkInfo.callbackUrl) {
+      return new Promise((resolve, reject) => {
+        _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, { resolve, reject });
+        window.location.href = linkInfo.url;
+        setTimeout(() => {
+          if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+            _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+            reject(new SignatureRejectedError("Transaction signature timeout"));
+          }
+        }, 3e4);
+      });
+    } else {
+      window.location.href = linkInfo.url;
+      throw new SignatureRejectedError(
+        "Deep link transaction signature initiated. Please complete the signature in your wallet app."
+      );
+    }
+  }
+  /**
+   * Get provider (not applicable for deep links)
+   */
+  getProvider() {
+    return null;
+  }
+  /**
+   * Static method to handle callback from wallet apps
+   * This can be called from anywhere in the application
+   */
+  static handleCallback() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const urlParams = new URLSearchParams(window.location.search);
+    const actionId = urlParams.get("actionId");
+    if (actionId && _DeepLinkAdapter.pendingActions.has(actionId)) {
+      const callback = _DeepLinkAdapter.pendingActions.get(actionId);
+      const result = urlParams.get("result");
+      const error = urlParams.get("error");
+      if (error) {
+        callback.reject(new Error(error));
+      } else if (result) {
+        try {
+          const parsedResult = JSON.parse(decodeURIComponent(result));
+          callback.resolve(parsedResult);
+        } catch (e) {
+          callback.resolve(result);
+        }
+      }
+      _DeepLinkAdapter.pendingActions.delete(actionId);
+    }
+  }
+  /**
+   * Set current account (called after successful connection)
+   */
+  setAccount(account) {
+    this.currentAccount = account;
+    if (account) {
+      this.currentChainId = account.chainId;
+      this.currentChainType = account.chainType;
+    }
+  }
+  /**
+   * Emit disconnected event
+   */
+  emitDisconnected() {
+    this.emit("disconnected");
+  }
+};
+// Static map to store pending actions across all instances
+// Key: actionId, Value: { resolve, reject }
+_DeepLinkAdapter.pendingActions = /* @__PURE__ */ new Map();
+var DeepLinkAdapter = _DeepLinkAdapter;
+
+// src/core/adapter-registry.ts
+var AdapterRegistry = class {
+  constructor(config = {}) {
+    this.adapters = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.registerDefaultAdapters();
+  }
+  /**
+   * Register default adapters
+   */
+  registerDefaultAdapters() {
+    this.register("metamask" /* METAMASK */, () => new MetaMaskAdapter());
+    this.register("private-key" /* PRIVATE_KEY */, () => new EVMPrivateKeyAdapter());
+    if (this.config.walletConnectProjectId) {
+      this.register(
+        "walletconnect" /* WALLETCONNECT */,
+        () => new WalletConnectAdapter(this.config.walletConnectProjectId)
+      );
+      this.register("walletconnect-tron" /* WALLETCONNECT_TRON */, () => {
+        const { WalletConnectTronAdapter: WalletConnectTronAdapter2 } = loadWalletConnectTronModule();
+        return new WalletConnectTronAdapter2(this.config.walletConnectProjectId);
+      });
+    }
+    this.register("tronlink" /* TRONLINK */, () => new TronLinkAdapter());
+    this.register(
+      "deep-link-evm" /* DEEP_LINK_EVM */,
+      () => new DeepLinkAdapter({
+        providerType: "tokenpocket" /* TOKENPOCKET */
+      })
+    );
+    this.register(
+      "deep-link-tron" /* DEEP_LINK_TRON */,
+      () => new DeepLinkAdapter({
+        providerType: "tokenpocket" /* TOKENPOCKET */
+      })
+    );
+  }
+  /**
+   * Register adapter
+   */
+  register(type, factory) {
+    this.adapters.set(type, factory);
+  }
+  /**
+   * Get adapter
+   */
+  getAdapter(type) {
+    const factory = this.adapters.get(type);
+    if (!factory) {
+      return null;
+    }
+    return factory();
+  }
+  /**
    * Check if adapter is registered
    */
   has(type) {
@@ -1602,6 +4502,190 @@ var AdapterRegistry = class {
   }
 };
 
+// src/core/wallet-manager.ts
+init_types();
+var QRCodeSigner = class {
+  constructor(config) {
+    this.pollTimer = null;
+    this.timeoutTimer = null;
+    this.status = "waiting" /* WAITING */;
+    this.qrCodeDataUrl = null;
+    this.result = null;
+    this.config = {
+      requestId: config.requestId,
+      requestUrl: config.requestUrl,
+      pollUrl: config.pollUrl || "",
+      pollInterval: config.pollInterval || 2e3,
+      timeout: config.timeout || 3e5,
+      // 5 minutes
+      pollFn: config.pollFn
+    };
+  }
+  /**
+   * 生成二维码图片（Data URL）
+   */
+  async generateQRCode(options) {
+    if (this.qrCodeDataUrl) {
+      return this.qrCodeDataUrl;
+    }
+    try {
+      const qrCodeOptions = {
+        width: options?.width || 300,
+        margin: options?.margin || 2,
+        color: {
+          dark: options?.color?.dark || "#000000",
+          light: options?.color?.light || "#FFFFFF"
+        }
+      };
+      this.qrCodeDataUrl = await QRCode__default.default.toDataURL(this.config.requestUrl, qrCodeOptions);
+      return this.qrCodeDataUrl;
+    } catch (error) {
+      throw new Error(`Failed to generate QR code: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * 开始轮询签名结果
+   */
+  async startPolling(onStatusChange, onResult) {
+    if (this.status === "success" /* SUCCESS */ && this.result?.signature) {
+      return this.result.signature;
+    }
+    if (this.status === "cancelled" /* CANCELLED */ || this.status === "timeout" /* TIMEOUT */) {
+      throw new SignatureRejectedError("Signature request was cancelled or timed out");
+    }
+    this.timeoutTimer = setTimeout(() => {
+      this.stopPolling();
+      this.status = "timeout" /* TIMEOUT */;
+      onStatusChange?.(this.status);
+      throw new SignatureRejectedError("Signature request timed out");
+    }, this.config.timeout);
+    return new Promise((resolve, reject) => {
+      const poll = async () => {
+        try {
+          let result = null;
+          if (this.config.pollFn) {
+            result = await this.config.pollFn(this.config.requestId);
+          } else if (this.config.pollUrl) {
+            result = await this.defaultPoll(this.config.requestId);
+          } else {
+            return;
+          }
+          if (result?.completed) {
+            this.stopPolling();
+            this.result = result;
+            if (result.signature) {
+              this.status = "success" /* SUCCESS */;
+              onStatusChange?.(this.status);
+              onResult?.(result);
+              resolve(result.signature);
+            } else if (result.error) {
+              this.status = "failed" /* FAILED */;
+              onStatusChange?.(this.status);
+              reject(new SignatureRejectedError(result.error));
+            }
+          } else if (result) {
+            if (this.status === "waiting" /* WAITING */) {
+              this.status = "pending" /* PENDING */;
+              onStatusChange?.(this.status);
+            }
+            this.pollTimer = setTimeout(poll, this.config.pollInterval);
+          } else {
+            this.pollTimer = setTimeout(poll, this.config.pollInterval);
+          }
+        } catch (error) {
+          this.stopPolling();
+          this.status = "failed" /* FAILED */;
+          onStatusChange?.(this.status);
+          reject(error);
+        }
+      };
+      poll();
+    });
+  }
+  /**
+   * 默认 HTTP 轮询函数
+   */
+  async defaultPoll(requestId) {
+    if (!this.config.pollUrl) {
+      return null;
+    }
+    try {
+      const url = `${this.config.pollUrl}?requestId=${encodeURIComponent(requestId)}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new NetworkError(`Poll request failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        completed: data.completed === true,
+        signature: data.signature,
+        error: data.error,
+        signer: data.signer
+      };
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      return null;
+    }
+  }
+  /**
+   * 停止轮询
+   */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+  }
+  /**
+   * 取消签名请求
+   */
+  cancel() {
+    this.stopPolling();
+    this.status = "cancelled" /* CANCELLED */;
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 获取二维码 URL
+   */
+  getQRCodeUrl() {
+    return this.config.requestUrl;
+  }
+  /**
+   * 获取结果
+   */
+  getResult() {
+    return this.result;
+  }
+  /**
+   * 清理资源
+   */
+  cleanup() {
+    this.stopPolling();
+    this.qrCodeDataUrl = null;
+    this.result = null;
+    this.status = "waiting" /* WAITING */;
+  }
+};
+
 // src/core/wallet-manager.ts
 var WalletManager = class extends TypedEventEmitter {
   constructor(config = {}) {
@@ -1617,9 +4701,15 @@ var WalletManager = class extends TypedEventEmitter {
       defaultTronChainId: config.defaultTronChainId ?? 195,
       walletConnectProjectId: config.walletConnectProjectId ?? ""
     };
-    this.registry = new AdapterRegistry();
+    this.registry = new AdapterRegistry(this.config);
   }
   // ===== Connection Management =====
+  /**
+   * Check if adapter is registered for a wallet type
+   */
+  hasAdapter(type) {
+    return this.registry.has(type);
+  }
   /**
    * Connect primary wallet
    */
@@ -1686,7 +4776,7 @@ var WalletManager = class extends TypedEventEmitter {
     this.connectedWallets.delete(chainType);
     this.primaryWallet = null;
     if (this.config.enableStorage) {
-      this.saveToStorage();
+      this.clearStorage();
     }
     this.emit("disconnected");
   }
@@ -1775,6 +4865,35 @@ var WalletManager = class extends TypedEventEmitter {
     }
     return adapter.signMessage(message);
   }
+  /**
+   * Create QR code signer for message signing
+   * 
+   * This method creates a QR code signer that can be used to display a QR code
+   * for users to scan with their wallet app to sign a message.
+   * 
+   * @param message - Message to sign
+   * @param config - QR code signer configuration
+   * @returns QRCodeSigner instance
+   * 
+   * @example
+   * ```typescript
+   * const signer = walletManager.createQRCodeSigner('Hello World', {
+   *   requestId: 'sign-123',
+   *   requestUrl: 'https://example.com/sign?requestId=sign-123&message=Hello%20World',
+   *   pollUrl: 'https://api.example.com/sign/status',
+   * })
+   * 
+   * const qrCodeUrl = await signer.generateQRCode()
+   * const signature = await signer.startPolling()
+   * ```
+   */
+  createQRCodeSigner(message, config) {
+    return new QRCodeSigner({
+      ...config,
+      // Encode message in request URL if not already encoded
+      requestUrl: config.requestUrl.includes(encodeURIComponent(message)) ? config.requestUrl : `${config.requestUrl}${config.requestUrl.includes("?") ? "&" : "?"}message=${encodeURIComponent(message)}`
+    });
+  }
   /**
    * Sign TypedData (EVM only)
    */
@@ -1839,6 +4958,41 @@ var WalletManager = class extends TypedEventEmitter {
       throw error;
     }
   }
+  /**
+   * Request account switch (opens wallet account selector)
+   * @param targetAddress Optional target address to verify after switching
+   * @returns The new account after switching
+   */
+  async requestSwitchAccount(targetAddress) {
+    if (!this.primaryWallet) {
+      throw new WalletNotConnectedError();
+    }
+    if (!this.primaryWallet.requestSwitchAccount) {
+      throw new Error(`Account switching not supported by ${this.primaryWallet.type}`);
+    }
+    const account = await this.primaryWallet.requestSwitchAccount(targetAddress);
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    return account;
+  }
+  /**
+   * Ensure the current account matches the target address
+   * If not matching, request account switch
+   * @param targetAddress The address that should be active
+   * @returns The account (either existing or after switch)
+   */
+  async ensureAccount(targetAddress) {
+    const currentAccount = this.getPrimaryAccount();
+    if (!currentAccount) {
+      throw new WalletNotConnectedError();
+    }
+    if (currentAccount.nativeAddress.toLowerCase() === targetAddress.toLowerCase()) {
+      return currentAccount;
+    }
+    console.log(`[WalletManager] Current account ${currentAccount.nativeAddress} doesn't match target ${targetAddress}, requesting switch...`);
+    return this.requestSwitchAccount(targetAddress);
+  }
   // ===== Contract Calls =====
   /**
    * Read contract
@@ -2085,6 +5239,29 @@ var WalletManager = class extends TypedEventEmitter {
           console.debug("Silent TronLink connection failed:", silentError);
         }
       }
+      if (data.primaryWalletType === "walletconnect-tron" /* WALLETCONNECT_TRON */) {
+        try {
+          const wcAdapter = adapter;
+          if (typeof wcAdapter.restoreSession === "function") {
+            console.debug("[WalletManager] Attempting to restore WalletConnect Tron session...");
+            const account2 = await wcAdapter.restoreSession(data.primaryChainId);
+            if (account2) {
+              console.debug("[WalletManager] WalletConnect Tron session restored successfully");
+              this.setPrimaryWallet(adapter);
+              this.connectedWallets.set(adapter.chainType, adapter);
+              this.setupAdapterListeners(adapter, true);
+              this.emit("accountChanged", account2);
+              return account2;
+            } else {
+              console.debug("[WalletManager] No valid WalletConnect Tron session found");
+              return null;
+            }
+          }
+        } catch (restoreError) {
+          console.debug("[WalletManager] WalletConnect Tron restore failed:", restoreError);
+          return null;
+        }
+      }
       const account = await adapter.connect(data.primaryChainId);
       this.setPrimaryWallet(adapter);
       this.connectedWallets.set(adapter.chainType, adapter);
@@ -2132,44 +5309,44 @@ var WalletManager = class extends TypedEventEmitter {
 };
 
 // src/react/WalletContext.tsx
-var WalletContext = React.createContext(null);
+var WalletContext = React2.createContext(null);
 function WalletProvider({ children, walletManager: externalWalletManager }) {
-  const [walletManager] = React.useState(() => externalWalletManager || new WalletManager());
-  const [account, setAccount] = React.useState(null);
-  const [connectedWallets, setConnectedWallets] = React.useState([]);
-  const [isRestoring, setIsRestoring] = React.useState(true);
-  const updateConnectedWallets = React.useCallback(() => {
+  const [walletManager] = React2.useState(() => externalWalletManager || new WalletManager());
+  const [account, setAccount] = React2.useState(null);
+  const [connectedWallets, setConnectedWallets] = React2.useState([]);
+  const [isRestoring, setIsRestoring] = React2.useState(true);
+  const updateConnectedWallets = React2.useCallback(() => {
     setConnectedWallets(walletManager.getConnectedWallets());
   }, [walletManager]);
-  const connect = React.useCallback(async (type, chainId) => {
+  const connect = React2.useCallback(async (type, chainId) => {
     const account2 = await walletManager.connect(type, chainId);
     setAccount(account2);
     updateConnectedWallets();
     return account2;
   }, [walletManager, updateConnectedWallets]);
-  const connectAdditional = React.useCallback(async (type, chainId) => {
+  const connectAdditional = React2.useCallback(async (type, chainId) => {
     const account2 = await walletManager.connectAdditional(type, chainId);
     updateConnectedWallets();
     return account2;
   }, [walletManager, updateConnectedWallets]);
-  const disconnect = React.useCallback(async () => {
+  const disconnect = React2.useCallback(async () => {
     await walletManager.disconnect();
     setAccount(null);
     updateConnectedWallets();
   }, [walletManager, updateConnectedWallets]);
-  const switchPrimaryWallet = React.useCallback(async (chainType) => {
+  const switchPrimaryWallet = React2.useCallback(async (chainType) => {
     const account2 = await walletManager.switchPrimaryWallet(chainType);
     setAccount(account2);
     updateConnectedWallets();
     return account2;
   }, [walletManager, updateConnectedWallets]);
-  const signMessage = React.useCallback(async (message) => {
+  const signMessage = React2.useCallback(async (message) => {
     return walletManager.signMessage(message);
   }, [walletManager]);
-  const signTransaction = React.useCallback(async (transaction) => {
+  const signTransaction = React2.useCallback(async (transaction) => {
     return walletManager.signTransaction(transaction);
   }, [walletManager]);
-  React.useEffect(() => {
+  React2.useEffect(() => {
     const restoreConnection = async () => {
       try {
         const restoredAccount = await walletManager.restoreFromStorage();
@@ -2185,7 +5362,7 @@ function WalletProvider({ children, walletManager: externalWalletManager }) {
     };
     restoreConnection();
   }, [walletManager, updateConnectedWallets]);
-  React.useEffect(() => {
+  React2.useEffect(() => {
     const handleAccountChanged = (newAccount) => {
       setAccount(newAccount);
       updateConnectedWallets();
@@ -2233,10 +5410,10 @@ function WalletProvider({ children, walletManager: externalWalletManager }) {
     signMessage,
     signTransaction
   };
-  return /* @__PURE__ */ React__default.default.createElement(WalletContext.Provider, { value }, children);
+  return /* @__PURE__ */ React2__default.default.createElement(WalletContext.Provider, { value }, children);
 }
 function useWallet() {
-  const context = React.useContext(WalletContext);
+  const context = React2.useContext(WalletContext);
   if (!context) {
     throw new Error("useWallet must be used within a WalletProvider");
   }
@@ -2256,8 +5433,8 @@ function useAccount() {
 }
 function useConnect() {
   const { connect: contextConnect, connectAdditional: contextConnectAdditional } = useWallet();
-  const [isConnecting, setIsConnecting] = React.useState(false);
-  const [error, setError] = React.useState(null);
+  const [isConnecting, setIsConnecting] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
   const connect = async (type, chainId) => {
     setIsConnecting(true);
     setError(null);
@@ -2295,8 +5472,8 @@ function useConnect() {
 }
 function useDisconnect() {
   const { disconnect: contextDisconnect } = useWallet();
-  const [isDisconnecting, setIsDisconnecting] = React.useState(false);
-  const [error, setError] = React.useState(null);
+  const [isDisconnecting, setIsDisconnecting] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
   const disconnect = async () => {
     setIsDisconnecting(true);
     setError(null);
@@ -2318,8 +5495,8 @@ function useDisconnect() {
 }
 function useSignMessage() {
   const { signMessage: contextSignMessage } = useWallet();
-  const [isSigning, setIsSigning] = React.useState(false);
-  const [error, setError] = React.useState(null);
+  const [isSigning, setIsSigning] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
   const signMessage = async (message) => {
     setIsSigning(true);
     setError(null);
@@ -2342,8 +5519,8 @@ function useSignMessage() {
 }
 function useSignTransaction() {
   const { signTransaction: contextSignTransaction } = useWallet();
-  const [isSigning, setIsSigning] = React.useState(false);
-  const [error, setError] = React.useState(null);
+  const [isSigning, setIsSigning] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
   const signTransaction = async (transaction) => {
     setIsSigning(true);
     setError(null);
@@ -2364,11 +5541,381 @@ function useSignTransaction() {
     error
   };
 }
+function useQRCodeSigner(config) {
+  const [qrCodeDataUrl, setQrCodeDataUrl] = React2.useState(null);
+  const [status, setStatus] = React2.useState("waiting" /* WAITING */);
+  const [result, setResult] = React2.useState(null);
+  const [isPolling, setIsPolling] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const signerRef = React2.useRef(null);
+  React2.useEffect(() => {
+    signerRef.current = new QRCodeSigner(config);
+    return () => {
+      signerRef.current?.cleanup();
+    };
+  }, [config.requestId, config.requestUrl, config.pollUrl]);
+  const generateQRCode = React2.useCallback(async () => {
+    if (!signerRef.current) return;
+    try {
+      const dataUrl = await signerRef.current.generateQRCode();
+      setQrCodeDataUrl(dataUrl);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    }
+  }, []);
+  const startSign = React2.useCallback(async () => {
+    if (!signerRef.current) {
+      throw new Error("QRCodeSigner not initialized");
+    }
+    setError(null);
+    setStatus("waiting" /* WAITING */);
+    setIsPolling(true);
+    try {
+      await generateQRCode();
+      const signature = await signerRef.current.startPolling(
+        (newStatus) => {
+          setStatus(newStatus);
+        },
+        (signResult) => {
+          setResult(signResult);
+        }
+      );
+      setIsPolling(false);
+      return signature;
+    } catch (err) {
+      setIsPolling(false);
+      const error2 = err instanceof Error ? err : new SignatureRejectedError(err instanceof Error ? err.message : String(err));
+      setError(error2);
+      throw error2;
+    }
+  }, [generateQRCode]);
+  const stopPolling = React2.useCallback(() => {
+    signerRef.current?.stopPolling();
+    setIsPolling(false);
+  }, []);
+  const cancel = React2.useCallback(() => {
+    signerRef.current?.cancel();
+    setStatus("cancelled" /* CANCELLED */);
+    setIsPolling(false);
+  }, []);
+  return {
+    qrCodeDataUrl,
+    status,
+    result,
+    isPolling,
+    startSign,
+    stopPolling,
+    cancel,
+    error
+  };
+}
+function QRCodeModal({
+  isOpen,
+  onClose,
+  qrCodeDataUrl,
+  status,
+  error,
+  title = "\u626B\u7801\u7B7E\u540D",
+  description
+}) {
+  React2.useEffect(() => {
+    if (isOpen) {
+      document.body.style.overflow = "hidden";
+    } else {
+      document.body.style.overflow = "";
+    }
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, [isOpen]);
+  if (!isOpen) {
+    return null;
+  }
+  const getStatusText = () => {
+    switch (status) {
+      case "waiting" /* WAITING */:
+        return "\u8BF7\u4F7F\u7528\u94B1\u5305\u626B\u63CF\u4E8C\u7EF4\u7801";
+      case "pending" /* PENDING */:
+        return "\u5DF2\u626B\u63CF\uFF0C\u8BF7\u5728\u94B1\u5305\u4E2D\u786E\u8BA4\u7B7E\u540D";
+      case "success" /* SUCCESS */:
+        return "\u7B7E\u540D\u6210\u529F";
+      case "failed" /* FAILED */:
+        return "\u7B7E\u540D\u5931\u8D25";
+      case "timeout" /* TIMEOUT */:
+        return "\u7B7E\u540D\u8D85\u65F6";
+      case "cancelled" /* CANCELLED */:
+        return "\u5DF2\u53D6\u6D88";
+      default:
+        return "\u7B49\u5F85\u626B\u63CF";
+    }
+  };
+  const getStatusColor = () => {
+    switch (status) {
+      case "waiting" /* WAITING */:
+      case "pending" /* PENDING */:
+        return "#3b82f6";
+      // blue
+      case "success" /* SUCCESS */:
+        return "#10b981";
+      // green
+      case "failed" /* FAILED */:
+      case "timeout" /* TIMEOUT */:
+      case "cancelled" /* CANCELLED */:
+        return "#ef4444";
+      // red
+      default:
+        return "#6b7280";
+    }
+  };
+  return /* @__PURE__ */ React2__default.default.createElement(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "rgba(0, 0, 0, 0.5)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        zIndex: 1e4,
+        padding: "20px"
+      },
+      onClick: (e) => {
+        if (e.target === e.currentTarget) {
+          onClose();
+        }
+      }
+    },
+    /* @__PURE__ */ React2__default.default.createElement(
+      "div",
+      {
+        style: {
+          backgroundColor: "#ffffff",
+          borderRadius: "12px",
+          padding: "24px",
+          maxWidth: "400px",
+          width: "100%",
+          boxShadow: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04)"
+        }
+      },
+      /* @__PURE__ */ React2__default.default.createElement(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "space-between",
+            alignItems: "center",
+            marginBottom: "20px"
+          }
+        },
+        /* @__PURE__ */ React2__default.default.createElement(
+          "h2",
+          {
+            style: {
+              margin: 0,
+              fontSize: "20px",
+              fontWeight: 600,
+              color: "#111827"
+            }
+          },
+          title
+        ),
+        /* @__PURE__ */ React2__default.default.createElement(
+          "button",
+          {
+            onClick: onClose,
+            style: {
+              background: "none",
+              border: "none",
+              fontSize: "24px",
+              cursor: "pointer",
+              color: "#6b7280",
+              padding: 0,
+              width: "24px",
+              height: "24px",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center"
+            }
+          },
+          "\xD7"
+        )
+      ),
+      description && /* @__PURE__ */ React2__default.default.createElement(
+        "p",
+        {
+          style: {
+            margin: "0 0 20px 0",
+            fontSize: "14px",
+            color: "#6b7280"
+          }
+        },
+        description
+      ),
+      /* @__PURE__ */ React2__default.default.createElement(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "center",
+            marginBottom: "20px"
+          }
+        },
+        qrCodeDataUrl ? /* @__PURE__ */ React2__default.default.createElement(
+          "img",
+          {
+            src: qrCodeDataUrl,
+            alt: "QR Code",
+            style: {
+              width: "100%",
+              maxWidth: "300px",
+              height: "auto",
+              border: "1px solid #e5e7eb",
+              borderRadius: "8px"
+            }
+          }
+        ) : /* @__PURE__ */ React2__default.default.createElement(
+          "div",
+          {
+            style: {
+              width: "300px",
+              height: "300px",
+              backgroundColor: "#f3f4f6",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              borderRadius: "8px",
+              color: "#6b7280"
+            }
+          },
+          "\u751F\u6210\u4E8C\u7EF4\u7801\u4E2D..."
+        )
+      ),
+      /* @__PURE__ */ React2__default.default.createElement(
+        "div",
+        {
+          style: {
+            textAlign: "center",
+            marginBottom: "20px"
+          }
+        },
+        /* @__PURE__ */ React2__default.default.createElement(
+          "div",
+          {
+            style: {
+              display: "inline-flex",
+              alignItems: "center",
+              gap: "8px",
+              padding: "8px 16px",
+              borderRadius: "6px",
+              backgroundColor: `${getStatusColor()}15`,
+              color: getStatusColor(),
+              fontSize: "14px",
+              fontWeight: 500
+            }
+          },
+          status === "waiting" /* WAITING */ && /* @__PURE__ */ React2__default.default.createElement(
+            "div",
+            {
+              style: {
+                width: "8px",
+                height: "8px",
+                borderRadius: "50%",
+                backgroundColor: getStatusColor(),
+                animation: "pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite"
+              }
+            }
+          ),
+          status === "pending" /* PENDING */ && /* @__PURE__ */ React2__default.default.createElement(
+            "div",
+            {
+              style: {
+                width: "8px",
+                height: "8px",
+                borderRadius: "50%",
+                backgroundColor: getStatusColor()
+              }
+            }
+          ),
+          status === "success" /* SUCCESS */ && "\u2713",
+          status === "failed" /* FAILED */ && "\u2715",
+          getStatusText()
+        )
+      ),
+      error && /* @__PURE__ */ React2__default.default.createElement(
+        "div",
+        {
+          style: {
+            padding: "12px",
+            backgroundColor: "#fef2f2",
+            border: "1px solid #fecaca",
+            borderRadius: "6px",
+            marginBottom: "20px"
+          }
+        },
+        /* @__PURE__ */ React2__default.default.createElement(
+          "p",
+          {
+            style: {
+              margin: 0,
+              fontSize: "14px",
+              color: "#dc2626"
+            }
+          },
+          error.message
+        )
+      ),
+      /* @__PURE__ */ React2__default.default.createElement(
+        "div",
+        {
+          style: {
+            display: "flex",
+            gap: "12px"
+          }
+        },
+        /* @__PURE__ */ React2__default.default.createElement(
+          "button",
+          {
+            onClick: onClose,
+            style: {
+              flex: 1,
+              padding: "10px 20px",
+              border: "1px solid #d1d5db",
+              borderRadius: "6px",
+              backgroundColor: "#ffffff",
+              color: "#374151",
+              fontSize: "14px",
+              fontWeight: 500,
+              cursor: "pointer"
+            }
+          },
+          status === "success" /* SUCCESS */ ? "\u5173\u95ED" : "\u53D6\u6D88"
+        )
+      )
+    ),
+    /* @__PURE__ */ React2__default.default.createElement("style", null, `
+        @keyframes pulse {
+          0%, 100% {
+            opacity: 1;
+          }
+          50% {
+            opacity: 0.5;
+          }
+        }
+      `)
+  );
+}
 
+exports.QRCodeModal = QRCodeModal;
 exports.WalletProvider = WalletProvider;
 exports.useAccount = useAccount;
 exports.useConnect = useConnect;
 exports.useDisconnect = useDisconnect;
+exports.useQRCodeSigner = useQRCodeSigner;
 exports.useSignMessage = useSignMessage;
 exports.useSignTransaction = useSignTransaction;
 exports.useWallet = useWallet;