@enclave-hq/wallet-sdk 1.2.4 → 1.2.5

package/dist/tron.js

@@ -0,0 +1,852 @@
+'use strict';
+
+var walletconnectTron = require('@tronweb3/walletconnect-tron');
+var EventEmitter = require('eventemitter3');
+var chainUtils = require('@enclave-hq/chain-utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/adapters/tron/wallet-connect.ts
+var ChainType = chainUtils.ChainType;
+
+// src/core/errors.ts
+var WalletSDKError = class _WalletSDKError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "WalletSDKError";
+    Object.setPrototypeOf(this, _WalletSDKError.prototype);
+  }
+};
+var WalletNotConnectedError = class extends WalletSDKError {
+  constructor(walletType) {
+    super(
+      walletType ? `Wallet ${walletType} is not connected` : "No wallet is connected",
+      "WALLET_NOT_CONNECTED",
+      { walletType }
+    );
+    this.name = "WalletNotConnectedError";
+  }
+};
+var ConnectionRejectedError = class extends WalletSDKError {
+  constructor(walletType) {
+    super(
+      `Connection to ${walletType} was rejected by user`,
+      "CONNECTION_REJECTED",
+      { walletType }
+    );
+    this.name = "ConnectionRejectedError";
+  }
+};
+var SignatureRejectedError = class extends WalletSDKError {
+  constructor(message) {
+    super(
+      message || "Signature was rejected by user",
+      "SIGNATURE_REJECTED"
+    );
+    this.name = "SignatureRejectedError";
+  }
+};
+var MethodNotSupportedError = class extends WalletSDKError {
+  constructor(method, walletType) {
+    super(
+      `Method ${method} is not supported by ${walletType}`,
+      "METHOD_NOT_SUPPORTED",
+      { method, walletType }
+    );
+    this.name = "MethodNotSupportedError";
+  }
+};
+var ConfigurationError = class extends WalletSDKError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", details);
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/adapters/base/wallet-adapter.ts
+var WalletAdapter = class extends EventEmitter__default.default {
+  constructor() {
+    super(...arguments);
+    // 状态
+    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
+   */
+  async getAddress() {
+    this.ensureConnected();
+    if (!this.currentAccount) {
+      throw new WalletNotConnectedError(this.type);
+    }
+    return this.currentAccount.nativeAddress;
+  }
+  signTransaction(_transaction) {
+    throw new MethodNotSupportedError("signTransaction", this.type);
+  }
+  signTypedData(_typedData) {
+    throw new MethodNotSupportedError("signTypedData", this.type);
+  }
+  // 链切换（默认不支持）
+  switchChain(_chainId) {
+    throw new MethodNotSupportedError("switchChain", this.type);
+  }
+  addChain(_chainConfig) {
+    throw new MethodNotSupportedError("addChain", this.type);
+  }
+  // 合约调用（默认不支持）
+  async readContract(_params) {
+    throw new MethodNotSupportedError("readContract", this.type);
+  }
+  async writeContract(_params) {
+    throw new MethodNotSupportedError("writeContract", this.type);
+  }
+  async estimateGas(_params) {
+    throw new MethodNotSupportedError("estimateGas", this.type);
+  }
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new MethodNotSupportedError("waitForTransaction", this.type);
+  }
+  getSigner() {
+    throw new MethodNotSupportedError("getSigner", this.type);
+  }
+  // 工具方法
+  ensureConnected() {
+    if (this.state !== "connected" /* CONNECTED */ || !this.currentAccount) {
+      throw new WalletNotConnectedError(this.type);
+    }
+  }
+  setState(state) {
+    this.state = state;
+  }
+  setAccount(account) {
+    this.currentAccount = account;
+  }
+  emitAccountChanged(account) {
+    this.emit("accountChanged", account);
+  }
+  emitChainChanged(chainId) {
+    this.emit("chainChanged", chainId);
+  }
+  emitDisconnected() {
+    this.emit("disconnected");
+  }
+  emitError(error) {
+    this.emit("error", error);
+  }
+  // EventEmitter 方法（从 EventEmitter3 继承）
+  // removeAllListeners 已经由 EventEmitter 提供
+};
+
+// src/utils/address/universal-address.ts
+function createUniversalAddress(chainId, address) {
+  return `${chainId}:${address}`;
+}
+
+// src/adapters/tron/wallet-connect.ts
+var _WalletConnectTronAdapter = class _WalletConnectTronAdapter extends WalletAdapter {
+  constructor(projectId) {
+    super();
+    this.type = "walletconnect-tron" /* WALLETCONNECT_TRON */;
+    this.chainType = ChainType.TRON;
+    this.name = "WalletConnect (Tron)";
+    this.icon = "https://avatars.githubusercontent.com/u/37784886";
+    this.wallet = null;
+    this.currentAddress = null;
+    if (!projectId) {
+      throw new ConfigurationError("WalletConnect projectId is required");
+    }
+    this.projectId = projectId;
+  }
+  /**
+   * Check if WalletConnect is available
+   */
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running in Telegram environment (Mini App or Web)
+   * Both Telegram Mini App (in client) and Telegram Web (web.telegram.org) 
+   * provide window.Telegram.WebApp API, so they are treated the same way.
+   */
+  isTelegramMiniApp() {
+    if (typeof window === "undefined") return false;
+    const tg = window.Telegram?.WebApp;
+    if (!tg) return false;
+    const platform = tg.platform || "unknown";
+    console.log("[WalletConnect Tron] Telegram environment detected:", {
+      platform,
+      version: tg.version,
+      isMiniApp: platform !== "web",
+      // Mini App if not web platform
+      isWeb: platform === "web"
+      // Telegram Web if web platform
+    });
+    return true;
+  }
+  /**
+   * Restore session from existing wallet (for storage restoration)
+   */
+  async restoreSession(chainId) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    try {
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        return null;
+      }
+      const status = await this.wallet.checkConnectStatus();
+      if (status && status.address) {
+        this.currentAddress = status.address;
+        const account = {
+          universalAddress: createUniversalAddress(targetChainId, status.address),
+          nativeAddress: status.address,
+          chainId: targetChainId,
+          chainType: ChainType.TRON,
+          isActive: true
+        };
+        this.setState("connected" /* CONNECTED */);
+        this.setAccount(account);
+        this.setupEventListeners();
+        return account;
+      }
+      return null;
+    } catch (error) {
+      console.debug("[WalletConnect Tron] Restore session failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Initialize WalletConnect wallet instance
+   * @param chainId - Optional chain ID to determine network (default: Mainnet)
+   */
+  initializeWallet(chainId) {
+    if (_WalletConnectTronAdapter.walletInstance && _WalletConnectTronAdapter.walletProjectId === this.projectId) {
+      return;
+    }
+    let appUrl = "";
+    if (typeof window !== "undefined") {
+      try {
+        if (window.location && window.location.origin) {
+          appUrl = window.location.origin;
+        } else if (window.location && window.location.href) {
+          const url = new URL(window.location.href);
+          appUrl = url.origin;
+        }
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Failed to get origin from window.location:", error);
+      }
+      if (appUrl && (appUrl.includes("serveo.net") || appUrl.includes("loca.lt") || appUrl.includes("ngrok.io") || appUrl.includes("ngrok-free.app") || appUrl.includes("cloudflared.io"))) {
+        console.log("[WalletConnect Tron] Detected tunnel service URL:", appUrl);
+        console.log("[WalletConnect Tron] \u26A0\uFE0F Make sure this URL is added to WalletConnect Cloud project allowlist");
+      }
+      if (!appUrl) {
+        const tg = window.Telegram?.WebApp;
+        if (tg && tg.initDataUnsafe?.start_param) {
+          appUrl = "https://enclave.network";
+        } else {
+          appUrl = "https://enclave.network";
+        }
+      }
+    } else {
+      appUrl = "https://enclave.network";
+    }
+    if (!appUrl || !appUrl.startsWith("http://") && !appUrl.startsWith("https://")) {
+      appUrl = "https://enclave.network";
+    }
+    const icons = [
+      "https://walletconnect.com/walletconnect-logo.svg",
+      "https://avatars.githubusercontent.com/u/37784886"
+      // WalletConnect GitHub avatar
+    ];
+    let network = walletconnectTron.WalletConnectChainID.Mainnet;
+    if (chainId !== void 0) {
+      if (chainId === 195 || chainId === _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID) {
+        network = walletconnectTron.WalletConnectChainID.Mainnet;
+      } else if (chainId === 201910292) {
+        network = walletconnectTron.WalletConnectChainID.Shasta;
+      } else if (chainId === 2494104990) {
+        network = walletconnectTron.WalletConnectChainID.Nile;
+      }
+    }
+    const metadataInfo = {
+      name: "Enclave Wallet SDK",
+      description: "Multi-chain wallet adapter for Enclave",
+      url: appUrl,
+      icons,
+      network,
+      chainId,
+      isTelegram: this.isTelegramMiniApp(),
+      projectId: this.projectId,
+      urlValid: appUrl && (appUrl.startsWith("http://") || appUrl.startsWith("https://")),
+      iconsValid: icons && icons.length > 0 && icons.every((icon) => icon && icon.startsWith("http")),
+      currentLocation: typeof window !== "undefined" ? window.location.href : "N/A",
+      telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A"
+    };
+    console.log("[WalletConnect Tron] Initializing with metadata:", metadataInfo);
+    if (!metadataInfo.urlValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid URL in metadata:", appUrl);
+    }
+    if (!metadataInfo.iconsValid) {
+      console.warn("[WalletConnect Tron] \u26A0\uFE0F Invalid icons in metadata:", icons);
+    }
+    console.log("[WalletConnect Tron] Initializing wallet...", {
+      network,
+      chainId,
+      note: "If no wallets are in WalletConnect Explorer for TRON, QR code will be displayed for scanning"
+    });
+    _WalletConnectTronAdapter.walletInstance = new walletconnectTron.WalletConnectWallet({
+      network,
+      options: {
+        projectId: this.projectId,
+        metadata: {
+          name: "Enclave Wallet SDK",
+          description: "Multi-chain wallet adapter for Enclave",
+          url: appUrl,
+          icons
+        }
+      },
+      // Theme configuration
+      themeMode: "light",
+      themeVariables: {
+        "--w3m-z-index": 1e4
+        // Ensure modal appears above Telegram UI
+      },
+      // Web3Modal configuration for recommended wallets
+      // According to official docs: https://developers.tron.network/docs/walletconnect-tron
+      // Note: If no wallets are registered in WalletConnect Explorer for TRON,
+      // explorerRecommendedWalletIds will have no effect, and QR code will be shown instead.
+      // @ts-ignore - web3ModalConfig is supported but may not be in TypeScript types
+      web3ModalConfig: {
+        themeMode: "light",
+        themeVariables: {
+          "--w3m-z-index": 1e4
+        },
+        /**
+         * Recommended Wallets are fetched from WalletConnect explore api:
+         * https://walletconnect.com/explorer?type=wallet&version=2
+         * 
+         * IMPORTANT: If wallets are not registered in Explorer for TRON, this list will be ignored.
+         * The AppKit will show a QR code instead, which users can scan with any WalletConnect-compatible wallet.
+         * 
+         * Wallet IDs (for reference, may not work if not in Explorer):
+         * - TokenPocket: 20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66
+         * - TronLink: 1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369
+         */
+        explorerRecommendedWalletIds: [
+          // These IDs are kept for when wallets register in WalletConnect Explorer
+          // Currently, if no TRON wallets are in Explorer, QR code will be shown
+          "20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66",
+          // TokenPocket
+          "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369",
+          // TronLink
+          "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0"
+          // TokenPocket (backup)
+        ]
+      }
+    });
+    _WalletConnectTronAdapter.walletProjectId = this.projectId;
+  }
+  /**
+   * Connect wallet
+   */
+  async connect(chainId) {
+    if (typeof window === "undefined") {
+      throw new Error("WalletConnect requires a browser environment");
+    }
+    const currentState = this.state;
+    if (currentState === "connecting" /* CONNECTING */) {
+      console.warn("[WalletConnect Tron] Connection already in progress, waiting...");
+      let attempts = 0;
+      while (this.state === "connecting" /* CONNECTING */ && attempts < 50) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        attempts++;
+      }
+      if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+        return this.currentAccount;
+      }
+      if (this.state === "connecting" /* CONNECTING */) {
+        throw new Error("Connection timeout - previous connection attempt is still pending");
+      }
+    }
+    if (this.state === "connected" /* CONNECTED */ && this.currentAccount) {
+      return this.currentAccount;
+    }
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const targetChainId = Array.isArray(chainId) ? chainId[0] || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID : chainId || _WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID;
+      if (!_WalletConnectTronAdapter.walletInstance || _WalletConnectTronAdapter.walletProjectId !== this.projectId) {
+        this.initializeWallet(targetChainId);
+      }
+      this.wallet = _WalletConnectTronAdapter.walletInstance;
+      if (!this.wallet) {
+        throw new Error("Failed to initialize WalletConnect wallet");
+      }
+      let network = walletconnectTron.WalletConnectChainID.Mainnet;
+      if (targetChainId === 195) {
+        network = walletconnectTron.WalletConnectChainID.Mainnet;
+      } else if (targetChainId === 201910292) {
+        network = walletconnectTron.WalletConnectChainID.Shasta;
+      } else if (targetChainId === 2494104990) {
+        network = walletconnectTron.WalletConnectChainID.Nile;
+      }
+      let address;
+      try {
+        console.log("[WalletConnect Tron] Attempting to connect...", {
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp(),
+          projectId: this.projectId
+        });
+        const result = await this.wallet.connect();
+        address = result.address;
+        if (!address) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        console.log("[WalletConnect Tron] Connection successful:", {
+          address,
+          network,
+          chainId: targetChainId,
+          isTelegram: this.isTelegramMiniApp()
+        });
+      } catch (error) {
+        const errorMessage = error.message || String(error);
+        const errorCode = error.code || error.error?.code;
+        const origin = typeof window !== "undefined" && window.location ? window.location.origin : "";
+        let detailedError = errorMessage;
+        if (error.error) {
+          if (typeof error.error === "string") {
+            detailedError = error.error;
+          } else if (error.error.message) {
+            detailedError = error.error.message;
+          } else if (error.error.data) {
+            detailedError = JSON.stringify(error.error.data);
+          }
+        }
+        const isNoWalletFound = errorMessage.includes("\u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305") || errorMessage.includes("No matching wallet") || errorMessage.includes("No wallet found") || errorMessage.includes("\u627E\u4E0D\u5230\u94B1\u5305") || errorMessage.includes("not found") || errorMessage.includes("no matching");
+        const isTimeout = errorMessage.includes("timeout") || errorMessage.includes("\u8D85\u65F6") || errorCode === "TIMEOUT";
+        const isRejected = errorMessage.includes("rejected") || errorMessage.includes("\u62D2\u7EDD") || errorCode === 4001;
+        const isOriginNotAllowed = errorCode === 3e3 || /origin not allowed/i.test(errorMessage) || /Unauthorized:\s*origin not allowed/i.test(errorMessage);
+        const currentMetadata = this.wallet ? {
+          // Try to get metadata from wallet instance if available
+          projectId: this.projectId,
+          network
+        } : null;
+        const errorDetails = {
+          error: errorMessage,
+          detailedError,
+          code: errorCode,
+          isTelegram: this.isTelegramMiniApp(),
+          network,
+          chainId: targetChainId,
+          projectId: this.projectId,
+          metadata: currentMetadata,
+          // Get URL from window.location if available
+          currentUrl: typeof window !== "undefined" ? window.location.href : "N/A",
+          telegramPlatform: typeof window !== "undefined" && window.Telegram?.WebApp?.platform || "N/A",
+          errorType: isNoWalletFound ? "NO_WALLET_FOUND" : isTimeout ? "TIMEOUT" : isRejected ? "REJECTED" : "UNKNOWN"
+        };
+        console.error("[WalletConnect Tron] Connection error - Full details:", errorDetails);
+        console.error("[WalletConnect Tron] Error object:", error);
+        console.error("[WalletConnect Tron] Error stack:", error.stack);
+        if (isNoWalletFound) {
+          const noWalletErrorDetails = [
+            `
+=== WalletConnect Tron: No Matching Wallet Found ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            ``,
+            `Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            ``,
+            `Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `  - Metadata URL: ${typeof window !== "undefined" ? window.location.origin : "N/A"}`,
+            ``,
+            `Possible Causes:`,
+            `  1. No WalletConnect-compatible wallet (TokenPocket, etc.) installed on device`,
+            `  2. Wallet app not opened or not responding to deep link (wc://)`,
+            `  3. Deep link handling issue in Telegram Mini App environment`,
+            `  4. WalletConnect session timeout (user took too long to approve)`,
+            `  5. Network connectivity issue preventing WalletConnect relay connection`,
+            ``,
+            `Solutions:`,
+            `  1. Ensure TokenPocket or other WalletConnect-compatible wallet is installed`,
+            `  2. Try opening the wallet app manually before connecting`,
+            `  3. In Telegram Mini App, ensure the deep link popup is not blocked`,
+            `  4. Try connecting again (may need to wait a few seconds)`,
+            `  5. Check network connection and WalletConnect relay server accessibility`,
+            ``,
+            `For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(noWalletErrorDetails);
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron: \u6CA1\u6709\u627E\u5230\u652F\u6301\u7684\u94B1\u5305 (No matching wallet found)
+
+\u53EF\u80FD\u7684\u539F\u56E0\uFF1A
+1. \u8BBE\u5907\u4E0A\u672A\u5B89\u88C5\u652F\u6301 WalletConnect \u7684\u94B1\u5305\uFF08\u5982 TokenPocket\uFF09
+2. \u94B1\u5305\u5E94\u7528\u672A\u6253\u5F00\u6216\u672A\u54CD\u5E94 deep link (wc://)
+3. \u5728 Telegram Mini App \u4E2D\uFF0Cdeep link \u5904\u7406\u53EF\u80FD\u6709\u95EE\u9898
+4. \u8FDE\u63A5\u8D85\u65F6\uFF08\u7528\u6237\u672A\u53CA\u65F6\u6279\u51C6\uFF09
+5. \u7F51\u7EDC\u8FDE\u63A5\u95EE\u9898
+
+\u89E3\u51B3\u65B9\u6848\uFF1A
+1. \u786E\u4FDD\u5DF2\u5B89\u88C5 TokenPocket \u6216\u5176\u4ED6\u652F\u6301 WalletConnect \u7684\u94B1\u5305
+2. \u5C1D\u8BD5\u624B\u52A8\u6253\u5F00\u94B1\u5305\u5E94\u7528\u540E\u518D\u8FDE\u63A5
+3. \u5728 Telegram Mini App \u4E2D\uFF0C\u786E\u4FDD deep link \u5F39\u7A97\u672A\u88AB\u963B\u6B62
+4. \u7A0D\u7B49\u51E0\u79D2\u540E\u91CD\u8BD5\u8FDE\u63A5
+5. \u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u548C WalletConnect \u4E2D\u7EE7\u670D\u52A1\u5668\u53EF\u8BBF\u95EE\u6027
+
+\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\u65E5\u5FD7\u3002`
+          );
+        }
+        if (errorMessage.includes("Invalid") || errorMessage.includes("Configuration") || errorMessage.includes("App Config") || errorMessage.includes("Invalid App")) {
+          const configErrorDetails = [
+            `
+=== WalletConnect Tron Configuration Error ===`,
+            `Error: ${errorMessage}`,
+            `Detailed: ${detailedError}`,
+            `Code: ${errorCode || "N/A"}`,
+            `
+Environment:`,
+            `  - Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}`,
+            `  - Platform: ${errorDetails.telegramPlatform}`,
+            `  - Current URL: ${errorDetails.currentUrl}`,
+            `
+Configuration:`,
+            `  - Project ID: ${this.projectId ? "Set" : "Missing"}`,
+            `  - Network: ${network}`,
+            `  - Chain ID: ${targetChainId}`,
+            `
+Possible Causes:`,
+            `  1. Deep link (wc://) handling issue in Telegram Mini App`,
+            `  2. Invalid metadata configuration (URL or icons not accessible)`,
+            `  3. Network/chainId mismatch`,
+            `  4. WalletConnect project ID not configured correctly`,
+            `  5. Domain not added to WalletConnect Cloud allowlist`,
+            `
+Please check:`,
+            `  - WalletConnect Project ID is valid and active`,
+            `  - Domain is added to WalletConnect Cloud allowlist (for serveo.net, etc.)`,
+            `  - Metadata URL is accessible: Check console for metadata logs`,
+            `  - Icons are accessible: Check console for icon URLs`,
+            `  - Network matches chainId: Expected ${network} for chainId ${targetChainId}`,
+            `
+For more details, see the error object logged above.`,
+            `===========================================
+`
+          ].join("\n");
+          console.error(configErrorDetails);
+          throw new ConfigurationError(
+            `WalletConnect Tron connection failed: ${errorMessage}
+
+Configuration Details:
+- Telegram Mini App: ${this.isTelegramMiniApp() ? "Yes" : "No"}
+- Platform: ${errorDetails.telegramPlatform}
+- Origin: ${origin || "(unknown)"}
+- Project ID: ${this.projectId ? "Set" : "Missing"}
+- Network: ${network}
+- Chain ID: ${targetChainId}
+
+This "Invalid App Configuration" error may be caused by:
+1. Deep link (wc://) handling issue in Telegram Mini App
+2. Invalid metadata configuration (URL or icons)
+3. Network/chainId mismatch
+4. Domain not added to WalletConnect Cloud allowlist
+
+Please check the console for detailed error information.`
+          );
+        }
+        if (isOriginNotAllowed) {
+          throw new ConfigurationError(
+            `WalletConnect Tron relayer rejected this origin (code 3000: Unauthorized: origin not allowed).
+
+Fix:
+1) Open WalletConnect Cloud \u2192 your project (${this.projectId})
+2) Add this site origin to the allowlist:
+   - ${origin || "(unknown origin)"}
+
+Common dev origins to allow:
+- http://localhost:5173
+- http://192.168.0.221:5173 (your LAN dev URL)
+- https://wallet-test.enclave-hq.com (your Cloudflare Tunnel/custom domain)
+
+Original error: ${errorMessage}`
+          );
+        }
+        if (isTimeout) {
+          throw new ConnectionRejectedError(
+            `WalletConnect Tron connection timeout. Please try again and ensure your wallet app is open and ready.`
+          );
+        }
+        if (isRejected) {
+          throw new ConnectionRejectedError(this.type);
+        }
+        throw error;
+      }
+      this.currentAddress = address;
+      const account = {
+        universalAddress: createUniversalAddress(targetChainId, address),
+        nativeAddress: address,
+        chainId: targetChainId,
+        chainType: ChainType.TRON,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      this.currentAddress = null;
+      if (error.message?.includes("rejected") || error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect wallet
+   */
+  async disconnect() {
+    this.removeEventListeners();
+    if (this.wallet) {
+      try {
+        await this.wallet.disconnect();
+      } catch (error) {
+        console.warn("[WalletConnect Tron] Error during disconnect:", error);
+      }
+    }
+    this.wallet = null;
+    this.currentAddress = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * Sign message
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      const signature = await this.wallet.signMessage(message);
+      if (typeof signature === "string") {
+        return signature;
+      } else if (signature && typeof signature === "object") {
+        if ("signature" in signature) {
+          return signature.signature;
+        } else if ("result" in signature) {
+          return signature.result;
+        } else {
+          return JSON.stringify(signature);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign message error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError();
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signMessage is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign message failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Sign transaction
+   * 
+   * @param transaction - Tron transaction object
+   *                      Can be created using TronWeb (if available) or any TRON transaction builder
+   *                      Format: { raw_data: {...}, raw_data_hex: "...", txID: "..." }
+   * @returns Signed transaction object or signature
+   */
+  async signTransaction(transaction) {
+    this.ensureConnected();
+    try {
+      if (!this.wallet) {
+        throw new Error("Wallet not initialized");
+      }
+      if (!transaction) {
+        throw new Error("Transaction object is required");
+      }
+      console.log("[WalletConnect Tron] Signing transaction:", {
+        hasRawData: !!transaction.raw_data,
+        hasRawDataHex: !!transaction.raw_data_hex,
+        hasTxID: !!transaction.txID
+      });
+      const result = await this.wallet.signTransaction(transaction);
+      if (typeof result === "string") {
+        return result;
+      } else if (result && typeof result === "object") {
+        if ("txID" in result && typeof result.txID === "string") {
+          return result.txID;
+        } else if ("txid" in result && typeof result.txid === "string") {
+          return result.txid;
+        } else if ("signature" in result) {
+          return JSON.stringify(result);
+        } else {
+          return JSON.stringify(result);
+        }
+      }
+      throw new Error("Invalid signature format returned from wallet");
+    } catch (error) {
+      console.error("[WalletConnect Tron] Sign transaction error:", error);
+      let errorMessage = "Unknown error";
+      if (typeof error === "string") {
+        errorMessage = error;
+      } else if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.error?.message) {
+        errorMessage = error.error.message;
+      } else if (error?.data?.message) {
+        errorMessage = error.data.message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      if (errorMessage?.includes("rejected") || errorMessage?.includes("declined") || errorMessage?.includes("User rejected") || error?.code === 4001 || error?.code === "USER_REJECTED" || error?.error?.code === 4001) {
+        throw new SignatureRejectedError("Transaction signature was rejected by user");
+      }
+      if (errorMessage?.includes("not supported") || errorMessage?.includes("method not found") || errorMessage?.includes("Method not found") || errorMessage?.includes("Not support") || error?.code === -32601 || error?.error?.code === -32601) {
+        throw new Error("tron_signTransaction is not supported by the connected wallet. Please use a wallet that supports WalletConnect Tron signing, or use TronLink extension for browser-based signing.");
+      }
+      throw new Error(`WalletConnect Tron sign transaction failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Read contract (not supported by WalletConnect)
+   */
+  async readContract(_params) {
+    this.ensureConnected();
+    throw new Error("WalletConnect Tron does not support direct contract reading. Please use direct Tron RPC calls or a wallet extension (like TronLink) for read operations.");
+  }
+  /**
+   * Write contract (not yet implemented)
+   */
+  async writeContract(_params) {
+    throw new Error("Contract write not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Estimate gas (not yet implemented)
+   */
+  async estimateGas(_params) {
+    throw new Error("Gas estimation not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Wait for transaction (not yet implemented)
+   */
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new Error("Transaction waiting not yet implemented for WalletConnect Tron");
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.on("accountsChanged", (accounts) => {
+      if (accounts && accounts.length > 0 && accounts[0] !== this.currentAddress) {
+        const newAddress = accounts[0];
+        this.currentAddress = newAddress;
+        if (this.currentAccount) {
+          const newAccount = {
+            ...this.currentAccount,
+            nativeAddress: newAddress,
+            universalAddress: createUniversalAddress(this.currentAccount.chainId, newAddress)
+          };
+          this.setAccount(newAccount);
+          this.emit("accountChanged", newAccount);
+        }
+      } else if (!accounts || accounts.length === 0) {
+        this.disconnect();
+      }
+    });
+    this.wallet.on("disconnect", () => {
+      this.disconnect();
+    });
+  }
+  /**
+   * Remove event listeners
+   */
+  removeEventListeners() {
+    if (!this.wallet) {
+      return;
+    }
+    this.wallet.removeAllListeners("accountsChanged");
+    this.wallet.removeAllListeners("disconnect");
+  }
+  /**
+   * Get provider (returns wallet instance)
+   */
+  getProvider() {
+    return this.wallet;
+  }
+  /**
+   * Clear static wallet instance (for complete cleanup)
+   */
+  static clearWalletInstance() {
+    if (_WalletConnectTronAdapter.walletInstance) {
+      _WalletConnectTronAdapter.walletInstance.disconnect().catch(() => {
+      });
+      _WalletConnectTronAdapter.walletInstance = null;
+      _WalletConnectTronAdapter.walletProjectId = null;
+    }
+  }
+};
+// Tron 主网链 ID
+_WalletConnectTronAdapter.TRON_MAINNET_CHAIN_ID = 195;
+// Static wallet instance to avoid multiple initializations
+_WalletConnectTronAdapter.walletInstance = null;
+_WalletConnectTronAdapter.walletProjectId = null;
+var WalletConnectTronAdapter = _WalletConnectTronAdapter;
+
+exports.WalletConnectTronAdapter = WalletConnectTronAdapter;
+//# sourceMappingURL=tron.js.map
+//# sourceMappingURL=tron.js.map