@enclave-hq/wallet-sdk 1.2.0 → 1.2.2

package/dist/index.mjs

@@ -752,25 +752,69 @@ var MetaMaskAdapter = class extends BrowserWalletAdapter {
       throw new Error("Wallet client not initialized");
     }
     try {
-      console.log("\u{1F50D} [MetaMask writeContract] params.gasPrice:", params.gasPrice, "type:", typeof params.gasPrice);
-      let processedGasPrice;
-      if (!params.gasPrice) {
-        processedGasPrice = void 0;
-      } else if (params.gasPrice === "auto") {
-        processedGasPrice = void 0;
-      } else {
-        processedGasPrice = BigInt(params.gasPrice);
-      }
-      console.log("\u{1F50D} [MetaMask writeContract] processedGasPrice:", processedGasPrice);
-      const txHash = await this.walletClient.writeContract({
+      console.log("\u{1F50D} [MetaMask writeContract] Gas params:", {
+        gasPrice: params.gasPrice,
+        maxFeePerGas: params.maxFeePerGas,
+        maxPriorityFeePerGas: params.maxPriorityFeePerGas
+      });
+      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,
-        gasPrice: processedGasPrice
-      });
+        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);
+        }
+        console.log("\u{1F50D} [MetaMask writeContract] Using EIP-1559 gas params");
+      } else if (params.gasPrice) {
+        if (params.gasPrice === "auto") {
+          console.log("\u{1F50D} [MetaMask writeContract] Auto gas price - letting viem decide");
+        } else {
+          txOptions.gasPrice = BigInt(params.gasPrice);
+          console.log("\u{1F50D} [MetaMask writeContract] Using legacy gasPrice");
+        }
+      } else {
+        console.log("\u{1F50D} [MetaMask writeContract] No gas params - fetching and setting reasonable gas fees");
+        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;
+              const maxFeePerGasGwei = Number(adjustedMaxFeePerGas) / 1e9;
+              const maxPriorityFeePerGasGwei = Number(maxPriorityFeePerGas) / 1e9;
+              console.log("\u{1F4B0} [MetaMask writeContract] Set gas fees (EIP-1559):", {
+                maxFeePerGas: `${maxFeePerGasGwei.toFixed(6)} Gwei`,
+                maxPriorityFeePerGas: `${maxPriorityFeePerGasGwei.toFixed(6)} Gwei`,
+                maxFeePerGasWei: adjustedMaxFeePerGas.toString(),
+                maxPriorityFeePerGasWei: maxPriorityFeePerGas.toString(),
+                note: "\u5DF2\u8BBE\u7F6E\u5408\u7406\u7684 gas \u8D39\u7528\uFF0C\u907F\u514D MetaMask \u4F7F\u7528\u9ED8\u8BA4\u503C"
+              });
+            } else {
+              const gasPrice = await this.publicClient.getGasPrice();
+              txOptions.gasPrice = gasPrice;
+              const gasPriceGwei = Number(gasPrice) / 1e9;
+              console.log("\u{1F4B0} [MetaMask writeContract] Set gas price (Legacy):", {
+                gasPrice: `${gasPriceGwei.toFixed(6)} Gwei`,
+                gasPriceWei: gasPrice.toString()
+              });
+            }
+          } catch (err) {
+            console.warn("\u26A0\uFE0F [MetaMask writeContract] Failed to estimate gas fees, letting viem auto-estimate:", err);
+          }
+        }
+      }
+      const txHash = await this.walletClient.writeContract(txOptions);
       return txHash;
     } catch (error) {
       if (error.code === 4001) {
@@ -957,16 +1001,57 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
     await this.ensureAvailable();
     try {
       this.setState("connecting" /* CONNECTING */);
+      const w = window;
       const tronWeb = this.getTronWeb();
-      const result = await tronWeb.request({
-        method: "tron_requestAccounts"
-      });
-      if (!result || !result.code || result.code !== 200) {
-        throw new ConnectionRejectedError(this.type);
+      if (tronWeb.ready) {
+        await tronWeb.ready;
+      }
+      let address = tronWeb.defaultAddress?.base58;
+      if (!address && tronWeb.defaultAddress?.hex && tronWeb.address && typeof tronWeb.address.fromHex === "function") {
+        try {
+          address = tronWeb.address.fromHex(tronWeb.defaultAddress.hex);
+        } catch (e) {
+        }
       }
-      const address = tronWeb.defaultAddress?.base58;
       if (!address) {
-        throw new Error("Failed to get Tron address");
+        for (let i = 0; i < 20; i++) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          address = tronWeb.defaultAddress?.base58;
+          if (address) break;
+        }
+      }
+      if (!address) {
+        if (w.tronLink && typeof w.tronLink.request === "function") {
+          try {
+            const result = await w.tronLink.request({
+              method: "tron_requestAccounts"
+            });
+            if (!result || result.code !== 200) {
+              throw new ConnectionRejectedError(this.type);
+            }
+          } catch (error) {
+            if (error.code === 4001 || error.message?.includes("User rejected") || error.message?.includes("rejected")) {
+              throw new ConnectionRejectedError(this.type);
+            }
+          }
+        }
+        address = tronWeb.defaultAddress?.base58;
+        if (!address && tronWeb.defaultAddress?.hex && tronWeb.address && typeof tronWeb.address.fromHex === "function") {
+          try {
+            address = tronWeb.address.fromHex(tronWeb.defaultAddress.hex);
+          } catch (e) {
+          }
+        }
+        if (!address) {
+          for (let i = 0; i < 20; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            address = tronWeb.defaultAddress?.base58;
+            if (address) break;
+          }
+        }
+      }
+      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 account = {
@@ -1042,17 +1127,41 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
   }
   /**
    * 读取合约
+   * 参考 webserver 的实现，使用 TronWeb 合约实例的标准 call() 方法
    */
   async readContract(params) {
     this.ensureConnected();
     try {
       const tronWeb = this.getTronWeb();
-      const contract = await tronWeb.contract(params.abi, params.address);
-      const result = await contract[params.functionName](...params.args || []).call();
-      return result;
+      if (!this.currentAccount) {
+        throw new Error("No account connected");
+      }
+      try {
+        const contract = await tronWeb.contract(params.abi, params.address);
+        const method = contract[params.functionName];
+        if (!method || typeof method !== "function") {
+          throw new Error(`Function ${params.functionName} not found in contract ABI`);
+        }
+        const result = await method(...params.args || []).call();
+        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;
+        }
+      }
     } catch (error) {
       console.error("Read contract error:", error);
-      throw new Error(`Failed to read contract: ${error.message}`);
+      throw new Error(`Failed to read contract: ${error.message || "Unknown error"}`);
     }
   }
   /**
@@ -1097,26 +1206,38 @@ var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
       }));
       console.log("[TronLink] Transaction options:", options);
       console.log("[TronLink] Parameters:", parameter);
-      const transaction = await tronWeb.transactionBuilder.triggerSmartContract(
+      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,
-        params.functionName + "(" + functionAbi.inputs.map((i) => i.type).join(",") + ")",
+        functionSelector,
         options,
         parameter,
         this.currentAccount.nativeAddress
       );
-      console.log("[TronLink] Transaction built:", transaction);
-      if (!transaction || !transaction.transaction) {
+      console.log("[TronLink] Transaction built:", tx);
+      if (!tx || !tx.transaction) {
         throw new Error("Failed to build transaction");
       }
-      const signedTx = await tronWeb.trx.sign(transaction.transaction);
+      console.log("[TronLink] Requesting user signature...");
+      const signedTx = await tronWeb.trx.sign(tx.transaction);
+      console.log("[TronLink] Transaction signed:", signedTx);
+      const txID = signedTx.txID;
+      console.log("[TronLink] Transaction hash (txID):", txID);
+      console.log("[TronLink] Broadcasting transaction...");
       const broadcast = await tronWeb.trx.sendRawTransaction(signedTx);
       console.log("[TronLink] Broadcast result:", broadcast);
-      if (!broadcast.result) {
-        throw new Error(broadcast.message || "Transaction broadcast failed");
+      if (broadcast && broadcast.result === true) {
+        return txID || broadcast.txid || "";
+      } else {
+        if (txID) {
+          console.warn("[TronLink] Broadcast returned false but txID exists:", txID);
+          return txID;
+        }
+        throw new Error(broadcast?.message || "Transaction broadcast failed");
       }
-      const txHash = broadcast.txid || broadcast.transaction?.txID;
-      console.log("[TronLink] Transaction hash:", txHash);
-      return txHash || "";
     } catch (error) {
       console.error("Write contract error:", error);
       if (error.message?.includes("User rejected") || error.message?.includes("Confirmation declined")) {