@enclave-hq/wallet-sdk 1.2.3 → 1.2.5

package/dist/index.js

@@ -2,16 +2,609 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var EventEmitter = require('eventemitter3');
 var chainUtils = require('@enclave-hq/chain-utils');
+var EventEmitter = require('eventemitter3');
 var viem = require('viem');
 var accounts = require('viem/accounts');
+var EthereumProvider = require('@walletconnect/ethereum-provider');
+var module$1 = require('module');
+var path = require('path');
+var url = require('url');
+var QRCode = require('qrcode');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var EthereumProvider__default = /*#__PURE__*/_interopDefault(EthereumProvider);
+var QRCode__default = /*#__PURE__*/_interopDefault(QRCode);
+
+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);
+exports.ChainType = void 0; exports.WalletType = void 0; exports.WalletState = void 0;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    exports.ChainType = chainUtils.ChainType;
+    exports.WalletType = /* @__PURE__ */ ((WalletType3) => {
+      WalletType3["METAMASK"] = "metamask";
+      WalletType3["WALLETCONNECT"] = "walletconnect";
+      WalletType3["COINBASE_WALLET"] = "coinbase-wallet";
+      WalletType3["TRONLINK"] = "tronlink";
+      WalletType3["WALLETCONNECT_TRON"] = "walletconnect-tron";
+      WalletType3["PRIVATE_KEY"] = "private-key";
+      WalletType3["DEEP_LINK_EVM"] = "deep-link-evm";
+      WalletType3["DEEP_LINK_TRON"] = "deep-link-tron";
+      return WalletType3;
+    })(exports.WalletType || {});
+    exports.WalletState = /* @__PURE__ */ ((WalletState2) => {
+      WalletState2["DISCONNECTED"] = "disconnected";
+      WalletState2["CONNECTING"] = "connecting";
+      WalletState2["CONNECTED"] = "connected";
+      WalletState2["ERROR"] = "error";
+      return WalletState2;
+    })(exports.WalletState || {});
+  }
+});
+
+// src/adapters/deep-link/providers/tokenpocket.ts
+var tokenpocket_exports = {};
+__export(tokenpocket_exports, {
+  TokenPocketDeepLinkProvider: () => exports.TokenPocketDeepLinkProvider
+});
+exports.TokenPocketDeepLinkProvider = void 0;
+var init_tokenpocket = __esm({
+  "src/adapters/deep-link/providers/tokenpocket.ts"() {
+    init_types();
+    exports.TokenPocketDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "TokenPocket";
+        this.icon = "https://tokenpocket.pro/icon.png";
+        this.supportedChainTypes = [exports.ChainType.EVM, exports.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 === exports.ChainType.TRON) {
+          return {
+            chainId: String(chainId),
+            network: "tron"
+          };
+        } else if (chainType === exports.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 === exports.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: () => exports.TronLinkDeepLinkProvider
+});
+exports.TronLinkDeepLinkProvider = void 0;
+var init_tronlink = __esm({
+  "src/adapters/deep-link/providers/tronlink.ts"() {
+    init_types();
+    exports.TronLinkDeepLinkProvider = class {
+      constructor() {
+        this.name = "TronLink";
+        this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+        this.supportedChainTypes = [exports.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 !== exports.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 !== exports.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 !== exports.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: () => exports.ImTokenDeepLinkProvider
+});
+exports.ImTokenDeepLinkProvider = void 0;
+var init_imtoken = __esm({
+  "src/adapters/deep-link/providers/imtoken.ts"() {
+    init_types();
+    exports.ImTokenDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "ImToken";
+        this.icon = "https://token.im/static/img/logo.png";
+        this.supportedChainTypes = [exports.ChainType.EVM, exports.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: () => exports.MetaMaskDeepLinkProvider
+});
+exports.MetaMaskDeepLinkProvider = void 0;
+var init_metamask = __esm({
+  "src/adapters/deep-link/providers/metamask.ts"() {
+    init_types();
+    exports.MetaMaskDeepLinkProvider = class {
+      constructor() {
+        this.name = "MetaMask";
+        this.icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+        this.supportedChainTypes = [exports.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 !== exports.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 !== exports.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 !== exports.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/core/events.ts
+// src/adapters/deep-link/providers/okx.ts
+var okx_exports = {};
+__export(okx_exports, {
+  OKXDeepLinkProvider: () => exports.OKXDeepLinkProvider
+});
+exports.OKXDeepLinkProvider = void 0;
+var init_okx = __esm({
+  "src/adapters/deep-link/providers/okx.ts"() {
+    init_types();
+    exports.OKXDeepLinkProvider = class {
+      constructor() {
+        this.name = "OKX";
+        this.icon = "https://www.okx.com/favicon.ico";
+        this.supportedChainTypes = [exports.ChainType.EVM, exports.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,23 +633,12 @@ var TypedEventEmitter = class {
     return this;
   }
 };
-var ChainType = chainUtils.ChainType;
-var WalletType = /* @__PURE__ */ ((WalletType3) => {
-  WalletType3["METAMASK"] = "metamask";
-  WalletType3["WALLETCONNECT"] = "walletconnect";
-  WalletType3["COINBASE_WALLET"] = "coinbase-wallet";
-  WalletType3["TRONLINK"] = "tronlink";
-  WalletType3["WALLETCONNECT_TRON"] = "walletconnect-tron";
-  WalletType3["PRIVATE_KEY"] = "private-key";
-  return WalletType3;
-})(WalletType || {});
-var WalletState = /* @__PURE__ */ ((WalletState2) => {
-  WalletState2["DISCONNECTED"] = "disconnected";
-  WalletState2["CONNECTING"] = "connecting";
-  WalletState2["CONNECTED"] = "connected";
-  WalletState2["ERROR"] = "error";
-  return WalletState2;
-})(WalletState || {});
+
+// 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 {
@@ -158,6 +740,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
@@ -227,6 +816,7 @@ var WalletAdapter = class extends EventEmitter__default.default {
 };
 
 // src/adapters/base/browser-wallet-adapter.ts
+init_types();
 var BrowserWalletAdapter = class extends WalletAdapter {
   /**
    * 检查钱包是否可用
@@ -260,6 +850,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}`;
@@ -329,7 +922,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
@@ -495,7 +1093,7 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
   constructor() {
     super(...arguments);
     this.type = "metamask" /* METAMASK */;
-    this.chainType = ChainType.EVM;
+    this.chainType = exports.ChainType.EVM;
     this.name = "MetaMask";
     this.icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
     this.walletClient = null;
@@ -522,7 +1120,7 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
           universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
           nativeAddress: address,
           chainId: this.currentAccount.chainId,
-          chainType: ChainType.EVM,
+          chainType: exports.ChainType.EVM,
           isActive: true
         };
         this.setAccount(account);
@@ -558,6 +1156,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();
@@ -571,10 +1170,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],
@@ -593,7 +1192,7 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
         universalAddress: createUniversalAddress(finalChainId, address),
         nativeAddress: address,
         chainId: finalChainId,
-        chainType: ChainType.EVM,
+        chainType: exports.ChainType.EVM,
         isActive: true
       };
       this.setState("connected" /* CONNECTED */);
@@ -736,6 +1335,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: exports.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;
+    }
+  }
   /**
    * 读取合约
    */
@@ -960,11 +1609,52 @@ 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);
     this.type = "tronlink" /* TRONLINK */;
-    this.chainType = ChainType.TRON;
+    this.chainType = exports.ChainType.TRON;
     this.name = "TronWeb";
     this.icon = "https://www.tronlink.org/static/logoIcon.svg";
     /**
@@ -986,7 +1676,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
           universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
           nativeAddress: address,
           chainId: this.currentAccount.chainId,
-          chainType: ChainType.TRON,
+          chainType: exports.ChainType.TRON,
           isActive: true
         };
         this.setAccount(account);
@@ -1007,6 +1697,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;
@@ -1061,12 +1752,12 @@ 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,
         chainId: tronChainId,
-        chainType: ChainType.TRON,
+        chainType: exports.ChainType.TRON,
         isActive: true
       };
       this.setState("connected" /* CONNECTED */);
@@ -1136,10 +1827,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");
@@ -1154,19 +1847,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"}`);
@@ -1177,6 +1868,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:", {
@@ -1202,29 +1894,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");
@@ -1264,6 +2098,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 = {
@@ -1391,11 +2226,12 @@ 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);
     this.type = "private-key" /* PRIVATE_KEY */;
-    this.chainType = ChainType.EVM;
+    this.chainType = exports.ChainType.EVM;
     this.name = "Private Key (EVM)";
     this.privateKey = null;
     this.walletClient = null;
@@ -1404,28 +2240,29 @@ 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,
-        chainType: ChainType.EVM,
+        chainId: targetChainId,
+        chainType: exports.ChainType.EVM,
         isActive: true
       };
       this.setState("connected" /* CONNECTED */);
@@ -1636,61 +2473,1622 @@ 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();
-  }
-  /**
-   * Check if adapter is registered
-   */
-  has(type) {
-    return this.adapters.has(type);
-  }
-  /**
+init_types();
+var _WalletConnectAdapter = class _WalletConnectAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect" /* WALLETCONNECT */;
+    this.chainType = exports.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: exports.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: exports.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: exports.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;
+function loadWalletConnectTronModule() {
+  const here = typeof __filename !== "undefined" ? __filename : url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+  const req = module$1.createRequire(here);
+  const tronBundle = here.endsWith(".mjs") ? "tron.mjs" : "tron.js";
+  return req(path.join(path.dirname(here), tronBundle));
+}
+
+// src/adapters/deep-link/adapter.ts
+init_types();
+var DeepLinkProviderType = /* @__PURE__ */ ((DeepLinkProviderType2) => {
+  DeepLinkProviderType2["TOKENPOCKET"] = "tokenpocket";
+  DeepLinkProviderType2["TRONLINK"] = "tronlink";
+  DeepLinkProviderType2["IMTOKEN"] = "imtoken";
+  DeepLinkProviderType2["METAMASK"] = "metamask";
+  DeepLinkProviderType2["OKX"] = "okx";
+  return DeepLinkProviderType2;
+})(DeepLinkProviderType || {});
+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(exports.ChainType.EVM)) {
+      this.chainType = exports.ChainType.EVM;
+      this.type = "deep-link-evm" /* DEEP_LINK_EVM */;
+    } else if (this.provider.supportedChainTypes.includes(exports.ChainType.TRON)) {
+      this.chainType = exports.ChainType.TRON;
+      this.type = "deep-link-tron" /* DEEP_LINK_TRON */;
+    } else {
+      this.chainType = exports.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 = exports.ChainType.TRON;
+    } else {
+      chainType = exports.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 } = loadWalletConnectTronModule();
+        return new WalletConnectTronAdapter(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) {
+    return this.adapters.has(type);
+  }
+  /**
    * Get all registered adapter types
    */
-  getRegisteredTypes() {
-    return Array.from(this.adapters.keys());
+  getRegisteredTypes() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * 根据链类型获取适配器类型列表
+   */
+  getAdapterTypesByChainType(chainType) {
+    const types = [];
+    for (const type of this.adapters.keys()) {
+      const adapter = this.getAdapter(type);
+      if (adapter && adapter.chainType === chainType) {
+        types.push(type);
+      }
+    }
+    return types;
+  }
+};
+
+// src/core/wallet-manager.ts
+init_types();
+var QRCodeSignStatus = /* @__PURE__ */ ((QRCodeSignStatus2) => {
+  QRCodeSignStatus2["WAITING"] = "waiting";
+  QRCodeSignStatus2["PENDING"] = "pending";
+  QRCodeSignStatus2["SUCCESS"] = "success";
+  QRCodeSignStatus2["FAILED"] = "failed";
+  QRCodeSignStatus2["TIMEOUT"] = "timeout";
+  QRCodeSignStatus2["CANCELLED"] = "cancelled";
+  return QRCodeSignStatus2;
+})(QRCodeSignStatus || {});
+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 轮询函数
    */
-  getAdapterTypesByChainType(chainType) {
-    const types = [];
-    for (const type of this.adapters.keys()) {
-      const adapter = this.getAdapter(type);
-      if (adapter && adapter.chainType === chainType) {
-        types.push(type);
+  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;
     }
-    return types;
+  }
+  /**
+   * 停止轮询
+   */
+  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 */;
   }
 };
 
@@ -1709,9 +4107,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
    */
@@ -1778,7 +4182,7 @@ var WalletManager = class extends TypedEventEmitter {
     this.connectedWallets.delete(chainType);
     this.primaryWallet = null;
     if (this.config.enableStorage) {
-      this.saveToStorage();
+      this.clearStorage();
     }
     this.emit("disconnected");
   }
@@ -1867,6 +4271,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)
    */
@@ -1931,6 +4364,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
@@ -2125,7 +4593,7 @@ var WalletManager = class extends TypedEventEmitter {
         return null;
       }
       console.debug("[WalletManager] Wallet is available, attempting restoration");
-      if (adapter.chainType === ChainType.EVM && data.primaryWalletType === "metamask" /* METAMASK */) {
+      if (adapter.chainType === exports.ChainType.EVM && data.primaryWalletType === "metamask" /* METAMASK */) {
         try {
           const provider = typeof window !== "undefined" ? window.ethereum : null;
           if (provider) {
@@ -2162,7 +4630,7 @@ var WalletManager = class extends TypedEventEmitter {
           console.debug("Silent connection failed, trying normal connection:", silentError);
         }
       }
-      if (adapter.chainType === ChainType.TRON && data.primaryWalletType === "tronlink" /* TRONLINK */) {
+      if (adapter.chainType === exports.ChainType.TRON && data.primaryWalletType === "tronlink" /* TRONLINK */) {
         try {
           const tronWeb = adapter.getTronWeb?.();
           if (tronWeb && tronWeb.defaultAddress?.base58) {
@@ -2177,6 +4645,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);
@@ -2223,7 +4714,466 @@ var WalletManager = class extends TypedEventEmitter {
   }
 };
 
+// src/index.ts
+init_types();
+init_tokenpocket();
+init_tronlink();
+init_imtoken();
+init_metamask();
+init_okx();
+
+// src/adapters/tron/deep-link.ts
+init_types();
+var DeepLinkWalletType = /* @__PURE__ */ ((DeepLinkWalletType2) => {
+  DeepLinkWalletType2["TOKENPOCKET"] = "tokenpocket";
+  DeepLinkWalletType2["TRONLINK"] = "tronlink";
+  return DeepLinkWalletType2;
+})(DeepLinkWalletType || {});
+var _TronDeepLinkAdapter = class _TronDeepLinkAdapter extends WalletAdapter {
+  constructor(walletType = "tokenpocket" /* TOKENPOCKET */, options) {
+    super();
+    this.type = "tronlink" /* TRONLINK */;
+    // Reuse TRONLINK type for now
+    this.chainType = exports.ChainType.TRON;
+    this.pendingActions = /* @__PURE__ */ new Map();
+    this.walletType = walletType;
+    this.callbackUrl = options?.callbackUrl;
+    this.callbackSchema = options?.callbackSchema;
+    if (walletType === "tokenpocket" /* TOKENPOCKET */) {
+      this.name = "TokenPocket (Deep Link)";
+      this.icon = "https://tokenpocket.pro/icon.png";
+    } else if (walletType === "tronlink" /* TRONLINK */) {
+      this.name = "TronLink (Deep Link)";
+      this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+    } else {
+      this.name = "TRON Deep Link";
+      this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+    }
+    if (walletType === "tokenpocket" /* TOKENPOCKET */ && typeof window !== "undefined") {
+      this.setupCallbackHandler();
+    }
+  }
+  /**
+   * Setup callback handler for TokenPocket deep link results
+   * 
+   * According to TokenPocket docs:
+   * - callbackUrl: Wallet sends result to this URL (server-side callback)
+   * - callbackSchema: Wallet launches H5 app through this schema (client-side callback)
+   * 
+   * For H5 apps, we use callbackSchema to receive results in the same page
+   */
+  setupCallbackHandler() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") {
+        console.log("[TronDeepLink] Page became visible, user may have returned from wallet app");
+        this.checkCallbackFromUrl();
+      }
+    });
+    this.checkCallbackFromUrl();
+  }
+  /**
+   * Check if callback result is in URL parameters
+   * TokenPocket may append callback results to URL when using callbackSchema
+   */
+  checkCallbackFromUrl() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const urlParams = new URLSearchParams(window.location.search);
+    const actionId = urlParams.get("actionId");
+    const result = urlParams.get("result");
+    const error = urlParams.get("error");
+    if (actionId && this.pendingActions.has(actionId)) {
+      const { resolve, reject } = this.pendingActions.get(actionId);
+      if (error) {
+        reject(new Error(error));
+      } else if (result) {
+        try {
+          const parsedResult = JSON.parse(decodeURIComponent(result));
+          resolve(parsedResult);
+        } catch (e) {
+          resolve(result);
+        }
+      }
+      this.pendingActions.delete(actionId);
+      const newUrl = window.location.pathname;
+      window.history.replaceState({}, "", newUrl);
+    }
+  }
+  /**
+   * Check if deep link is available (mobile device or Telegram Mini App)
+   * 
+   * Note: In Telegram Mini App, we're more lenient - even if platform detection
+   * fails, deep links may still work, so the caller should handle Telegram Mini App
+   * separately if needed.
+   */
+  async isAvailable() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+    if (isTelegramMiniApp) {
+      const platform = window.Telegram.WebApp.platform || "unknown";
+      const version = window.Telegram.WebApp.version || "unknown";
+      console.log(`[TronDeepLink] Telegram Mini App detected, platform: ${platform}, version: ${version}`);
+      if (platform === "unknown") {
+        const userAgent = navigator.userAgent || "";
+        if (/iPhone|iPad|iPod/i.test(userAgent)) {
+          console.log(`[TronDeepLink] Detected iOS from user agent`);
+        } else if (/Android/i.test(userAgent)) {
+          console.log(`[TronDeepLink] Detected Android from user agent`);
+        }
+      }
+      return true;
+    }
+    const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+      navigator.userAgent
+    );
+    return isMobile;
+  }
+  /**
+   * Connect wallet via deep link
+   * 
+   * IMPORTANT: Deep links for TRON wallets are primarily for SIGNING, not connection.
+   * TokenPocket and TronLink deep links support:
+   * - Signing transactions: tron:signTransaction-version=1.0&protocol=TokenPocket&network=tron&chain_id=195&data={...}
+   * - Signing messages: tron:signMessage-version=1.0&protocol=TokenPocket&network=tron&chain_id=195&data={...}
+   * 
+   * For CONNECTION, you should use:
+   * - WalletConnect (recommended for mobile)
+   * - Browser extension (TronWeb/TronLink)
+   * 
+   * Note: You can sign directly using signMessage() or signTransaction() without calling connect() first.
+   * The wallet app will open and use the user's account automatically.
+   * 
+   * This method attempts to open the wallet app, but cannot establish a connection
+   * or retrieve the wallet address directly. The user must complete connection
+   * through WalletConnect or browser extension after opening the app.
+   */
+  async connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("Deep link requires a browser environment");
+    }
+    const targetChainId = Array.isArray(chainId) ? chainId[0] || _TronDeepLinkAdapter.TRON_MAINNET_CHAIN_ID : chainId || _TronDeepLinkAdapter.TRON_MAINNET_CHAIN_ID;
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const isAvailable = await this.isAvailable();
+      if (!isAvailable) {
+        const isTelegram = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegram) {
+          const platform = window.Telegram?.WebApp?.platform || "unknown";
+          throw new Error(
+            `Deep link is not available in Telegram Mini App on ${platform} platform. Please use WalletConnect or browser extension, or test on a mobile device.`
+          );
+        } else {
+          throw new Error("Deep link is only available on mobile devices or Telegram Mini App. Please use WalletConnect or browser extension.");
+        }
+      }
+      let deepLinkUrl = "";
+      if (this.walletType === "tokenpocket" /* TOKENPOCKET */) {
+        const actionId = `web-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const param = {
+          action: "login",
+          // Login action to open wallet
+          actionId,
+          blockchains: [{
+            chainId: String(targetChainId),
+            network: "tron"
+          }],
+          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));
+        deepLinkUrl = `tpoutside://pull.activity?param=${encodedParam}`;
+      } else if (this.walletType === "tronlink" /* TRONLINK */) {
+        deepLinkUrl = `tronlink://open?action=connect&network=tron`;
+      }
+      if (!deepLinkUrl) {
+        throw new Error(`Unsupported wallet type: ${this.walletType}`);
+      }
+      console.log(`[TronDeepLink] ===== Connect via Deep Link =====`);
+      console.log(`[TronDeepLink] Wallet Type:`, this.walletType);
+      console.log(`[TronDeepLink] Chain ID:`, targetChainId);
+      console.log(`[TronDeepLink] Deep Link URL:`, deepLinkUrl);
+      console.log(`[TronDeepLink] Note: Deep links are for signing, not connection. After opening the app, please use WalletConnect to establish connection.`);
+      console.log(`[TronDeepLink] ==================================`);
+      window.location.href = deepLinkUrl;
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      throw new ConnectionRejectedError(
+        `\u5DF2\u6253\u5F00 ${this.walletType === "tokenpocket" /* TOKENPOCKET */ ? "TokenPocket" : "TronLink"} \u5E94\u7528\u3002
+
+\u6CE8\u610F\uFF1A\u6DF1\u5EA6\u94FE\u63A5\u4E3B\u8981\u7528\u4E8E\u7B7E\u540D\u4EA4\u6613\uFF0C\u4E0D\u80FD\u76F4\u63A5\u5EFA\u7ACB\u8FDE\u63A5\u3002
+
+\u8BF7\u4F7F\u7528\u4EE5\u4E0B\u65B9\u5F0F\u5B8C\u6210\u8FDE\u63A5\uFF1A
+1. \u5728\u94B1\u5305\u5E94\u7528\u4E2D\u4F7F\u7528 WalletConnect \u626B\u63CF\u4E8C\u7EF4\u7801
+2. \u6216\u4F7F\u7528\u6D4F\u89C8\u5668\u6269\u5C55\uFF08\u5982 TronLink\uFF09\u8FDE\u63A5
+
+Deep link opened ${this.walletType} app. Please use WalletConnect or browser extension to complete the connection.`
+      );
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      if (error instanceof ConnectionRejectedError) {
+        throw error;
+      }
+      throw new Error(`Failed to open ${this.walletType} via deep link: ${error.message}`);
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+  }
+  /**
+   * Sign message via deep link
+   * 
+   * TokenPocket deep link format for signing:
+   * tron:signMessage-version=1.0&protocol=TokenPocket&network=tron&chain_id=195&data={message}
+   * 
+   * Reference: https://help.tokenpocket.pro/developer-cn/scan-protocol/tron
+   * 
+   * Note: Deep links can sign directly without establishing a connection first.
+   * The wallet app will open and use the user's account to sign the message.
+   * The signature result will be returned via callback URL or app-to-app communication.
+   */
+  async signMessage(message) {
+    if (typeof window === "undefined") {
+      throw new Error("Deep link requires a browser environment");
+    }
+    const isAvailable = await this.isAvailable();
+    if (!isAvailable) {
+      const isTelegram = !!(window.Telegram && window.Telegram.WebApp);
+      if (isTelegram) {
+        const platform = window.Telegram?.WebApp?.platform || "unknown";
+        throw new Error(
+          `Deep link signing is not available in Telegram Mini App on ${platform} platform. Please use WalletConnect or test on a mobile device.`
+        );
+      } else {
+        throw new Error("Deep link signing is only available on mobile devices or Telegram Mini App.");
+      }
+    }
+    let deepLinkUrl = "";
+    if (this.walletType === "tokenpocket" /* TOKENPOCKET */) {
+      const actionId = `web-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      const param = {
+        action: "sign",
+        actionId,
+        message,
+        hash: false,
+        signType: "ethPersonalSign",
+        // For TRON, we use ethPersonalSign as it's similar
+        memo: "TRON message signature",
+        blockchains: [{
+          chainId: "195",
+          // TRON Mainnet chain ID as string
+          network: "tron"
+        }],
+        dappName: "Enclave Wallet SDK",
+        dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+        protocol: "TokenPocket",
+        version: "1.1.8",
+        expired: 0
+        // No expiration
+        // callbackUrl: optional, if you want to receive callback
+        // callbackSchema: optional, custom schema for callback
+      };
+      const encodedParam = encodeURIComponent(JSON.stringify(param));
+      deepLinkUrl = `tpoutside://pull.activity?param=${encodedParam}`;
+      console.log(`[TronDeepLink] Using TokenPocket tpoutside:// format for signMessage`);
+      console.log(`[TronDeepLink] Param object:`, param);
+    } else if (this.walletType === "tronlink" /* TRONLINK */) {
+      const encodedMessage = encodeURIComponent(message);
+      deepLinkUrl = `tronlink://signMessage?message=${encodedMessage}`;
+    }
+    if (!deepLinkUrl) {
+      throw new MethodNotSupportedError("signMessage", this.type);
+    }
+    console.log(`[TronDeepLink] ===== Sign Message via Deep Link =====`);
+    console.log(`[TronDeepLink] Wallet Type:`, this.walletType);
+    console.log(`[TronDeepLink] Message:`, message);
+    console.log(`[TronDeepLink] Deep Link URL:`, deepLinkUrl);
+    console.log(`[TronDeepLink] Full URL length:`, deepLinkUrl.length);
+    console.log(`[TronDeepLink] ========================================`);
+    window.location.href = deepLinkUrl;
+    throw new Error(
+      `Deep link opened ${this.walletType} for signing. The signature will be handled by the wallet app. This adapter cannot retrieve the signature directly from deep links. Consider using WalletConnect or browser extension for programmatic signing.`
+    );
+  }
+  /**
+   * Sign transaction via deep link
+   * 
+   * TokenPocket deep link format:
+   * tron:signTransaction-version=1.0&protocol=TokenPocket&network=tron&chain_id=195&data={transaction}
+   * 
+   * Reference: https://help.tokenpocket.pro/developer-cn/scan-protocol/tron
+   * 
+   * Note: Deep links can sign directly without establishing a connection first.
+   * The wallet app will open and use the user's account to sign the transaction.
+   * The transaction data should be a JSON string containing the TRON transaction object.
+   * The signature result will be returned via callback URL or app-to-app communication.
+   */
+  async signTransaction(transaction) {
+    if (typeof window === "undefined") {
+      throw new Error("Deep link requires a browser environment");
+    }
+    const isAvailable = await this.isAvailable();
+    if (!isAvailable) {
+      const isTelegram = !!(window.Telegram && window.Telegram.WebApp);
+      if (isTelegram) {
+        const platform = window.Telegram?.WebApp?.platform || "unknown";
+        throw new Error(
+          `Deep link signing is not available in Telegram Mini App on ${platform} platform. Please use WalletConnect or test on a mobile device.`
+        );
+      } else {
+        throw new Error("Deep link signing is only available on mobile devices or Telegram Mini App.");
+      }
+    }
+    let deepLinkUrl = "";
+    let actionId = "";
+    let param = null;
+    if (this.walletType === "tokenpocket" /* TOKENPOCKET */) {
+      actionId = `web-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      let transactionData;
+      if (typeof transaction === "string") {
+        transactionData = transaction;
+      } else if (transaction.raw_data_hex) {
+        transactionData = JSON.stringify(transaction);
+      } else {
+        transactionData = JSON.stringify(transaction);
+      }
+      param = {
+        action: "pushTransaction",
+        actionId,
+        txData: transactionData,
+        // Transaction data as JSON string
+        blockchains: [{
+          chainId: "195",
+          // TRON Mainnet chain ID as string
+          network: "tron"
+        }],
+        dappName: "Enclave Wallet SDK",
+        dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+        protocol: "TokenPocket",
+        version: "1.1.8",
+        expired: 0
+        // No expiration
+      };
+      if (this.callbackSchema) {
+        param.callbackSchema = this.callbackSchema;
+      } else if (this.callbackUrl) {
+        param.callbackUrl = this.callbackUrl;
+      } else {
+        if (typeof window !== "undefined" && window.location) {
+          param.callbackSchema = `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+      }
+      const encodedParam = encodeURIComponent(JSON.stringify(param));
+      deepLinkUrl = `tpoutside://pull.activity?param=${encodedParam}`;
+      console.log(`[TronDeepLink] Using TokenPocket tpoutside:// format for signTransaction`);
+      console.log(`[TronDeepLink] Param object (without txData):`, { ...param, txData: "[TRANSACTION DATA]" });
+    } else if (this.walletType === "tronlink" /* TRONLINK */) {
+      const transactionData = typeof transaction === "string" ? transaction : JSON.stringify(transaction);
+      const encodedData = encodeURIComponent(transactionData);
+      deepLinkUrl = `tronlink://signTransaction?transaction=${encodedData}`;
+    }
+    if (!deepLinkUrl) {
+      throw new MethodNotSupportedError("signTransaction", this.type);
+    }
+    console.log(`[TronDeepLink] ===== Sign Transaction via Deep Link =====`);
+    console.log(`[TronDeepLink] Wallet Type:`, this.walletType);
+    console.log(`[TronDeepLink] Transaction:`, transaction);
+    console.log(`[TronDeepLink] Transaction keys:`, transaction ? Object.keys(transaction) : "N/A");
+    if (transaction && typeof transaction === "object") {
+      console.log(`[TronDeepLink] Transaction has raw_data:`, !!transaction.raw_data);
+      console.log(`[TronDeepLink] Transaction has raw_data_hex:`, !!transaction.raw_data_hex);
+      console.log(`[TronDeepLink] Transaction has txID:`, !!transaction.txID);
+    }
+    if (actionId) {
+      console.log(`[TronDeepLink] Action ID:`, actionId);
+    }
+    if (param) {
+      console.log(`[TronDeepLink] Callback Schema:`, param.callbackSchema || param.callbackUrl || "None");
+    }
+    console.log(`[TronDeepLink] Deep Link URL:`, deepLinkUrl);
+    console.log(`[TronDeepLink] Full URL length:`, deepLinkUrl.length);
+    if (deepLinkUrl.length > 200) {
+      console.log(`[TronDeepLink] URL (first 200 chars):`, deepLinkUrl.substring(0, 200) + "...");
+      console.log(`[TronDeepLink] URL (last 100 chars):`, "..." + deepLinkUrl.substring(deepLinkUrl.length - 100));
+    }
+    console.log(`[TronDeepLink] ===========================================`);
+    if (this.walletType === "tokenpocket" /* TOKENPOCKET */ && param && param.callbackSchema) {
+      return new Promise((resolve, reject) => {
+        this.pendingActions.set(actionId, { resolve, reject });
+        window.location.href = deepLinkUrl;
+        setTimeout(() => {
+          if (this.pendingActions.has(actionId)) {
+            this.pendingActions.delete(actionId);
+            reject(new Error("Transaction signature timeout: No response from wallet app"));
+          }
+        }, 3e4);
+      });
+    }
+    window.location.href = deepLinkUrl;
+    throw new SignatureRejectedError(
+      `\u5DF2\u6253\u5F00 ${this.walletType === "tokenpocket" /* TOKENPOCKET */ ? "TokenPocket" : "TronLink"} \u8FDB\u884C\u4EA4\u6613\u7B7E\u540D\u3002
+
+\u6CE8\u610F\uFF1A\u6DF1\u5EA6\u94FE\u63A5\u65E0\u6CD5\u76F4\u63A5\u8FD4\u56DE\u7B7E\u540D\u7ED3\u679C\u3002
+
+\u7B7E\u540D\u7ED3\u679C\u5C06\u901A\u8FC7\u4EE5\u4E0B\u65B9\u5F0F\u8FD4\u56DE\uFF1A
+1. \u94B1\u5305\u5E94\u7528\u7684\u56DE\u8C03 URL
+2. \u5E94\u7528\u95F4\u901A\u4FE1\uFF08App-to-App\uFF09
+
+\u5982\u9700\u7A0B\u5E8F\u5316\u83B7\u53D6\u7B7E\u540D\uFF0C\u8BF7\u4F7F\u7528 WalletConnect \u6216\u6D4F\u89C8\u5668\u6269\u5C55\u3002
+
+Deep link opened ${this.walletType} for transaction signing. The signature will be handled by the wallet app via callback. For programmatic signing, use WalletConnect or browser extension.`
+    );
+  }
+  /**
+   * Read contract (not supported via deep link)
+   */
+  async readContract(_params) {
+    throw new MethodNotSupportedError("readContract", this.type);
+  }
+  /**
+   * Write contract (not supported via deep link)
+   */
+  async writeContract(_params) {
+    throw new MethodNotSupportedError("writeContract", this.type);
+  }
+  /**
+   * Estimate gas (not supported)
+   */
+  async estimateGas(_params) {
+    throw new MethodNotSupportedError("estimateGas", this.type);
+  }
+  /**
+   * Wait for transaction (not supported)
+   */
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new MethodNotSupportedError("waitForTransaction", this.type);
+  }
+  /**
+   * Get provider (not applicable for deep links)
+   */
+  getProvider() {
+    return null;
+  }
+};
+// TRON Mainnet chain ID
+_TronDeepLinkAdapter.TRON_MAINNET_CHAIN_ID = 195;
+var TronDeepLinkAdapter = _TronDeepLinkAdapter;
+
 // src/auth/message-generator.ts
+init_types();
 var AuthMessageGenerator = class {
   constructor(domain) {
     this.domain = domain;
@@ -2233,7 +5183,7 @@ var AuthMessageGenerator = class {
    */
   generateAuthMessage(chainType, nonce, chainId, timestamp = Date.now(), statement) {
     switch (chainType) {
-      case ChainType.EVM:
+      case exports.ChainType.EVM:
         return this.generateEIP191Message({
           domain: this.domain,
           nonce,
@@ -2241,7 +5191,7 @@ var AuthMessageGenerator = class {
           timestamp,
           statement
         });
-      case ChainType.TRON:
+      case exports.ChainType.TRON:
         return this.generateTIP191Message({
           domain: this.domain,
           nonce,
@@ -2298,15 +5248,18 @@ var AuthMessageGenerator = class {
     return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
   }
 };
+
+// src/auth/signature-verifier.ts
+init_types();
 var SignatureVerifier = class {
   /**
    * 验证签名
    */
   async verifySignature(message, signature, expectedAddress, chainType) {
     switch (chainType) {
-      case ChainType.EVM:
+      case exports.ChainType.EVM:
         return this.verifyEIP191Signature(message, signature, expectedAddress);
-      case ChainType.TRON:
+      case exports.ChainType.TRON:
         return this.verifyTIP191Signature(message, signature, expectedAddress);
       default:
         throw new Error(`Unsupported chain type: ${chainType}`);
@@ -2339,12 +5292,16 @@ var SignatureVerifier = class {
   }
 };
 
+// src/detection/detector.ts
+init_types();
+
 // src/detection/supported-wallets.ts
+init_types();
 var SUPPORTED_WALLETS = {
   ["metamask" /* METAMASK */]: {
     type: "metamask" /* METAMASK */,
     name: "MetaMask",
-    chainType: ChainType.EVM,
+    chainType: exports.ChainType.EVM,
     icon: "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg",
     downloadUrl: "https://metamask.io/download/",
     description: "The most popular Ethereum wallet"
@@ -2352,7 +5309,7 @@ var SUPPORTED_WALLETS = {
   ["walletconnect" /* WALLETCONNECT */]: {
     type: "walletconnect" /* WALLETCONNECT */,
     name: "WalletConnect",
-    chainType: ChainType.EVM,
+    chainType: exports.ChainType.EVM,
     icon: "https://avatars.githubusercontent.com/u/37784886",
     downloadUrl: "https://walletconnect.com/",
     description: "Connect to 170+ wallets"
@@ -2360,7 +5317,7 @@ var SUPPORTED_WALLETS = {
   ["coinbase-wallet" /* COINBASE_WALLET */]: {
     type: "coinbase-wallet" /* COINBASE_WALLET */,
     name: "Coinbase Wallet",
-    chainType: ChainType.EVM,
+    chainType: exports.ChainType.EVM,
     icon: "https://www.coinbase.com/img/favicon/favicon-96x96.png",
     downloadUrl: "https://www.coinbase.com/wallet",
     description: "Coinbase self-custody wallet"
@@ -2368,7 +5325,7 @@ var SUPPORTED_WALLETS = {
   ["tronlink" /* TRONLINK */]: {
     type: "tronlink" /* TRONLINK */,
     name: "TronWeb",
-    chainType: ChainType.TRON,
+    chainType: exports.ChainType.TRON,
     icon: "https://www.tronlink.org/static/logoIcon.svg",
     downloadUrl: "https://www.tronlink.org/",
     description: "TronWeb \u517C\u5BB9\u94B1\u5305\uFF08\u652F\u6301 TronLink\u3001TokenPocket \u7B49\uFF09"
@@ -2376,16 +5333,30 @@ var SUPPORTED_WALLETS = {
   ["walletconnect-tron" /* WALLETCONNECT_TRON */]: {
     type: "walletconnect-tron" /* WALLETCONNECT_TRON */,
     name: "WalletConnect (Tron)",
-    chainType: ChainType.TRON,
+    chainType: exports.ChainType.TRON,
     downloadUrl: "https://walletconnect.com/",
     description: "WalletConnect for Tron"
   },
   ["private-key" /* PRIVATE_KEY */]: {
     type: "private-key" /* PRIVATE_KEY */,
     name: "Private Key",
-    chainType: ChainType.EVM,
+    chainType: exports.ChainType.EVM,
     // 可以用于任何链
     description: "Import wallet using private key (for development)"
+  },
+  ["deep-link-evm" /* DEEP_LINK_EVM */]: {
+    type: "deep-link-evm" /* DEEP_LINK_EVM */,
+    name: "Deep Link (EVM)",
+    chainType: exports.ChainType.EVM,
+    icon: "https://tokenpocket.pro/icon.png",
+    description: "Deep link connection for EVM chains (TokenPocket, ImToken, etc.)"
+  },
+  ["deep-link-tron" /* DEEP_LINK_TRON */]: {
+    type: "deep-link-tron" /* DEEP_LINK_TRON */,
+    name: "Deep Link (TRON)",
+    chainType: exports.ChainType.TRON,
+    icon: "https://tokenpocket.pro/icon.png",
+    description: "Deep link connection for TRON chain (TokenPocket, TronLink, etc.)"
   }
 };
 function getWalletMetadata(type) {
@@ -2393,12 +5364,12 @@ function getWalletMetadata(type) {
 }
 function getEVMWallets() {
   return Object.values(SUPPORTED_WALLETS).filter(
-    (wallet) => wallet.chainType === ChainType.EVM
+    (wallet) => wallet.chainType === exports.ChainType.EVM
   );
 }
 function getTronWallets() {
   return Object.values(SUPPORTED_WALLETS).filter(
-    (wallet) => wallet.chainType === ChainType.TRON
+    (wallet) => wallet.chainType === exports.ChainType.TRON
   );
 }
 
@@ -2408,7 +5379,7 @@ var WalletDetector = class {
    * Detect all wallet availability
    */
   async detectAllWallets() {
-    const walletTypes = Object.values(WalletType).filter(
+    const walletTypes = Object.values(exports.WalletType).filter(
       (type) => type !== "private-key" /* PRIVATE_KEY */
       // Private key wallet does not need detection
     );
@@ -2425,7 +5396,7 @@ var WalletDetector = class {
     if (!metadata) {
       return {
         walletType,
-        chainType: ChainType.EVM,
+        chainType: exports.ChainType.EVM,
         // Default
         isAvailable: false,
         detected: false
@@ -2533,11 +5504,12 @@ function shortenTronAddress(address, chars = 4) {
 }
 
 // src/utils/validation.ts
+init_types();
 function validateAddress(address, chainType) {
   switch (chainType) {
-    case ChainType.EVM:
+    case exports.ChainType.EVM:
       return isValidEVMAddress(address);
-    case ChainType.TRON:
+    case exports.ChainType.TRON:
       return isValidTronAddress(address);
     default:
       return false;
@@ -2558,9 +5530,9 @@ function isValidSignature(signature) {
 }
 function isValidTransactionHash(txHash, chainType) {
   switch (chainType) {
-    case ChainType.EVM:
+    case exports.ChainType.EVM:
       return /^0x[0-9a-fA-F]{64}$/.test(txHash);
-    case ChainType.TRON:
+    case exports.ChainType.TRON:
       return /^[0-9a-fA-F]{64}$/.test(txHash);
     default:
       return false;
@@ -2607,26 +5579,30 @@ exports.AuthMessageGenerator = AuthMessageGenerator;
 exports.BrowserWalletAdapter = BrowserWalletAdapter;
 exports.CHAIN_INFO = CHAIN_INFO;
 exports.ChainNotSupportedError = ChainNotSupportedError;
-exports.ChainType = ChainType;
 exports.ConfigurationError = ConfigurationError;
 exports.ConnectionRejectedError = ConnectionRejectedError;
+exports.DeepLinkAdapter = DeepLinkAdapter;
+exports.DeepLinkProviderType = DeepLinkProviderType;
+exports.DeepLinkWalletType = DeepLinkWalletType;
 exports.EVMPrivateKeyAdapter = EVMPrivateKeyAdapter;
 exports.MetaMaskAdapter = MetaMaskAdapter;
 exports.MethodNotSupportedError = MethodNotSupportedError;
 exports.NetworkError = NetworkError;
+exports.QRCodeSignStatus = QRCodeSignStatus;
+exports.QRCodeSigner = QRCodeSigner;
 exports.SUPPORTED_WALLETS = SUPPORTED_WALLETS;
 exports.SignatureRejectedError = SignatureRejectedError;
 exports.SignatureVerifier = SignatureVerifier;
 exports.TransactionFailedError = TransactionFailedError;
+exports.TronDeepLinkAdapter = TronDeepLinkAdapter;
 exports.TronLinkAdapter = TronLinkAdapter;
 exports.WalletAdapter = WalletAdapter;
+exports.WalletConnectAdapter = WalletConnectAdapter;
 exports.WalletDetector = WalletDetector;
 exports.WalletManager = WalletManager;
 exports.WalletNotAvailableError = WalletNotAvailableError;
 exports.WalletNotConnectedError = WalletNotConnectedError;
 exports.WalletSDKError = WalletSDKError;
-exports.WalletState = WalletState;
-exports.WalletType = WalletType;
 exports.compareEVMAddresses = compareEVMAddresses;
 exports.compareTronAddresses = compareTronAddresses;
 exports.compareUniversalAddresses = compareUniversalAddresses;