@rash2x/bridge-widget 0.6.92 → 0.6.93

package/dist/{index-j6yDeMSt.js → index-BDIi-D7p.js}

@@ -5305,6 +5305,15 @@ class EvmChainStrategy {
       throw toChainStrategyError(error, "evm", "transaction");
     }
   }
+  async getNextNonce() {
+    if (!this.publicClient || !this.config.evmAddress) {
+      throw new WalletNotConnectedError("evm");
+    }
+    return await this.publicClient.getTransactionCount({
+      address: this.config.evmAddress,
+      blockTag: "pending"
+    });
+  }
   async executeTransaction(step) {
     const walletClient = this.walletClient;
     if (!walletClient) {
@@ -5317,12 +5326,14 @@ class EvmChainStrategy {
       );
     }
     const tx = step.transaction;
+    const nonce = await this.getNextNonce();
     const hash = await walletClient.sendTransaction({
       to: tx.to,
       data: tx.data,
       account: tx.from || this.config.evmAddress,
       value: tx.value ? BigInt(tx.value) : void 0,
-      chain: walletClient.chain
+      chain: walletClient.chain,
+      nonce
     });
     return hash;
   }
@@ -5364,13 +5375,15 @@ class EvmChainStrategy {
       });
       if (currentAllowance > 0n) {
         try {
+          const resetNonce = await this.getNextNonce();
           const resetHash = await walletClient.writeContract({
             address: tokenAddress,
             abi: ERC20_ABI,
             functionName: "approve",
             args: [spenderAddress, 0n],
             account: this.config.evmAddress,
-            chain: walletClient.chain
+            chain: walletClient.chain,
+            nonce: resetNonce
           });
           await publicClient.waitForTransactionReceipt({
             hash: resetHash
@@ -5387,13 +5400,15 @@ class EvmChainStrategy {
         console.log("USDT allowance is 0, no reset needed");
       }
       try {
+        const approveNonce = await this.getNextNonce();
         const approveHash = await walletClient.writeContract({
           address: tokenAddress,
           abi: ERC20_ABI,
           functionName: "approve",
           args: [spenderAddress, amount],
           account: this.config.evmAddress,
-          chain: walletClient.chain
+          chain: walletClient.chain,
+          nonce: approveNonce
         });
         return approveHash;
       } catch (approveError) {
@@ -6258,6 +6273,13 @@ class TronChainStrategy {
     } else {
       signedTx = await tronWeb.trx.sign(unsignedTx);
     }
+    const signatures = signedTx.signature;
+    if (!Array.isArray(signatures) || signatures.length === 0) {
+      throw new TransactionFailedError(
+        "tron",
+        "Wallet returned unsigned transaction"
+      );
+    }
     const sent = await tronWeb.trx.sendRawTransaction(signedTx);
     if (!sent?.result || !sent?.txid) {
       throw new TransactionFailedError(
@@ -25760,7 +25782,7 @@ class WalletConnectModal {
   }
   async initUi() {
     if (typeof window !== "undefined") {
-      await import("./index--FWEmzfG.js");
+      await import("./index-Ba3TMYQR.js");
       const modal = document.createElement("wcm-modal");
       document.body.insertAdjacentElement("beforeend", modal);
       OptionsCtrl.setIsUiLoaded(true);
@@ -25806,6 +25828,59 @@ const useThemeStore = create((set2) => ({
 }));
 const TRON_MAINNET_CHAIN_ID = "tron:0x2b6653dc";
 const CONNECTION_TIMEOUT = 6e4;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasValidSignature(transaction2) {
+  if (!isRecord(transaction2)) return false;
+  const signature = transaction2.signature;
+  return Array.isArray(signature) && signature.length > 0 && signature.every((item) => typeof item === "string" && item.length > 0);
+}
+function normalizeSignature(signature) {
+  return signature.replace(/^0x/i, "");
+}
+function toSignedTransaction(result, unsignedTx) {
+  if (hasValidSignature(result)) {
+    return result;
+  }
+  if (isRecord(result)) {
+    const nestedTx = result.transaction;
+    if (hasValidSignature(nestedTx)) {
+      return nestedTx;
+    }
+    const nestedSignedTx = result.signedTransaction;
+    if (hasValidSignature(nestedSignedTx)) {
+      return nestedSignedTx;
+    }
+    const signature = result.signature;
+    if (typeof signature === "string" && signature.length > 0) {
+      return {
+        ...unsignedTx,
+        signature: [normalizeSignature(signature)]
+      };
+    }
+    if (Array.isArray(signature) && signature.length > 0 && signature.every((item) => typeof item === "string" && item.length > 0)) {
+      return {
+        ...unsignedTx,
+        signature: signature.map((item) => normalizeSignature(item))
+      };
+    }
+  }
+  if (typeof result === "string" && result.length > 0) {
+    return {
+      ...unsignedTx,
+      signature: [normalizeSignature(result)]
+    };
+  }
+  return null;
+}
+function isUserRejectedError(error) {
+  if (isRecord(error) && typeof error.code === "number" && error.code === 4001) {
+    return true;
+  }
+  const msg = error instanceof Error ? error.message.toLowerCase() : "";
+  return msg.includes("user rejected") || msg.includes("rejected by user");
+}
 function useTronWalletConnect(projectId) {
   const { address, isConnected, isConnecting } = useTronWalletConnectStore();
   const { setAddress, setActions, reset } = useTronWalletConnectStore();
@@ -25986,11 +26061,41 @@ function useTronWalletConnect(projectId) {
         throw new Error("WalletConnect not connected");
       }
       try {
-        const result = await providerRef.current.request({
-          method: "tron_signTransaction",
-          params: [transaction2]
-        });
-        return result;
+        const requestVariants = [
+          [transaction2],
+          [transaction2, address],
+          [{ transaction: transaction2, address }],
+          { transaction: transaction2, address }
+        ];
+        let lastResponse;
+        let lastError;
+        for (const params of requestVariants) {
+          try {
+            const result = await providerRef.current.request(
+              {
+                method: "tron_signTransaction",
+                params
+              },
+              TRON_MAINNET_CHAIN_ID
+            );
+            lastResponse = result;
+            const signedTx = toSignedTransaction(result, transaction2);
+            if (signedTx) {
+              return signedTx;
+            }
+          } catch (error) {
+            if (isUserRejectedError(error)) {
+              throw error;
+            }
+            lastError = error;
+          }
+        }
+        if (lastError) {
+          throw lastError;
+        }
+        throw new Error(
+          `WalletConnect returned unsigned transaction: ${JSON.stringify(lastResponse)}`
+        );
       } catch (error) {
         console.error("TRON WalletConnect transaction signing failed:", error);
         throw error;
@@ -26516,4 +26621,4 @@ export {
   getQuoteFees as y,
   calculateMinReceived as z
 };
-//# sourceMappingURL=index-j6yDeMSt.js.map
+//# sourceMappingURL=index-BDIi-D7p.js.map