@enclave-hq/wallet-sdk 1.2.4 → 1.2.5

package/dist/react/index.mjs

@@ -1,7 +1,7 @@
 import { ChainType as ChainType$1 } from '@enclave-hq/chain-utils';
 import React2, { createContext, useState, useCallback, useEffect, useContext, useRef } from 'react';
 import EventEmitter from 'eventemitter3';
-import { createWalletClient, custom, createPublicClient, http, isAddress, getAddress } from 'viem';
+import { encodeFunctionData, createWalletClient, custom, createPublicClient, http, isAddress, getAddress } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import EthereumProvider from '@walletconnect/ethereum-provider';
 import { WalletConnectChainID, WalletConnectWallet } from '@tronweb3/walletconnect-tron';
@@ -837,7 +837,12 @@ var CHAIN_INFO = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrls: ["https://eth.llamarpc.com"],
+    // 使用支持浏览器 CORS 的公共 RPC，避免 dapp 域名被跨域拦截（如 eth.llamarpc.com 无 CORS 头）
+    rpcUrls: [
+      "https://cloudflare-eth.com",
+      "https://rpc.ankr.com/eth",
+      "https://eth.llamarpc.com"
+    ],
     blockExplorerUrls: ["https://etherscan.io"]
   },
   // EVM Testnets
@@ -1236,6 +1241,56 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
       }]
     });
   }
+  /**
+   * 请求切换账户
+   * 弹出 MetaMask 账户选择界面，让用户选择或切换到目标地址
+   * @param targetAddress 目标地址（可选），如果提供，会在切换后验证是否匹配
+   * @returns 切换后的账户信息
+   */
+  async requestSwitchAccount(targetAddress) {
+    const provider = this.getBrowserProvider();
+    if (!provider) {
+      throw new Error("MetaMask provider not available");
+    }
+    try {
+      await provider.request({
+        method: "wallet_requestPermissions",
+        params: [{ eth_accounts: {} }]
+      });
+      const accounts = await provider.request({
+        method: "eth_accounts"
+      });
+      if (!accounts || accounts.length === 0) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      const address = formatEVMAddress(accounts[0]);
+      if (targetAddress && address.toLowerCase() !== targetAddress.toLowerCase()) {
+        throw new Error(`\u8BF7\u5728 MetaMask \u4E2D\u9009\u62E9\u5730\u5740 ${targetAddress.slice(0, 6)}...${targetAddress.slice(-4)}\uFF0C\u5F53\u524D\u9009\u62E9\u7684\u662F ${address.slice(0, 6)}...${address.slice(-4)}`);
+      }
+      const chainId = this.currentAccount?.chainId || 1;
+      const account = {
+        universalAddress: createUniversalAddress(chainId, address),
+        nativeAddress: address,
+        chainId,
+        chainType: ChainType.EVM,
+        isActive: true
+      };
+      this.setAccount(account);
+      this.emitAccountChanged(account);
+      const viemChain = this.getViemChain(chainId);
+      this.walletClient = createWalletClient({
+        account: address,
+        chain: viemChain,
+        transport: custom(provider)
+      });
+      return account;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
   /**
    * 读取合约
    */
@@ -1461,6 +1516,46 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
 
 // src/adapters/tron/tronlink.ts
 init_types();
+var TronApiRateLimiter = class {
+  constructor(minIntervalMs = 600) {
+    this.lastCallTime = 0;
+    this.minInterval = minIntervalMs;
+  }
+  /**
+   * 等待直到可以进行下一次 API 调用
+   */
+  async waitForNextCall() {
+    const now = Date.now();
+    const timeSinceLastCall = now - this.lastCallTime;
+    if (timeSinceLastCall < this.minInterval) {
+      const waitTime = this.minInterval - timeSinceLastCall;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    this.lastCallTime = Date.now();
+  }
+};
+var tronApiRateLimiter = new TronApiRateLimiter(600);
+async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 500) {
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const errorMsg = error?.message || String(error);
+      const errorLower = errorMsg.toLowerCase();
+      const isRateLimitError = error?.response?.status === 429 || error?.status === 429 || errorLower.includes("429") || errorLower.includes("rate limit") || errorLower.includes("too many requests") || error?.code === "ERR_BAD_REQUEST" && error?.response?.status === 429;
+      if (isRateLimitError && attempt < maxRetries - 1) {
+        const delay = initialDelay * Math.pow(2, attempt);
+        console.warn(`[TronLink] \u9047\u5230\u901F\u7387\u9650\u5236 (429)\uFF0C\u7B49\u5F85 ${delay}ms \u540E\u91CD\u8BD5 (${attempt + 1}/${maxRetries})...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
 var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   constructor() {
     super(...arguments);
@@ -1638,10 +1733,12 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   /**
    * 读取合约
    * 参考 webserver 的实现，使用 TronWeb 合约实例的标准 call() 方法
+   * 带 TronGrid 限流 + 429 重试
    */
   async readContract(params) {
     this.ensureConnected();
-    try {
+    await tronApiRateLimiter.waitForNextCall();
+    const doRead = async () => {
       const tronWeb = this.getTronWeb();
       if (!this.currentAccount) {
         throw new Error("No account connected");
@@ -1656,19 +1753,17 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
         return result;
       } catch (method1Error) {
         console.warn("\u26A0\uFE0F [\u65B9\u6CD51] TronWeb\u6807\u51C6\u65B9\u6CD5\u5931\u8D25\uFF0C\u5C1D\u8BD5\u65B9\u6CD52:", method1Error.message);
-        try {
-          const contract2 = await tronWeb.contract().at(params.address);
-          const method2 = contract2[params.functionName];
-          if (!method2 || typeof method2 !== "function") {
-            throw new Error(`Function ${params.functionName} not found in contract`);
-          }
-          const result = await method2(...params.args || []).call();
-          return result;
-        } catch (method2Error) {
-          console.error("\u26A0\uFE0F [\u65B9\u6CD52] \u4E5F\u5931\u8D25:", method2Error.message);
-          throw method1Error;
+        const contract2 = await tronWeb.contract().at(params.address);
+        const method2 = contract2[params.functionName];
+        if (!method2 || typeof method2 !== "function") {
+          throw new Error(`Function ${params.functionName} not found in contract`);
         }
+        const result = await method2(...params.args || []).call();
+        return result;
       }
+    };
+    try {
+      return await retryWithBackoff(doRead, 3, 800);
     } catch (error) {
       console.error("Read contract error:", error);
       throw new Error(`Failed to read contract: ${error.message || "Unknown error"}`);
@@ -1679,6 +1774,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
    */
   async writeContract(params) {
     this.ensureConnected();
+    await tronApiRateLimiter.waitForNextCall();
     try {
       const tronWeb = this.getTronWeb();
       console.log("[TronLink] writeContract params:", {
@@ -1704,29 +1800,171 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       }
       console.log("[TronLink] Function ABI:", functionAbi);
       console.log("[TronLink] Calling with args:", params.args);
+      const TRON_FEE_LIMIT = 1e8;
       const options = {
-        feeLimit: params.gas || 1e8,
-        // 默认 100 TRX 的能量限制
+        feeLimit: TRON_FEE_LIMIT,
+        // 固定为 100 TRX 的能量限制
         callValue: params.value || 0
         // 发送的 TRX 数量（单位：SUN）
       };
-      const parameter = functionAbi.inputs.map((input, index) => ({
-        type: input.type,
-        value: params.args[index]
-      }));
-      console.log("[TronLink] Transaction options:", options);
-      console.log("[TronLink] Parameters:", parameter);
-      const functionSelector = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
-      console.log("[TronLink] Function selector:", functionSelector);
-      console.log("[TronLink] Transaction options:", options);
-      console.log("[TronLink] Parameters:", parameter);
-      const tx = await tronWeb.transactionBuilder.triggerSmartContract(
-        params.address,
-        functionSelector,
-        options,
-        parameter,
-        this.currentAccount.nativeAddress
-      );
+      const hasTupleArray = functionAbi.inputs.some((input) => input.type === "tuple[]");
+      console.log("[TronLink] \u68C0\u67E5 tuple[] \u7C7B\u578B:", {
+        hasTupleArray,
+        inputs: functionAbi.inputs.map((i) => ({ name: i.name, type: i.type }))
+      });
+      let tx;
+      if (hasTupleArray) {
+        console.log("[TronLink] \u68C0\u6D4B\u5230 tuple[] \u53C2\u6570\uFF0C\u4F7F\u7528\u624B\u52A8\u7F16\u7801\u65B9\u5F0F");
+        const processedArgs = params.args.map((argValue, index) => {
+          const input = functionAbi.inputs[index];
+          if (input.type === "address" && typeof argValue === "string") {
+            if (argValue.startsWith("T") && argValue.length === 34) {
+              const hexAddress = tronWeb.address.toHex(argValue);
+              return hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+            }
+            return argValue.startsWith("0x") ? argValue : `0x${argValue}`;
+          }
+          if (input.type === "tuple[]" && Array.isArray(argValue)) {
+            return argValue.map((tupleItem) => {
+              if (input.components && Array.isArray(input.components)) {
+                const processedTuple = {};
+                input.components.forEach((component) => {
+                  let value = tupleItem[component.name];
+                  if (component.type === "address" && typeof value === "string") {
+                    if (value.startsWith("T") && value.length === 34) {
+                      const hexAddress = tronWeb.address.toHex(value);
+                      value = hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+                    } else if (!value.startsWith("0x")) {
+                      value = `0x${value}`;
+                    }
+                  }
+                  processedTuple[component.name] = value;
+                });
+                return processedTuple;
+              }
+              return tupleItem;
+            });
+          }
+          if (input.type === "tuple" && typeof argValue === "object" && !Array.isArray(argValue)) {
+            if (input.components && Array.isArray(input.components)) {
+              const processedTuple = {};
+              input.components.forEach((component) => {
+                let value = argValue[component.name];
+                if (component.type === "address" && typeof value === "string") {
+                  if (value.startsWith("T") && value.length === 34) {
+                    const hexAddress = tronWeb.address.toHex(value);
+                    value = hexAddress.startsWith("0x") ? hexAddress : `0x${hexAddress}`;
+                  } else if (!value.startsWith("0x")) {
+                    value = `0x${value}`;
+                  }
+                }
+                processedTuple[component.name] = value;
+              });
+              return processedTuple;
+            }
+          }
+          return argValue;
+        });
+        console.log("[TronLink] \u5904\u7406\u540E\u7684\u53C2\u6570\uFF08\u7528\u4E8E viem \u7F16\u7801\uFF09:", processedArgs);
+        const encodedData = encodeFunctionData({
+          abi: [functionAbi],
+          functionName: params.functionName,
+          args: processedArgs
+        });
+        console.log("[TronLink] \u7F16\u7801\u540E\u7684\u6570\u636E:", encodedData);
+        const functionSelector = encodedData.slice(0, 10);
+        const parameterData = encodedData.slice(10);
+        console.log("[TronLink] \u51FD\u6570\u9009\u62E9\u5668:", functionSelector);
+        console.log("[TronLink] \u53C2\u6570\u6570\u636E:", parameterData);
+        const functionSignature = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
+        const parameterHexClean = parameterData.startsWith("0x") ? parameterData.slice(2) : parameterData;
+        console.log("[TronLink] \u4F7F\u7528 TronWeb triggerSmartContract (rawParameter)...", {
+          contractAddress: params.address,
+          functionSelector: functionSignature,
+          encodedDataLength: parameterHexClean.length
+        });
+        tx = await retryWithBackoff(
+          () => tronWeb.transactionBuilder.triggerSmartContract(
+            params.address,
+            // Base58 格式的合约地址
+            functionSignature,
+            // 函数签名（用于识别函数）
+            {
+              feeLimit: options.feeLimit,
+              callValue: options.callValue,
+              rawParameter: parameterHexClean
+              // 使用 rawParameter 直接提供编码后的数据
+            },
+            [],
+            // parameter 留空（因为使用 rawParameter）
+            this.currentAccount.nativeAddress
+            // Base58 格式的发送地址
+          ),
+          3,
+          // 最多重试 3 次
+          500
+          // 初始延迟 500ms
+        );
+        console.log("[TronLink] \u4F7F\u7528 TronWeb API \u6784\u5EFA\u7684\u4EA4\u6613:", tx);
+      } else {
+        const parameter = functionAbi.inputs.map((input, index) => {
+          const argValue = params.args[index];
+          if (input.type === "tuple" && typeof argValue === "object" && !Array.isArray(argValue)) {
+            if (input.components && Array.isArray(input.components)) {
+              return {
+                type: input.type,
+                value: input.components.map((component) => ({
+                  type: component.type,
+                  value: argValue[component.name]
+                }))
+              };
+            }
+          }
+          if (input.type === "address" && typeof argValue === "string") {
+            if (argValue.startsWith("T") && argValue.length === 34) {
+              return {
+                type: input.type,
+                value: argValue
+              };
+            }
+            try {
+              const base58Address = tronWeb.address.fromHex(argValue.startsWith("0x") ? argValue : `0x${argValue}`);
+              return {
+                type: input.type,
+                value: base58Address
+              };
+            } catch (e) {
+              return {
+                type: input.type,
+                value: argValue
+              };
+            }
+          }
+          return {
+            type: input.type,
+            value: argValue
+          };
+        });
+        console.log("[TronLink] Transaction options:", options);
+        console.log("[TronLink] Parameters:", parameter);
+        const functionSelector = params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")";
+        console.log("[TronLink] Function selector:", functionSelector);
+        console.log("[TronLink] Transaction options:", options);
+        console.log("[TronLink] Parameters:", parameter);
+        tx = await retryWithBackoff(
+          () => tronWeb.transactionBuilder.triggerSmartContract(
+            params.address,
+            functionSelector,
+            options,
+            parameter,
+            this.currentAccount.nativeAddress
+          ),
+          3,
+          // 最多重试 3 次
+          500
+          // 初始延迟 500ms
+        );
+      }
       console.log("[TronLink] Transaction built:", tx);
       if (!tx || !tx.transaction) {
         throw new Error("Failed to build transaction");
@@ -1766,6 +2004,7 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       const maxAttempts = 60;
       while (attempts < maxAttempts) {
         try {
+          await tronApiRateLimiter.waitForNextCall();
           const txInfo = await tronWeb.trx.getTransactionInfo(txHash);
           if (txInfo && txInfo.id) {
             const receipt = {
@@ -3183,6 +3422,12 @@ _WalletConnectAdapter.providerChains = null;
 _WalletConnectAdapter.isInitializing = false;
 _WalletConnectAdapter.initPromise = null;
 var WalletConnectAdapter = _WalletConnectAdapter;
+
+// src/adapters/tron/wallet-connect.ts
+var wallet_connect_exports = {};
+__export(wallet_connect_exports, {
+  WalletConnectTronAdapter: () => WalletConnectTronAdapter
+});
 init_types();
 var _WalletConnectTronAdapter = class _WalletConnectTronAdapter extends WalletAdapter {
   constructor(projectId) {
@@ -3875,6 +4120,11 @@ _WalletConnectTronAdapter.walletInstance = null;
 _WalletConnectTronAdapter.walletProjectId = null;
 var WalletConnectTronAdapter = _WalletConnectTronAdapter;
 
+// src/internal/walletconnect-tron-loader.esm.ts
+function loadWalletConnectTronModule() {
+  return wallet_connect_exports;
+}
+
 // src/adapters/deep-link/adapter.ts
 init_types();
 var _DeepLinkAdapter = class _DeepLinkAdapter extends WalletAdapter {
@@ -4181,10 +4431,10 @@ var AdapterRegistry = class {
         "walletconnect" /* WALLETCONNECT */,
         () => new WalletConnectAdapter(this.config.walletConnectProjectId)
       );
-      this.register(
-        "walletconnect-tron" /* WALLETCONNECT_TRON */,
-        () => new WalletConnectTronAdapter(this.config.walletConnectProjectId)
-      );
+      this.register("walletconnect-tron" /* WALLETCONNECT_TRON */, () => {
+        const { WalletConnectTronAdapter: WalletConnectTronAdapter2 } = loadWalletConnectTronModule();
+        return new WalletConnectTronAdapter2(this.config.walletConnectProjectId);
+      });
     }
     this.register("tronlink" /* TRONLINK */, () => new TronLinkAdapter());
     this.register(
@@ -4699,6 +4949,41 @@ var WalletManager = class extends TypedEventEmitter {
       throw error;
     }
   }
+  /**
+   * Request account switch (opens wallet account selector)
+   * @param targetAddress Optional target address to verify after switching
+   * @returns The new account after switching
+   */
+  async requestSwitchAccount(targetAddress) {
+    if (!this.primaryWallet) {
+      throw new WalletNotConnectedError();
+    }
+    if (!this.primaryWallet.requestSwitchAccount) {
+      throw new Error(`Account switching not supported by ${this.primaryWallet.type}`);
+    }
+    const account = await this.primaryWallet.requestSwitchAccount(targetAddress);
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    return account;
+  }
+  /**
+   * Ensure the current account matches the target address
+   * If not matching, request account switch
+   * @param targetAddress The address that should be active
+   * @returns The account (either existing or after switch)
+   */
+  async ensureAccount(targetAddress) {
+    const currentAccount = this.getPrimaryAccount();
+    if (!currentAccount) {
+      throw new WalletNotConnectedError();
+    }
+    if (currentAccount.nativeAddress.toLowerCase() === targetAddress.toLowerCase()) {
+      return currentAccount;
+    }
+    console.log(`[WalletManager] Current account ${currentAccount.nativeAddress} doesn't match target ${targetAddress}, requesting switch...`);
+    return this.requestSwitchAccount(targetAddress);
+  }
   // ===== Contract Calls =====
   /**
    * Read contract