@enclave-hq/wallet-sdk 1.2.3 → 1.2.4

package/dist/index.mjs

@@ -1,9 +1,597 @@
-import EventEmitter from 'eventemitter3';
 import { ChainType as ChainType$1 } from '@enclave-hq/chain-utils';
-import { isAddress, getAddress, createWalletClient, custom, createPublicClient, http, verifyMessage } from 'viem';
+import EventEmitter from 'eventemitter3';
+import { createWalletClient, custom, createPublicClient, http, isAddress, getAddress, verifyMessage } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
+import EthereumProvider from '@walletconnect/ethereum-provider';
+import { WalletConnectChainID, WalletConnectWallet } from '@tronweb3/walletconnect-tron';
+import QRCode from '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);
+var ChainType, WalletType, WalletState;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    ChainType = ChainType$1;
+    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;
+    })(WalletType || {});
+    WalletState = /* @__PURE__ */ ((WalletState2) => {
+      WalletState2["DISCONNECTED"] = "disconnected";
+      WalletState2["CONNECTING"] = "connecting";
+      WalletState2["CONNECTED"] = "connected";
+      WalletState2["ERROR"] = "error";
+      return WalletState2;
+    })(WalletState || {});
+  }
+});
+
+// src/adapters/deep-link/providers/tokenpocket.ts
+var tokenpocket_exports = {};
+__export(tokenpocket_exports, {
+  TokenPocketDeepLinkProvider: () => TokenPocketDeepLinkProvider
+});
+var TokenPocketDeepLinkProvider;
+var init_tokenpocket = __esm({
+  "src/adapters/deep-link/providers/tokenpocket.ts"() {
+    init_types();
+    TokenPocketDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "TokenPocket";
+        this.icon = "https://tokenpocket.pro/icon.png";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+        this.callbackUrl = options?.callbackUrl;
+        this.callbackSchema = options?.callbackSchema;
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      /**
+       * Generate unique actionId
+       */
+      generateActionId() {
+        return `web-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      }
+      /**
+       * Get callback configuration
+       */
+      getCallbackConfig() {
+        if (this.callbackSchema) {
+          return { callbackSchema: this.callbackSchema };
+        }
+        if (this.callbackUrl) {
+          return { callbackUrl: this.callbackUrl };
+        }
+        if (typeof window !== "undefined" && window.location) {
+          return {
+            callbackSchema: `${window.location.protocol}//${window.location.host}${window.location.pathname}`
+          };
+        }
+        return {};
+      }
+      /**
+       * Get blockchain configuration based on chain type
+       */
+      getBlockchainConfig(chainId, chainType) {
+        if (chainType === ChainType.TRON) {
+          return {
+            chainId: String(chainId),
+            network: "tron"
+          };
+        } else if (chainType === ChainType.EVM) {
+          return {
+            chainId: String(chainId),
+            network: "ethereum"
+          };
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+      }
+      buildSignMessageLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        const param = {
+          action: "sign",
+          actionId,
+          message: params.message,
+          hash: false,
+          signType: params.chainType === ChainType.TRON ? "ethPersonalSign" : "ethPersonalSign",
+          memo: `${params.chainType} message signature`,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.1.8",
+          expired: 0,
+          ...callback
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildSignTransactionLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        let transactionData;
+        if (typeof params.transaction === "string") {
+          transactionData = params.transaction;
+        } else {
+          transactionData = JSON.stringify(params.transaction);
+        }
+        const param = {
+          action: "pushTransaction",
+          actionId,
+          txData: transactionData,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.1.8",
+          expired: 0,
+          ...callback
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildConnectLink(params) {
+        const actionId = this.generateActionId();
+        const blockchain = this.getBlockchainConfig(params.chainId, params.chainType);
+        const param = {
+          action: "login",
+          actionId,
+          blockchains: [blockchain],
+          dappName: "Enclave Wallet SDK",
+          dappIcon: "https://walletconnect.com/walletconnect-logo.svg",
+          protocol: "TokenPocket",
+          version: "1.0",
+          expired: 1602
+          // 30 minutes
+        };
+        const encodedParam = encodeURIComponent(JSON.stringify(param));
+        const url = `tpoutside://pull.activity?param=${encodedParam}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/tronlink.ts
+var tronlink_exports = {};
+__export(tronlink_exports, {
+  TronLinkDeepLinkProvider: () => TronLinkDeepLinkProvider
+});
+var TronLinkDeepLinkProvider;
+var init_tronlink = __esm({
+  "src/adapters/deep-link/providers/tronlink.ts"() {
+    init_types();
+    TronLinkDeepLinkProvider = class {
+      constructor() {
+        this.name = "TronLink";
+        this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+        this.supportedChainTypes = [ChainType.TRON];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const encodedMessage = encodeURIComponent(params.message);
+        const url = `tronlink://signMessage?message=${encodedMessage}`;
+        const actionId = `tronlink-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const encodedData = encodeURIComponent(transactionData);
+        const url = `tronlink://signTransaction?transaction=${encodedData}`;
+        const actionId = `tronlink-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        if (params.chainType !== ChainType.TRON) {
+          throw new Error("TronLink only supports TRON chain");
+        }
+        const url = `tronlink://open?action=connect&network=tron`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(_urlParams) {
+        return {
+          actionId: null,
+          result: null,
+          error: null
+        };
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/imtoken.ts
+var imtoken_exports = {};
+__export(imtoken_exports, {
+  ImTokenDeepLinkProvider: () => ImTokenDeepLinkProvider
+});
+var ImTokenDeepLinkProvider;
+var init_imtoken = __esm({
+  "src/adapters/deep-link/providers/imtoken.ts"() {
+    init_types();
+    ImTokenDeepLinkProvider = class {
+      constructor(options) {
+        this.name = "ImToken";
+        this.icon = "https://token.im/static/img/logo.png";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+        this.callbackUrl = options?.callbackUrl;
+        this.callbackSchema = options?.callbackSchema;
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      /**
+       * Generate unique actionId
+       */
+      generateActionId() {
+        return `imtoken-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      }
+      /**
+       * Get callback configuration
+       */
+      getCallbackConfig() {
+        if (this.callbackSchema) {
+          return { callbackSchema: this.callbackSchema };
+        }
+        if (this.callbackUrl) {
+          return { callbackUrl: this.callbackUrl };
+        }
+        if (typeof window !== "undefined" && window.location) {
+          return {
+            callbackSchema: `${window.location.protocol}//${window.location.host}${window.location.pathname}`
+          };
+        }
+        return {};
+      }
+      buildSignMessageLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildSignTransactionLink(params) {
+        const actionId = this.generateActionId();
+        const callback = this.getCallbackConfig();
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url,
+          actionId,
+          ...callback
+        };
+      }
+      buildConnectLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `imtokenv2://navigate/DappView?url=${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// src/adapters/deep-link/providers/metamask.ts
+var metamask_exports = {};
+__export(metamask_exports, {
+  MetaMaskDeepLinkProvider: () => MetaMaskDeepLinkProvider
+});
+var MetaMaskDeepLinkProvider;
+var init_metamask = __esm({
+  "src/adapters/deep-link/providers/metamask.ts"() {
+    init_types();
+    MetaMaskDeepLinkProvider = class {
+      constructor() {
+        this.name = "MetaMask";
+        this.icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+        this.supportedChainTypes = [ChainType.EVM];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        const actionId = `metamask-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        const actionId = `metamask-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        if (params.chainType !== ChainType.EVM) {
+          throw new Error("MetaMask only supports EVM chains");
+        }
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `https://link.metamask.io/dapp/${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
 
-// src/core/events.ts
+// src/adapters/deep-link/providers/okx.ts
+var okx_exports = {};
+__export(okx_exports, {
+  OKXDeepLinkProvider: () => OKXDeepLinkProvider
+});
+var OKXDeepLinkProvider;
+var init_okx = __esm({
+  "src/adapters/deep-link/providers/okx.ts"() {
+    init_types();
+    OKXDeepLinkProvider = class {
+      constructor() {
+        this.name = "OKX";
+        this.icon = "https://www.okx.com/favicon.ico";
+        this.supportedChainTypes = [ChainType.EVM, ChainType.TRON];
+      }
+      async isAvailable() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        const isTelegramMiniApp = !!(window.Telegram && window.Telegram.WebApp);
+        if (isTelegramMiniApp) {
+          return true;
+        }
+        const isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+          navigator.userAgent
+        );
+        return isMobile;
+      }
+      buildSignMessageLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signMessage&message=${encodeURIComponent(params.message)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        const actionId = `okx-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildSignTransactionLink(params) {
+        const transactionData = typeof params.transaction === "string" ? params.transaction : JSON.stringify(params.transaction);
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=signTransaction&transaction=${encodeURIComponent(transactionData)}&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        const actionId = `okx-${Date.now()}`;
+        return {
+          url,
+          actionId
+        };
+      }
+      buildConnectLink(params) {
+        const dappUrl = `${window.location.origin}${window.location.pathname}?action=connect&chainId=${params.chainId}`;
+        const encodedDappUrl = encodeURIComponent(dappUrl);
+        const url = `okx://wallet/dapp/url?dappUrl=${encodedDappUrl}`;
+        return {
+          url
+        };
+      }
+      parseCallbackResult(urlParams) {
+        const actionId = urlParams.get("actionId");
+        const resultParam = urlParams.get("result");
+        const error = urlParams.get("error");
+        let result = null;
+        if (resultParam) {
+          try {
+            result = JSON.parse(decodeURIComponent(resultParam));
+          } catch (e) {
+            result = resultParam;
+          }
+        }
+        return {
+          actionId,
+          result,
+          error
+        };
+      }
+      getDefaultCallbackSchema() {
+        if (typeof window !== "undefined" && window.location) {
+          return `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
+        }
+        return "";
+      }
+    };
+  }
+});
 var TypedEventEmitter = class {
   constructor() {
     this.emitter = new EventEmitter();
@@ -32,23 +620,12 @@ var TypedEventEmitter = class {
     return this;
   }
 };
-var ChainType = ChainType$1;
-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 {
@@ -150,6 +727,13 @@ var WalletAdapter = class extends EventEmitter {
     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
@@ -219,6 +803,7 @@ var WalletAdapter = class extends EventEmitter {
 };
 
 // src/adapters/base/browser-wallet-adapter.ts
+init_types();
 var BrowserWalletAdapter = class extends WalletAdapter {
   /**
    * 检查钱包是否可用
@@ -252,6 +837,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}`;
@@ -550,6 +1138,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();
@@ -563,10 +1152,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 = createWalletClient({
         account: accounts[0],
@@ -952,6 +1541,7 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
 };
 
 // src/adapters/tron/tronlink.ts
+init_types();
 var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   constructor() {
     super(...arguments);
@@ -999,6 +1589,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;
@@ -1053,7 +1644,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       if (!address) {
         throw new Error("Failed to get Tron address. Please make sure your wallet is unlocked and try again.");
       }
-      const tronChainId = chainId || _TronLinkAdapter.TRON_MAINNET_CHAIN_ID;
+      const tronChainId = targetChainId || _TronLinkAdapter.TRON_MAINNET_CHAIN_ID;
       const account = {
         universalAddress: createUniversalAddress(tronChainId, address),
         nativeAddress: address,
@@ -1383,6 +1974,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
 // Tron 主网链 ID
 _TronLinkAdapter.TRON_MAINNET_CHAIN_ID = 195;
 var TronLinkAdapter = _TronLinkAdapter;
+init_types();
 var EVMPrivateKeyAdapter = class extends WalletAdapter {
   constructor() {
     super(...arguments);
@@ -1396,27 +1988,28 @@ var EVMPrivateKeyAdapter = class extends WalletAdapter {
   /**
    * 连接（导入私钥）
    */
-  async connect(chainId = 1) {
+  async connect(chainId) {
     if (!this.privateKey) {
       throw new Error("Private key not set. Call setPrivateKey() first.");
     }
     try {
       this.setState("connecting" /* CONNECTING */);
       const account = privateKeyToAccount(this.privateKey);
+      const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId || 1;
       this.walletClient = createWalletClient({
         account,
-        chain: this.getViemChain(chainId),
+        chain: this.getViemChain(targetChainId),
         transport: http()
       });
       this.publicClient = createPublicClient({
-        chain: this.getViemChain(chainId),
+        chain: this.getViemChain(targetChainId),
         transport: http()
       });
       const address = formatEVMAddress(account.address);
       const accountInfo = {
-        universalAddress: createUniversalAddress(chainId, address),
+        universalAddress: createUniversalAddress(targetChainId, address),
         nativeAddress: address,
-        chainId,
+        chainId: targetChainId,
         chainType: ChainType.EVM,
         isActive: true
       };
@@ -1628,66 +2221,2312 @@ 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());
+init_types();
+var _WalletConnectAdapter = class _WalletConnectAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect" /* WALLETCONNECT */;
+    this.chainType = ChainType.EVM;
+    this.name = "WalletConnect";
+    this.icon = "https://avatars.githubusercontent.com/u/37784886";
+    this.provider = null;
+    this.walletClient = null;
+    this.publicClient = null;
+    this.supportedChains = [];
+    /**
+     * Handle accounts changed
+     */
+    this.handleAccountsChanged = (accounts) => {
+      if (accounts.length === 0) {
+        this.setState("disconnected" /* DISCONNECTED */);
+        this.setAccount(null);
+        this.emitAccountChanged(null);
+      } else {
+        const address = formatEVMAddress(accounts[0]);
+        const account = {
+          universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
+          nativeAddress: address,
+          chainId: this.currentAccount.chainId,
+          chainType: ChainType.EVM,
+          isActive: true
+        };
+        this.setAccount(account);
+        this.emitAccountChanged(account);
+      }
+    };
+    /**
+     * Handle chain changed
+     */
+    this.handleChainChanged = (chainIdHex) => {
+      const chainId = parseInt(chainIdHex, 16);
+      if (this.currentAccount) {
+        const account = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(account);
+        this.emitChainChanged(chainId);
+        const viemChain = this.getViemChain(chainId);
+        const chainInfo = getChainInfo(chainId);
+        const primaryRpcUrl = chainInfo?.rpcUrls[0];
+        if (this.provider) {
+          this.walletClient = createWalletClient({
+            account: this.currentAccount.nativeAddress,
+            chain: viemChain,
+            transport: custom(this.provider)
+          });
+          this.publicClient = createPublicClient({
+            chain: viemChain,
+            transport: primaryRpcUrl ? http(primaryRpcUrl) : 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;
   }
   /**
-   * Register adapter
+   * Check if WalletConnect is available
+   * WalletConnect is always available (it's a web-based connection)
+   * Also works in Telegram Mini Apps
    */
-  register(type, factory) {
-    this.adapters.set(type, factory);
+  async isAvailable() {
+    return typeof window !== "undefined";
   }
   /**
-   * Get adapter
+   * 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
    */
-  getAdapter(type) {
-    const factory = this.adapters.get(type);
-    if (!factory) {
-      return null;
-    }
-    return factory();
+  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;
   }
   /**
-   * Check if adapter is registered
+   * Get Telegram WebApp instance if available
    */
-  has(type) {
-    return this.adapters.has(type);
+  getTelegramWebApp() {
+    if (typeof window === "undefined") return null;
+    return window.Telegram?.WebApp || null;
   }
   /**
-   * Get all registered adapter types
+   * 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
    */
-  getRegisteredTypes() {
-    return Array.from(this.adapters.keys());
+  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
    */
-  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 connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("WalletConnect requires a browser environment");
     }
-    return types;
-  }
-};
-
-// src/core/wallet-manager.ts
-var WalletManager = class extends TypedEventEmitter {
+    if (_WalletConnectAdapter.providerInstance && _WalletConnectAdapter.providerProjectId === this.projectId) {
+      const existingProvider = _WalletConnectAdapter.providerInstance;
+      if (existingProvider.accounts && existingProvider.accounts.length > 0) {
+        this.provider = existingProvider;
+        let targetChains;
+        if (Array.isArray(chainId)) {
+          targetChains = chainId.length > 0 ? chainId : [1];
+        } else if (chainId) {
+          targetChains = [chainId];
+        } else {
+          targetChains = [1];
+        }
+        const existingChains = this.supportedChains || [];
+        const mergedChains = [.../* @__PURE__ */ new Set([...existingChains, ...targetChains])];
+        this.supportedChains = mergedChains;
+        const currentChainId = existingProvider.chainId || targetChains[0];
+        const address = formatEVMAddress(existingProvider.accounts[0]);
+        const account = {
+          universalAddress: createUniversalAddress(currentChainId, address),
+          nativeAddress: address,
+          chainId: currentChainId,
+          chainType: ChainType.EVM,
+          isActive: true
+        };
+        this.setState("connected" /* CONNECTED */);
+        this.setAccount(account);
+        if (!this.walletClient) {
+          const viemChain = this.getViemChain(currentChainId);
+          this.walletClient = createWalletClient({
+            account: existingProvider.accounts[0],
+            chain: viemChain,
+            transport: custom(existingProvider)
+          });
+          const chainInfo = getChainInfo(currentChainId);
+          const primaryRpcUrl = chainInfo?.rpcUrls[0];
+          this.publicClient = createPublicClient({
+            chain: viemChain,
+            transport: primaryRpcUrl ? http(primaryRpcUrl) : 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.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 = createWalletClient({
+        account: accounts[0],
+        chain: viemChain,
+        transport: custom(this.provider)
+      });
+      const chainInfo = getChainInfo(currentChainId);
+      const primaryRpcUrl = chainInfo?.rpcUrls[0];
+      this.publicClient = createPublicClient({
+        chain: viemChain,
+        transport: primaryRpcUrl ? http(primaryRpcUrl) : custom(this.provider)
+      });
+      const address = formatEVMAddress(accounts[0]);
+      const account = {
+        universalAddress: createUniversalAddress(currentChainId, address),
+        nativeAddress: address,
+        chainId: currentChainId,
+        chainType: ChainType.EVM,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      const origin = typeof window !== "undefined" && window.location ? window.location.origin : "";
+      const errorCode = error?.code;
+      const errorMessage = error?.message || String(error);
+      const isOriginNotAllowed = errorCode === 3e3 || /origin not allowed/i.test(errorMessage) || /Unauthorized:\s*origin not allowed/i.test(errorMessage);
+      const session = this.provider?.session;
+      const providerState = this.provider ? {
+        accounts: this.provider.accounts,
+        chainId: this.provider.chainId,
+        session: session ? {
+          exists: true,
+          topic: session.topic,
+          namespaces: session.namespaces ? Object.keys(session.namespaces) : "none",
+          eip155Namespace: session.namespaces?.eip155 ? {
+            accounts: session.namespaces.eip155.accounts,
+            chains: session.namespaces.eip155.chains,
+            methods: session.namespaces.eip155.methods,
+            events: session.namespaces.eip155.events
+          } : "none"
+        } : "none",
+        providerKeys: Object.keys(this.provider)
+      } : "no provider";
+      console.error("[WalletConnect] Connection error:", {
+        error,
+        code: error.code,
+        message: error.message,
+        stack: error.stack,
+        providerState
+      });
+      if (this.provider) {
+        console.error("[WalletConnect] Full provider object:", this.provider);
+        console.error("[WalletConnect] Full session object:", session);
+      }
+      if (error.code === 4001 || error.message && (error.message.includes("User rejected") || error.message.includes("rejected by user") || error.message.includes("User cancelled"))) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      if (isOriginNotAllowed) {
+        throw new ConfigurationError(
+          `WalletConnect relayer rejected this origin (code 3000: Unauthorized: origin not allowed).
+
+Fix:
+1) Open WalletConnect Cloud \u2192 your project (${this.projectId})
+2) Add this site origin to the allowlist:
+   - ${origin || "(unknown origin)"}
+
+Common dev origins to allow:
+- http://localhost:5173
+- http://192.168.0.221:5173 (your LAN dev URL)
+- https://wallet-test.enclave-hq.com (your Cloudflare Tunnel/custom domain)
+
+Original error: ${errorMessage}`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    if (this.provider) {
+      try {
+        await this.provider.disconnect();
+      } catch (error) {
+        console.warn("[WalletConnect] Error during disconnect:", error);
+      }
+      if (_WalletConnectAdapter.providerInstance === this.provider) {
+        _WalletConnectAdapter.providerInstance = null;
+        _WalletConnectAdapter.providerProjectId = null;
+        _WalletConnectAdapter.providerChains = null;
+      }
+      this.provider = null;
+    }
+    this.removeEventListeners();
+    this.walletClient = null;
+    this.publicClient = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * Sign message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const signature = await this.provider.request({
+        method: "personal_sign",
+        params: [message, this.currentAccount.nativeAddress]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sign TypedData (EIP-712)
+   */
+  async signTypedData(typedData) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const signature = await this.provider.request({
+        method: "eth_signTypedData_v4",
+        params: [this.currentAccount.nativeAddress, JSON.stringify(typedData)]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sign transaction
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    try {
+      if (!this.provider) {
+        throw new Error("Provider not initialized");
+      }
+      const tx = {
+        from: this.currentAccount.nativeAddress,
+        to: transaction.to,
+        value: transaction.value ? `0x${BigInt(transaction.value).toString(16)}` : void 0,
+        data: transaction.data || "0x",
+        gas: transaction.gas ? `0x${BigInt(transaction.gas).toString(16)}` : void 0,
+        gasPrice: transaction.gasPrice && transaction.gasPrice !== "auto" ? `0x${BigInt(transaction.gasPrice).toString(16)}` : void 0,
+        maxFeePerGas: transaction.maxFeePerGas ? `0x${BigInt(transaction.maxFeePerGas).toString(16)}` : void 0,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? `0x${BigInt(transaction.maxPriorityFeePerGas).toString(16)}` : void 0,
+        nonce: transaction.nonce !== void 0 ? `0x${transaction.nonce.toString(16)}` : void 0,
+        chainId: transaction.chainId || this.currentAccount.chainId
+      };
+      const signature = await this.provider.request({
+        method: "eth_signTransaction",
+        params: [tx]
+      });
+      this.closeTelegramDeepLinkPopup();
+      return signature;
+    } catch (error) {
+      if (error.code === 4001 || error.message?.includes("rejected")) {
+        throw new SignatureRejectedError("Transaction signature was rejected by user");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get supported chains from current connection
+   * Returns the chains that were requested during connection
+   */
+  getSupportedChains() {
+    return [...this.supportedChains];
+  }
+  /**
+   * Switch chain
+   * 
+   * Note: WalletConnect v2 with mobile wallets may not support chain switching reliably.
+   * Some wallets may ignore the switch request or fail silently.
+   * It's recommended to include all needed chains in the initial connection.
+   * 
+   * Reference: https://specs.walletconnect.com/2.0/specs/clients/sign/namespaces
+   */
+  async switchChain(chainId) {
+    if (!this.provider) {
+      throw new Error("Provider not initialized");
+    }
+    const session = this.provider.session;
+    const supportedChains = session?.namespaces?.eip155?.chains || [];
+    const targetChainCAIP = `eip155:${chainId}`;
+    const isChainApproved = supportedChains.includes(targetChainCAIP);
+    if (!isChainApproved) {
+      console.warn(`[WalletConnect] Chain ${chainId} (${targetChainCAIP}) not in session approved chains:`, supportedChains);
+      console.warn("[WalletConnect] Chain switching may fail. Consider including all chains in initial connection.");
+    }
+    try {
+      console.log(`[WalletConnect] Attempting to switch to chain ${chainId} (${targetChainCAIP})`);
+      const result = await this.provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: `0x${chainId.toString(16)}` }]
+      });
+      if (result !== null && result !== void 0) {
+        console.warn("[WalletConnect] wallet_switchEthereumChain returned non-null result:", result);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      const currentChainId = this.provider.chainId;
+      if (currentChainId !== chainId) {
+        console.warn(`[WalletConnect] Chain switch may have failed. Expected ${chainId}, got ${currentChainId}`);
+        console.warn("[WalletConnect] Some mobile wallets may not support chain switching via WalletConnect.");
+        console.warn("[WalletConnect] User may need to manually switch chains in the wallet app.");
+      }
+      if (this.currentAccount) {
+        const updatedAccount = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(updatedAccount);
+        this.emitChainChanged(chainId);
+        const viemChain = this.getViemChain(chainId);
+        const chainInfo = getChainInfo(chainId);
+        const primaryRpcUrl = chainInfo?.rpcUrls[0];
+        this.walletClient = createWalletClient({
+          account: this.currentAccount.nativeAddress,
+          chain: viemChain,
+          transport: custom(this.provider)
+        });
+        this.publicClient = createPublicClient({
+          chain: viemChain,
+          transport: primaryRpcUrl ? http(primaryRpcUrl) : 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;
+init_types();
+var _WalletConnectTronAdapter = class _WalletConnectTronAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect-tron" /* WALLETCONNECT_TRON */;
+    this.chainType = ChainType.TRON;
+    this.name = "WalletConnect (Tron)";
+    this.icon = "https://avatars.githubusercontent.com/u/37784886";
+    this.wallet = null;
+    this.currentAddress = null;
+    if (!projectId) {
+      throw new ConfigurationError("WalletConnect projectId is required");
+    }
+    this.projectId = projectId;
+  }
+  /**
+   * Check if WalletConnect is available
+   */
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running in Telegram environment (Mini App or Web)
+   * Both Telegram Mini App (in client) and Telegram Web (web.telegram.org) 
+   * provide window.Telegram.WebApp API, so they are treated the same way.
+   */
+  isTelegramMiniApp() {
+    if (typeof window === "undefined") return false;
+    const tg = window.Telegram?.WebApp;
+    if (!tg) return false;
+    const platform = tg.platform || "unknown";
+    console.log("[WalletConnect Tron] Telegram environment detected:", {
+      platform,
+      version: tg.version,
+      isMiniApp: platform !== "web",
+      // Mini App if not web platform
+      isWeb: platform === "web"
+      // Telegram Web if web platform
+    });
+    return true;
+  }
+  /**
+   * Restore session from existing wallet (for storage restoration)
+   */
+  async restoreSession(chainId) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    try {
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        return null;
+      }
+      const status = await this.wallet.checkConnectStatus();
+      if (status && status.address) {
+        this.currentAddress = status.address;
+        const account = {
+          universalAddress: createUniversalAddress(targetChainId, status.address),
+          nativeAddress: status.address,
+          chainId: targetChainId,
+          chainType: ChainType.TRON,
+          isActive: true
+        };
+        this.setState("connected" /* CONNECTED */);
+        this.setAccount(account);
+        this.setupEventListeners();
+        return account;
+      }
+      return null;
+    } catch (error) {
+      console.debug("[WalletConnect Tron] Restore session failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Initialize WalletConnect wallet instance
+   * @param chainId - Optional chain ID to determine network (default: Mainnet)
+   */
+  initializeWallet(chainId) {
+    if (_WalletConnectTronAdapter.walletInstance && _WalletConnectTronAdapter.walletProjectId === this.projectId) {
+      return;
+    }
+    let appUrl = "";
+    if (typeof window !== "undefined") {
+      try {
+        if (window.location && window.location.origin) {
+          appUrl = window.location.origin;
+        } else if (window.location && window.location.href) {
+          const url = new URL(window.location.href);
+          appUrl = url.origin;
+        }
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Failed to get origin from window.location:", error);
+      }
+      if (appUrl && (appUrl.includes("serveo.net") || appUrl.includes("loca.lt") || appUrl.includes("ngrok.io") || appUrl.includes("ngrok-free.app") || appUrl.includes("cloudflared.io"))) {
+        console.log("[WalletConnect Tron] Detected tunnel service URL:", appUrl);
+        console.log("[WalletConnect Tron] \u26A0\uFE0F Make sure this URL is added to WalletConnect Cloud project allowlist");
+      }
+      if (!appUrl) {
+        const tg = window.Telegram?.WebApp;
+        if (tg && tg.initDataUnsafe?.start_param) {
+          appUrl = "https://enclave.network";
+        } else {
+          appUrl = "https://enclave.network";
+        }
+      }
+    } else {
+      appUrl = "https://enclave.network";
+    }
+    if (!appUrl || !appUrl.startsWith("http://") && !appUrl.startsWith("https://")) {
+      appUrl = "https://enclave.network";
+    }
+    const icons = [
+      "https://walletconnect.com/walletconnect-logo.svg",
+      "https://avatars.githubusercontent.com/u/37784886"
+      // WalletConnect GitHub avatar
+    ];
+    let network = WalletConnectChainID.Mainnet;
+    if (chainId !== void 0) {
+      if (chainId === 195 || chainId === _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID) {
+        network = WalletConnectChainID.Mainnet;
+      } else if (chainId === 201910292) {
+        network = WalletConnectChainID.Shasta;
+      } else if (chainId === 2494104990) {
+        network = WalletConnectChainID.Nile;
+      }
+    }
+    const metadataInfo = {
+      name: "Enclave Wallet SDK",
+      description: "Multi-chain wallet adapter for Enclave",
+      url: appUrl,
+      icons,
+      network,
+      chainId,
+      isTelegram: this.isTelegramMiniApp(),
+      projectId: this.projectId,
+      urlValid: appUrl && (appUrl.startsWith("http://") || appUrl.startsWith("https://")),
+      iconsValid: icons && icons.length > 0 && icons.every((icon) => icon && icon.startsWith("http")),
+      currentLocation: typeof window !== "undefined" ? window.location.href : "N/A",
+      telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A"
+    };
+    console.log("[WalletConnect Tron] Initializing with metadata:", metadataInfo);
+    if (!metadataInfo.urlValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid URL in metadata:", appUrl);
+    }
+    if (!metadataInfo.iconsValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid icons in metadata:", icons);
+    }
+    console.log("[WalletConnect Tron] Initializing wallet...", {
+      network,
+      chainId,
+      note: "If no wallets are in WalletConnect Explorer for TRON, QR code will be displayed for scanning"
+    });
+    _WalletConnectTronAdapter.walletInstance = new WalletConnectWallet({
+      network,
+      options: {
+        projectId: this.projectId,
+        metadata: {
+          name: "Enclave Wallet SDK",
+          description: "Multi-chain wallet adapter for Enclave",
+          url: appUrl,
+          icons
+        }
+      },
+      // Theme configuration
+      themeMode: "light",
+      themeVariables: {
+        "--w3m-z-index": 1e4
+        // Ensure modal appears above Telegram UI
+      },
+      // Web3Modal configuration for recommended wallets
+      // According to official docs: https://developers.tron.network/docs/walletconnect-tron
+      // Note: If no wallets are registered in WalletConnect Explorer for TRON,
+      // explorerRecommendedWalletIds will have no effect, and QR code will be shown instead.
+      // @ts-ignore - web3ModalConfig is supported but may not be in TypeScript types
+      web3ModalConfig: {
+        themeMode: "light",
+        themeVariables: {
+          "--w3m-z-index": 1e4
+        },
+        /**
+         * Recommended Wallets are fetched from WalletConnect explore api:
+         * https://walletconnect.com/explorer?type=wallet&version=2
+         * 
+         * IMPORTANT: If wallets are not registered in Explorer for TRON, this list will be ignored.
+         * The AppKit will show a QR code instead, which users can scan with any WalletConnect-compatible wallet.
+         * 
+         * Wallet IDs (for reference, may not work if not in Explorer):
+         * - TokenPocket: 20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66
+         * - TronLink: 1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369
+         */
+        explorerRecommendedWalletIds: [
+          // These IDs are kept for when wallets register in WalletConnect Explorer
+          // Currently, if no TRON wallets are in Explorer, QR code will be shown
+          "20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66",
+          // TokenPocket
+          "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369",
+          // TronLink
+          "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0"
+          // TokenPocket (backup)
+        ]
+      }
+    });
+    _WalletConnectTronAdapter.walletProjectId = this.projectId;
+  }
+  /**
+   * Connect wallet
+   */
+  async connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("WalletConnect requires a browser environment");
+    }
+    const currentState = this.state;
+    if (currentState === "connecting" /* CONNECTING */) {
+      console.warn("[WalletConnect Tron] Connection already in progress, waiting...");
+      let attempts = 0;
+      while (this.state === "connecting" /* CONNECTING */ && attempts < 50) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        attempts++;
+      }
+      if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+        return this.currentAccount;
+      }
+      if (this.state === "connecting" /* CONNECTING */) {
+        throw new Error("Connection timeout - previous connection attempt is still pending");
+      }
+    }
+    if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+      return this.currentAccount;
+    }
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        throw new Error("Failed to initialize WalletConnect wallet");
+      }
+      let network = WalletConnectChainID.Mainnet;
+      if (targetChainId === 195) {
+        network = WalletConnectChainID.Mainnet;
+      } else if (targetChainId === 201910292) {
+        network = WalletConnectChainID.Shasta;
+      } else if (targetChainId === 2494104990) {
+        network = WalletConnectChainID.Nile;
+      }
+      let address;
+      try {
+        console.log("[WalletConnect Tron] Attempting to connect...", {
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp(),
+          projectId: this.projectId
+        });
+        const result = await this.wallet.connect();
+        address = result.address;
+        if (!address) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        console.log("[WalletConnect Tron] Connection successful:", {
+          address,
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp()
+        });
+      } catch (error) {
+        const errorMessage = error.message || String(error);
+        const errorCode = error.code || error.error?.code;
+        const origin = typeof window !== "undefined" && window.location ? window.location.origin : "";
+        let detailedError = errorMessage;
+        if (error.error) {
+          if (typeof error.error === "string") {
+            detailedError = error.error;
+          } else if (error.error.message) {
+            detailedError = error.error.message;
+          } else if (error.error.data) {
+            detailedError = JSON.stringify(error.error.data);
+          }
+        }
+        const isNoWalletFound = errorMessage.includes("\u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305") || errorMessage.includes("No matching wallet") || errorMessage.includes("No wallet found") || errorMessage.includes("\u627E\u4E0D\u5230\u94B1\u5305") || errorMessage.includes("not found") || errorMessage.includes("no matching");
+        const isTimeout = errorMessage.includes("timeout") || errorMessage.includes("\u8D85\u65F6") || errorCode === "TIMEOUT";
+        const isRejected = errorMessage.includes("rejected") || errorMessage.includes("\u62D2\u7EDD") || errorCode === 4001;
+        const isOriginNotAllowed = errorCode === 3e3 || /origin not allowed/i.test(errorMessage) || /Unauthorized:\s*origin not allowed/i.test(errorMessage);
+        const currentMetadata = this.wallet ? {
+          // Try to get metadata from wallet instance if available
+          projectId: this.projectId,
+          network
+        } : null;
+        const errorDetails = {
+          error: errorMessage,
+          detailedError,
+          code: errorCode,
+          isTelegram: this.isTelegramMiniApp(),
+          network,
+          chainId: targetChainId,
+          projectId: this.projectId,
+          metadata: currentMetadata,
+          // Get URL from window.location if available
+          currentUrl: typeof window !== "undefined" ? window.location.href : "N/A",
+          telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A",
+          errorType: isNoWalletFound ? "NO_WALLET_FOUND" : isTimeout ? "TIMEOUT" : isRejected ? "REJECTED" : "UNKNOWN"
+        };
+        console.error("[WalletConnect Tron] Connection error - Full details:", errorDetails);
+        console.error("[WalletConnect Tron] Error object:", error);
+        console.error("[WalletConnect Tron] Error stack:", error.stack);
+        if (isNoWalletFound) {
+          const noWalletErrorDetails = [
+            `
+=== WalletConnect Tron: No Matching Wallet Found ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            ``,
+            `Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            ``,
+            `Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `  - Metadata URL: ${typeof window !== "undefined" ? window.location.origin : "N/A"}`,
+            ``,
+            `Possible Causes:`,
+            `  1. No WalletConnect-compatible wallet (TokenPocket, etc.) installed on device`,
+            `  2. Wallet app not opened or not responding to deep link (wc://)`,
+            `  3. Deep link handling issue in Telegram Mini App environment`,
+            `  4. WalletConnect session timeout (user took too long to approve)`,
+            `  5. Network connectivity issue preventing WalletConnect relay connection`,
+            ``,
+            `Solutions:`,
+            `  1. Ensure TokenPocket or other WalletConnect-compatible wallet is installed`,
+            `  2. Try opening the wallet app manually before connecting`,
+            `  3. In Telegram Mini App, ensure the deep link popup is not blocked`,
+            `  4. Try connecting again (may need to wait a few seconds)`,
+            `  5. Check network connection and WalletConnect relay server accessibility`,
+            ``,
+            `For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(noWalletErrorDetails);
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron: \u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305 (No matching wallet found)
+
+\u53EF\u80FD\u7684\u539F\u56E0\uFF1A
+1. \u8BBE\u5907\u4E0A\u672A\u5B89\u88C5\u652F\u6301 WalletConnect \u7684\u94B1\u5305\uFF08\u5982 TokenPocket\uFF09
+2. \u94B1\u5305\u5E94\u7528\u672A\u6253\u5F00\u6216\u672A\u54CD\u5E94 deep link (wc://)
+3. \u5728 Telegram Mini App \u4E2D\uFF0Cdeep link \u5904\u7406\u53EF\u80FD\u6709\u95EE\u9898
+4. \u8FDE\u63A5\u8D85\u65F6\uFF08\u7528\u6237\u672A\u53CA\u65F6\u6279\u51C6\uFF09
+5. \u7F51\u7EDC\u8FDE\u63A5\u95EE\u9898
+
+\u89E3\u51B3\u65B9\u6848\uFF1A
+1. \u786E\u4FDD\u5DF2\u5B89\u88C5 TokenPocket \u6216\u5176\u4ED6\u652F\u6301 WalletConnect \u7684\u94B1\u5305
+2. \u5C1D\u8BD5\u624B\u52A8\u6253\u5F00\u94B1\u5305\u5E94\u7528\u540E\u518D\u8FDE\u63A5
+3. \u5728 Telegram Mini App \u4E2D\uFF0C\u786E\u4FDD deep link \u5F39\u7A97\u672A\u88AB\u963B\u6B62
+4. \u7A0D\u7B49\u51E0\u79D2\u540E\u91CD\u8BD5\u8FDE\u63A5
+5. \u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u548C WalletConnect \u4E2D\u7EE7\u670D\u52A1\u5668\u53EF\u8BBF\u95EE\u6027
+
+\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\u65E5\u5FD7\u3002`
+          );
+        }
+        if (errorMessage.includes("Invalid") || errorMessage.includes("Configuration") || errorMessage.includes("App Config") || errorMessage.includes("Invalid App")) {
+          const configErrorDetails = [
+            `
+=== WalletConnect Tron Configuration Error ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            `
+Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            `
+Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `
+Possible Causes:`,
+            `  1. Deep link (wc://) handling issue in Telegram Mini App`,
+            `  2. Invalid metadata configuration (URL or icons not accessible)`,
+            `  3. Network/chainId mismatch`,
+            `  4. WalletConnect project ID not configured correctly`,
+            `  5. Domain not added to WalletConnect Cloud allowlist`,
+            `
+Please check:`,
+            `  - WalletConnect Project ID is valid and active`,
+            `  - Domain is added to WalletConnect Cloud allowlist (for serveo.net, etc.)`,
+            `  - Metadata URL is accessible: Check console for metadata logs`,
+            `  - Icons are accessible: Check console for icon URLs`,
+            `  - Network matches chainId: Expected ${network} for chainId ${targetChainId}`,
+            `
+For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(configErrorDetails);
+          throw new ConfigurationError(
+            `WalletConnect Tron connection failed: ${errorMessage}
+
+Configuration Details:
+- Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}
+- Platform: ${errorDetails.telegramPlatform}
+- Origin: ${origin || "(unknown)"}
+- Project ID: ${this.projectId ? "Set" : "Missing"}
+- Network: ${network}
+- Chain ID: ${targetChainId}
+
+This "Invalid App Configuration" error may be caused by:
+1. Deep link (wc://) handling issue in Telegram Mini App
+2. Invalid metadata configuration (URL or icons)
+3. Network/chainId mismatch
+4. Domain not added to WalletConnect Cloud allowlist
+
+Please check the console for detailed error information.`
+          );
+        }
+        if (isOriginNotAllowed) {
+          throw new ConfigurationError(
+            `WalletConnect Tron relayer rejected this origin (code 3000: Unauthorized: origin not allowed).
+
+Fix:
+1) Open WalletConnect Cloud \u2192 your project (${this.projectId})
+2) Add this site origin to the allowlist:
+   - ${origin || "(unknown origin)"}
+
+Common dev origins to allow:
+- http://localhost:5173
+- http://192.168.0.221:5173 (your LAN dev URL)
+- https://wallet-test.enclave-hq.com (your Cloudflare Tunnel/custom domain)
+
+Original error: ${errorMessage}`
+          );
+        }
+        if (isTimeout) {
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron connection timeout. Please try again and ensure your wallet app is open and ready.`
+          );
+        }
+        if (isRejected) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        throw error;
+      }
+      this.currentAddress = address;
+      const account = {
+        universalAddress: createUniversalAddress(targetChainId, address),
+        nativeAddress: address,
+        chainId: targetChainId,
+        chainType: ChainType.TRON,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      this.currentAddress = null;
+      if (error.message?.includes("rejected") || error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    this.removeEventListeners();
+    if (this.wallet) {
+      try {
+        await this.wallet.disconnect();
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Error during disconnect:", error);
+      }
+    }
+    this.wallet = null;
+    this.currentAddress = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * Sign message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      const signature = await this.wallet.signMessage(message);
+      if (typeof signature === "string") {
+        return signature;
+      } else if (signature && typeof signature === "object") {
+        if ("signature" in signature) {
+          return signature.signature;
+        } else if ("result" in signature) {
+          return signature.result;
+        } else {
+          return JSON.stringify(signature);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign message error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError();
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signMessage is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign message failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Sign transaction
+   * 
+   * @param transaction - Tron transaction object
+   *                      Can be created using TronWeb (if available) or any TRON transaction builder
+   *                      Format: { raw_data: {...}, raw_data_hex: "...", txID: "..." }
+   * @returns Signed transaction object or signature
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      if (!transaction) {
+        throw new Error("Transaction object is required");
+      }
+      console.log("[WalletConnect Tron] Signing transaction:", {
+        hasRawData: !!transaction.raw_data,
+        hasRawDataHex: !!transaction.raw_data_hex,
+        hasTxID: !!transaction.txID
+      });
+      const result = await this.wallet.signTransaction(transaction);
+      if (typeof result === "string") {
+        return result;
+      } else if (result && typeof result === "object") {
+        if ("txID" in result && typeof result.txID === "string") {
+          return result.txID;
+        } else if ("txid" in result && typeof result.txid === "string") {
+          return result.txid;
+        } else if ("signature" in result) {
+          return JSON.stringify(result);
+        } else {
+          return JSON.stringify(result);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign transaction error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else if (error?.data?.message) {
+        errorMessage = error.data.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError("Transaction signature was rejected by user");
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || errorMessage?.includes("Not support") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signTransaction is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign transaction failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Read contract (not supported by WalletConnect)
+   */
+  async readContract(_params) {
+    this.ensureConnected();
+    throw new Error("WalletConnect Tron does not support direct contract reading. Please use direct Tron RPC calls or a wallet extension (like TronLink) for read operations.");
+  }
+  /**
+   * Write contract (not yet implemented)
+   */
+  async writeContract(_params) {
+    throw new Error("Contract write not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Estimate gas (not yet implemented)
+   */
+  async estimateGas(_params) {
+    throw new Error("Gas estimation not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Wait for transaction (not yet implemented)
+   */
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new Error("Transaction waiting not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.on("accountsChanged", (accounts) => {
+      if (accounts && accounts.length > 0 && accounts[0] !== this.currentAddress) {
+        const newAddress = accounts[0];
+        this.currentAddress = newAddress;
+        if (this.currentAccount) {
+          const newAccount = {
+            ...this.currentAccount,
+            nativeAddress: newAddress,
+            universalAddress: createUniversalAddress(this.currentAccount.chainId, newAddress)
+          };
+          this.setAccount(newAccount);
+          this.emit("accountChanged", newAccount);
+        }
+      } else if (!accounts || accounts.length === 0) {
+        this.disconnect();
+      }
+    });
+    this.wallet.on("disconnect", () => {
+      this.disconnect();
+    });
+  }
+  /**
+   * Remove event listeners
+   */
+  removeEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.removeAllListeners("accountsChanged");
+    this.wallet.removeAllListeners("disconnect");
+  }
+  /**
+   * Get provider (returns wallet instance)
+   */
+  getProvider() {
+    return this.wallet;
+  }
+  /**
+   * Clear static wallet instance (for complete cleanup)
+   */
+  static clearWalletInstance() {
+    if (_WalletConnectTronAdapter.walletInstance) {
+      _WalletConnectTronAdapter.walletInstance.disconnect().catch(() => {
+      });
+      _WalletConnectTronAdapter.walletInstance = null;
+      _WalletConnectTronAdapter.walletProjectId = null;
+    }
+  }
+};
+// Tron 主网链 ID
+_WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID = 195;
+// Static wallet instance to avoid multiple initializations
+_WalletConnectTronAdapter.walletInstance = null;
+_WalletConnectTronAdapter.walletProjectId = null;
+var WalletConnectTronAdapter = _WalletConnectTronAdapter;
+
+// src/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(ChainType.EVM)) {
+      this.chainType = ChainType.EVM;
+      this.type = "deep-link-evm" /* DEEP_LINK_EVM */;
+    } else if (this.provider.supportedChainTypes.includes(ChainType.TRON)) {
+      this.chainType = ChainType.TRON;
+      this.type = "deep-link-tron" /* DEEP_LINK_TRON */;
+    } else {
+      this.chainType = ChainType.EVM;
+      this.type = "deep-link-evm" /* DEEP_LINK_EVM */;
+    }
+    if (typeof window !== "undefined") {
+      this.setupCallbackHandler();
+    }
+  }
+  /**
+   * Create provider instance based on type
+   */
+  createProvider(config) {
+    switch (config.providerType) {
+      case "tokenpocket" /* TOKENPOCKET */: {
+        const { TokenPocketDeepLinkProvider: TokenPocketDeepLinkProvider2 } = (init_tokenpocket(), __toCommonJS(tokenpocket_exports));
+        return new TokenPocketDeepLinkProvider2({
+          callbackUrl: config.callbackUrl,
+          callbackSchema: config.callbackSchema
+        });
+      }
+      case "tronlink" /* TRONLINK */: {
+        const { TronLinkDeepLinkProvider: TronLinkDeepLinkProvider2 } = (init_tronlink(), __toCommonJS(tronlink_exports));
+        return new TronLinkDeepLinkProvider2();
+      }
+      case "imtoken" /* IMTOKEN */: {
+        const { ImTokenDeepLinkProvider: ImTokenDeepLinkProvider2 } = (init_imtoken(), __toCommonJS(imtoken_exports));
+        return new ImTokenDeepLinkProvider2({
+          callbackUrl: config.callbackUrl,
+          callbackSchema: config.callbackSchema
+        });
+      }
+      case "metamask" /* METAMASK */: {
+        const { MetaMaskDeepLinkProvider: MetaMaskDeepLinkProvider2 } = (init_metamask(), __toCommonJS(metamask_exports));
+        return new MetaMaskDeepLinkProvider2();
+      }
+      case "okx" /* OKX */: {
+        const { OKXDeepLinkProvider: OKXDeepLinkProvider2 } = (init_okx(), __toCommonJS(okx_exports));
+        return new OKXDeepLinkProvider2();
+      }
+      default:
+        throw new Error(`Unsupported deep link provider type: ${config.providerType}`);
+    }
+  }
+  /**
+   * Setup callback handler for deep link results
+   */
+  setupCallbackHandler() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const handleUrlChange = () => {
+      const urlParams = new URLSearchParams(window.location.search);
+      const result = this.provider.parseCallbackResult(urlParams);
+      if (result.actionId && _DeepLinkAdapter.pendingActions.has(result.actionId)) {
+        const callback = _DeepLinkAdapter.pendingActions.get(result.actionId);
+        if (result.error) {
+          callback.reject(new Error(result.error));
+        } else if (result.result) {
+          callback.resolve(result.result);
+        }
+        _DeepLinkAdapter.pendingActions.delete(result.actionId);
+      }
+    };
+    window.addEventListener("popstate", handleUrlChange);
+    window.addEventListener("hashchange", handleUrlChange);
+    handleUrlChange();
+  }
+  /**
+   * Check if deep link is available
+   */
+  async isAvailable() {
+    return this.provider.isAvailable();
+  }
+  /**
+   * Connect to wallet via deep link
+   * 
+   * Note: Deep links typically don't support persistent connections
+   * This method may throw ConnectionRejectedError as deep links are
+   * primarily used for signing operations, not connection
+   */
+  async connect(chainId) {
+    const targetChainId = Array.isArray(chainId) ? chainId[0] : chainId || 1;
+    let chainType;
+    if (targetChainId === 195) {
+      chainType = ChainType.TRON;
+    } else {
+      chainType = ChainType.EVM;
+    }
+    if (!this.provider.supportedChainTypes.includes(chainType)) {
+      throw new Error(
+        `Provider ${this.provider.name} does not support chain type ${chainType}`
+      );
+    }
+    if (this.provider.buildConnectLink) {
+      const linkInfo = this.provider.buildConnectLink({
+        chainId: targetChainId,
+        chainType
+      });
+      if (linkInfo.actionId) {
+        return new Promise((resolve, reject) => {
+          _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, {
+            resolve: (result) => {
+              const address = result?.address || result?.account || result;
+              if (!address || typeof address !== "string") {
+                reject(new ConnectionRejectedError("Invalid connection result: no address found"));
+                return;
+              }
+              const account = {
+                universalAddress: createUniversalAddress(targetChainId, address),
+                nativeAddress: address,
+                chainId: targetChainId,
+                chainType,
+                isActive: true
+              };
+              this.setState("connected" /* CONNECTED */);
+              this.setAccount(account);
+              this.emit("connected", account);
+              resolve(account);
+            },
+            reject: (error) => {
+              this.setState("disconnected" /* DISCONNECTED */);
+              reject(error);
+            }
+          });
+          window.location.href = linkInfo.url;
+          setTimeout(() => {
+            if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+              _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+              this.setState("disconnected" /* DISCONNECTED */);
+              reject(new ConnectionRejectedError("Deep link connection timeout"));
+            }
+          }, 3e4);
+        });
+      } else {
+        window.location.href = linkInfo.url;
+        throw new ConnectionRejectedError(
+          "Deep link connection initiated. Please complete the connection in your wallet app."
+        );
+      }
+    } else {
+      throw new ConnectionRejectedError(
+        `Deep link connection is not supported by ${this.provider.name}. Deep links are primarily used for signing operations.`
+      );
+    }
+  }
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect() {
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.currentChainId = null;
+    this.currentChainType = null;
+    this.emitDisconnected();
+  }
+  /**
+   * Sign a message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    if (!this.currentChainId || !this.currentChainType) {
+      throw new WalletNotConnectedError(this.type);
+    }
+    const linkInfo = this.provider.buildSignMessageLink({
+      message,
+      chainId: this.currentChainId,
+      chainType: this.currentChainType
+    });
+    if (linkInfo.callbackSchema || linkInfo.callbackUrl) {
+      return new Promise((resolve, reject) => {
+        _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, { resolve, reject });
+        window.location.href = linkInfo.url;
+        setTimeout(() => {
+          if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+            _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+            reject(new SignatureRejectedError("Message signature timeout"));
+          }
+        }, 3e4);
+      });
+    } else {
+      window.location.href = linkInfo.url;
+      throw new SignatureRejectedError(
+        "Deep link signature initiated. Please complete the signature in your wallet app."
+      );
+    }
+  }
+  /**
+   * Sign a transaction
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    if (!this.currentChainId || !this.currentChainType) {
+      throw new WalletNotConnectedError(this.type);
+    }
+    const linkInfo = this.provider.buildSignTransactionLink({
+      transaction,
+      chainId: this.currentChainId,
+      chainType: this.currentChainType
+    });
+    if (linkInfo.callbackSchema || linkInfo.callbackUrl) {
+      return new Promise((resolve, reject) => {
+        _DeepLinkAdapter.pendingActions.set(linkInfo.actionId, { resolve, reject });
+        window.location.href = linkInfo.url;
+        setTimeout(() => {
+          if (_DeepLinkAdapter.pendingActions.has(linkInfo.actionId)) {
+            _DeepLinkAdapter.pendingActions.delete(linkInfo.actionId);
+            reject(new SignatureRejectedError("Transaction signature timeout"));
+          }
+        }, 3e4);
+      });
+    } else {
+      window.location.href = linkInfo.url;
+      throw new SignatureRejectedError(
+        "Deep link transaction signature initiated. Please complete the signature in your wallet app."
+      );
+    }
+  }
+  /**
+   * Get provider (not applicable for deep links)
+   */
+  getProvider() {
+    return null;
+  }
+  /**
+   * Static method to handle callback from wallet apps
+   * This can be called from anywhere in the application
+   */
+  static handleCallback() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const urlParams = new URLSearchParams(window.location.search);
+    const actionId = urlParams.get("actionId");
+    if (actionId && _DeepLinkAdapter.pendingActions.has(actionId)) {
+      const callback = _DeepLinkAdapter.pendingActions.get(actionId);
+      const result = urlParams.get("result");
+      const error = urlParams.get("error");
+      if (error) {
+        callback.reject(new Error(error));
+      } else if (result) {
+        try {
+          const parsedResult = JSON.parse(decodeURIComponent(result));
+          callback.resolve(parsedResult);
+        } catch (e) {
+          callback.resolve(result);
+        }
+      }
+      _DeepLinkAdapter.pendingActions.delete(actionId);
+    }
+  }
+  /**
+   * Set current account (called after successful connection)
+   */
+  setAccount(account) {
+    this.currentAccount = account;
+    if (account) {
+      this.currentChainId = account.chainId;
+      this.currentChainType = account.chainType;
+    }
+  }
+  /**
+   * Emit disconnected event
+   */
+  emitDisconnected() {
+    this.emit("disconnected");
+  }
+};
+// Static map to store pending actions across all instances
+// Key: actionId, Value: { resolve, reject }
+_DeepLinkAdapter.pendingActions = /* @__PURE__ */ new Map();
+var DeepLinkAdapter = _DeepLinkAdapter;
+
+// src/core/adapter-registry.ts
+var AdapterRegistry = class {
+  constructor(config = {}) {
+    this.adapters = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.registerDefaultAdapters();
+  }
+  /**
+   * Register default adapters
+   */
+  registerDefaultAdapters() {
+    this.register("metamask" /* METAMASK */, () => new MetaMaskAdapter());
+    this.register("private-key" /* PRIVATE_KEY */, () => new EVMPrivateKeyAdapter());
+    if (this.config.walletConnectProjectId) {
+      this.register(
+        "walletconnect" /* WALLETCONNECT */,
+        () => new WalletConnectAdapter(this.config.walletConnectProjectId)
+      );
+      this.register(
+        "walletconnect-tron" /* WALLETCONNECT_TRON */,
+        () => 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());
+  }
+  /**
+   * 根据链类型获取适配器类型列表
+   */
+  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.toDataURL(this.config.requestUrl, qrCodeOptions);
+      return this.qrCodeDataUrl;
+    } catch (error) {
+      throw new Error(`Failed to generate QR code: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * 开始轮询签名结果
+   */
+  async startPolling(onStatusChange, onResult) {
+    if (this.status === "success" /* SUCCESS */ && this.result?.signature) {
+      return this.result.signature;
+    }
+    if (this.status === "cancelled" /* CANCELLED */ || this.status === "timeout" /* TIMEOUT */) {
+      throw new SignatureRejectedError("Signature request was cancelled or timed out");
+    }
+    this.timeoutTimer = setTimeout(() => {
+      this.stopPolling();
+      this.status = "timeout" /* TIMEOUT */;
+      onStatusChange?.(this.status);
+      throw new SignatureRejectedError("Signature request timed out");
+    }, this.config.timeout);
+    return new Promise((resolve, reject) => {
+      const poll = async () => {
+        try {
+          let result = null;
+          if (this.config.pollFn) {
+            result = await this.config.pollFn(this.config.requestId);
+          } else if (this.config.pollUrl) {
+            result = await this.defaultPoll(this.config.requestId);
+          } else {
+            return;
+          }
+          if (result?.completed) {
+            this.stopPolling();
+            this.result = result;
+            if (result.signature) {
+              this.status = "success" /* SUCCESS */;
+              onStatusChange?.(this.status);
+              onResult?.(result);
+              resolve(result.signature);
+            } else if (result.error) {
+              this.status = "failed" /* FAILED */;
+              onStatusChange?.(this.status);
+              reject(new SignatureRejectedError(result.error));
+            }
+          } else if (result) {
+            if (this.status === "waiting" /* WAITING */) {
+              this.status = "pending" /* PENDING */;
+              onStatusChange?.(this.status);
+            }
+            this.pollTimer = setTimeout(poll, this.config.pollInterval);
+          } else {
+            this.pollTimer = setTimeout(poll, this.config.pollInterval);
+          }
+        } catch (error) {
+          this.stopPolling();
+          this.status = "failed" /* FAILED */;
+          onStatusChange?.(this.status);
+          reject(error);
+        }
+      };
+      poll();
+    });
+  }
+  /**
+   * 默认 HTTP 轮询函数
+   */
+  async defaultPoll(requestId) {
+    if (!this.config.pollUrl) {
+      return null;
+    }
+    try {
+      const url = `${this.config.pollUrl}?requestId=${encodeURIComponent(requestId)}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new NetworkError(`Poll request failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        completed: data.completed === true,
+        signature: data.signature,
+        error: data.error,
+        signer: data.signer
+      };
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      return null;
+    }
+  }
+  /**
+   * 停止轮询
+   */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+  }
+  /**
+   * 取消签名请求
+   */
+  cancel() {
+    this.stopPolling();
+    this.status = "cancelled" /* CANCELLED */;
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 获取二维码 URL
+   */
+  getQRCodeUrl() {
+    return this.config.requestUrl;
+  }
+  /**
+   * 获取结果
+   */
+  getResult() {
+    return this.result;
+  }
+  /**
+   * 清理资源
+   */
+  cleanup() {
+    this.stopPolling();
+    this.qrCodeDataUrl = null;
+    this.result = null;
+    this.status = "waiting" /* WAITING */;
+  }
+};
+
+// src/core/wallet-manager.ts
+var WalletManager = class extends TypedEventEmitter {
   constructor(config = {}) {
     super();
     // Primary wallet
@@ -1701,9 +4540,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
    */
@@ -1770,7 +4615,7 @@ var WalletManager = class extends TypedEventEmitter {
     this.connectedWallets.delete(chainType);
     this.primaryWallet = null;
     if (this.config.enableStorage) {
-      this.saveToStorage();
+      this.clearStorage();
     }
     this.emit("disconnected");
   }
@@ -1859,6 +4704,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)
    */
@@ -2169,6 +5043,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);
@@ -2215,7 +5112,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 = 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;
@@ -2290,6 +5646,9 @@ 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 {
   /**
    * 验证签名
@@ -2331,7 +5690,11 @@ var SignatureVerifier = class {
   }
 };
 
+// src/detection/detector.ts
+init_types();
+
 // src/detection/supported-wallets.ts
+init_types();
 var SUPPORTED_WALLETS = {
   ["metamask" /* METAMASK */]: {
     type: "metamask" /* METAMASK */,
@@ -2378,6 +5741,20 @@ var SUPPORTED_WALLETS = {
     chainType: 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: 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: ChainType.TRON,
+    icon: "https://tokenpocket.pro/icon.png",
+    description: "Deep link connection for TRON chain (TokenPocket, TronLink, etc.)"
   }
 };
 function getWalletMetadata(type) {
@@ -2525,6 +5902,7 @@ function shortenTronAddress(address, chars = 4) {
 }
 
 // src/utils/validation.ts
+init_types();
 function validateAddress(address, chainType) {
   switch (chainType) {
     case ChainType.EVM:
@@ -2594,6 +5972,6 @@ function removeHexPrefix(value) {
 // src/index.ts
 var index_default = WalletManager;
 
-export { AdapterRegistry, AuthMessageGenerator, BrowserWalletAdapter, CHAIN_INFO, ChainNotSupportedError, ChainType, ConfigurationError, ConnectionRejectedError, EVMPrivateKeyAdapter, MetaMaskAdapter, MethodNotSupportedError, NetworkError, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, TransactionFailedError, TronLinkAdapter, WalletAdapter, WalletDetector, WalletManager, WalletNotAvailableError, WalletNotConnectedError, WalletSDKError, WalletState, WalletType, compareEVMAddresses, compareTronAddresses, compareUniversalAddresses, createUniversalAddress, index_default as default, ensureHexPrefix, formatEVMAddress, fromHex, getAddressFromUniversalAddress, getChainIdFromUniversalAddress, getChainInfo, getChainType, getEVMWallets, getTronWallets, getWalletMetadata, hexToNumber, isEVMChain, isHex, isTronChain, isValidChainId, isValidEVMAddress, isValidSignature, isValidTransactionHash, isValidTronAddress, isValidTronHexAddress, isValidUniversalAddress, numberToHex, parseUniversalAddress, removeHexPrefix, shortenAddress, shortenTronAddress, toHex, validateAddress, validateAddressForChain };
+export { AdapterRegistry, AuthMessageGenerator, BrowserWalletAdapter, CHAIN_INFO, ChainNotSupportedError, ChainType, ConfigurationError, ConnectionRejectedError, DeepLinkAdapter, DeepLinkProviderType, DeepLinkWalletType, EVMPrivateKeyAdapter, ImTokenDeepLinkProvider, MetaMaskAdapter, MetaMaskDeepLinkProvider, MethodNotSupportedError, NetworkError, OKXDeepLinkProvider, QRCodeSignStatus, QRCodeSigner, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, TokenPocketDeepLinkProvider, TransactionFailedError, TronDeepLinkAdapter, TronLinkAdapter, TronLinkDeepLinkProvider, WalletAdapter, WalletConnectAdapter, WalletConnectTronAdapter, WalletDetector, WalletManager, WalletNotAvailableError, WalletNotConnectedError, WalletSDKError, WalletState, WalletType, compareEVMAddresses, compareTronAddresses, compareUniversalAddresses, createUniversalAddress, index_default as default, ensureHexPrefix, formatEVMAddress, fromHex, getAddressFromUniversalAddress, getChainIdFromUniversalAddress, getChainInfo, getChainType, getEVMWallets, getTronWallets, getWalletMetadata, hexToNumber, isEVMChain, isHex, isTronChain, isValidChainId, isValidEVMAddress, isValidSignature, isValidTransactionHash, isValidTronAddress, isValidTronHexAddress, isValidUniversalAddress, numberToHex, parseUniversalAddress, removeHexPrefix, shortenAddress, shortenTronAddress, toHex, validateAddress, validateAddressForChain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map