@weblock-wallet/sdk 0.1.59 → 0.1.61

package/dist/index.js

@@ -104550,7 +104550,15 @@ var WalletService = class {
       method: "eth_sendRawTransaction" /* ETH_SEND_RAW_TRANSACTION */,
       params: [signedTx]
     });
-    return response.result;
+    const txHash = response?.result;
+    if (!txHash || typeof txHash !== "string") {
+      throw new SDKError(
+        "RPC returned empty tx hash",
+        "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+        response
+      );
+    }
+    return txHash;
   }
   async getTransactionReceipt(txHash, chainId) {
     const response = await this.rpcClient.sendRpc({
@@ -104619,40 +104627,48 @@ var WalletService = class {
       if (!from) {
         throw new SDKError("Wallet not found", "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */);
       }
+      const toHexQuantity = (v5) => {
+        if (v5 === void 0 || v5 === null) return "0x0";
+        const s5 = String(v5).trim();
+        if (!s5) return "0x0";
+        if (s5.startsWith("0x") || s5.startsWith("0X")) return s5;
+        try {
+          const bi = BigInt(s5);
+          return "0x" + bi.toString(16);
+        } catch {
+          return s5;
+        }
+      };
       const walletInfo = await this.walletClient.getWallet();
       const share1 = walletInfo?.share1;
       let share2 = await LocalForage.get(
         STORAGE_KEYS.share2(this.orgHost)
       );
       if (!share2) {
-        const [firebaseId, deviceSecret, encryptedShare2Device] = await Promise.all([
-          LocalForage.get(STORAGE_KEYS.firebaseId(this.orgHost)),
-          LocalForage.get(STORAGE_KEYS.deviceSecret(this.orgHost)),
-          LocalForage.get(
+        try {
+          const firebaseId = await LocalForage.get(
+            STORAGE_KEYS.firebaseId(this.orgHost)
+          );
+          const encryptedDevice = await LocalForage.get(
             STORAGE_KEYS.encryptedShare2Device(this.orgHost)
-          )
-        ]);
-        if (firebaseId && deviceSecret && encryptedShare2Device) {
-          try {
-            console.debug(
-              "[WalletService] recovering share2 from encryptedShare2_device"
-            );
+          );
+          const deviceSecret = await LocalForage.get(
+            STORAGE_KEYS.deviceSecret(this.orgHost)
+          );
+          if (firebaseId && encryptedDevice && deviceSecret) {
             share2 = Crypto.decryptShare(
-              encryptedShare2Device,
+              encryptedDevice,
               deviceSecret,
               firebaseId
             );
-          } catch (e7) {
-            console.warn(
-              "[WalletService] failed to decrypt encryptedShare2_device",
-              e7
-            );
+            await LocalForage.save(STORAGE_KEYS.share2(this.orgHost), share2);
           }
+        } catch {
         }
       }
       if (!share1 || !share2) {
         throw new SDKError(
-          "Wallet shares not found. Please unlock the wallet by calling retrieveWallet(PIN) once on this device.",
+          "Wallet shares not found",
           "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */
         );
       }
@@ -104660,19 +104676,48 @@ var WalletService = class {
       const wallet = new Wallet(privateKey);
       const nonce = params.nonce ?? await this.getTransactionCount(from, params.chainId);
       const gasPrice = params.gasPrice ?? await this.getGasPrice(params.chainId);
+      let gasLimit = params.gasLimit;
+      if (!gasLimit) {
+        try {
+          const est = await this.estimateGas(
+            {
+              from,
+              to: params.to,
+              value: toHexQuantity(params.value),
+              data: params.data || "0x"
+            },
+            params.chainId
+          );
+          const buffered = Math.max(21e3, Math.ceil(est * 1.2));
+          gasLimit = "0x" + buffered.toString(16);
+        } catch (e7) {
+          const data = (params.data || "0x").toLowerCase();
+          const isApprove = data.startsWith("0x095ea7b3");
+          const fallback = isApprove ? 12e4 : data !== "0x" ? 8e5 : 21e3;
+          gasLimit = "0x" + fallback.toString(16);
+        }
+      }
+      const value = params.value ?? "0";
       const signedTx = await wallet.signTransaction({
         to: params.to,
-        value: params.value,
+        value,
         data: params.data || "0x",
         chainId: params.chainId,
         nonce,
         gasPrice,
-        gasLimit: params.gasLimit
+        gasLimit
       });
-      return this.sendRawTransaction(signedTx, params.chainId);
+      const txHash = await this.sendRawTransaction(signedTx, params.chainId);
+      await LocalForage.delete(STORAGE_KEYS.share2(this.orgHost));
+      return txHash;
     } catch (error) {
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      const anyErr = error;
+      const causeMsg = anyErr?.shortMessage || anyErr?.reason || anyErr?.message || anyErr?.error?.message || "Unknown error";
       throw new SDKError(
-        "Transaction failed",
+        `Transaction failed: ${causeMsg}`,
         "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
         error
       );
@@ -105147,9 +105192,19 @@ var RpcClient = class {
       method: request.method,
       params: request.params
     };
-    return this.client.post(this.baseUrl, rpcRequest, {
-      needsAccessToken: true
-    });
+    const res = await this.client.post(
+      this.baseUrl,
+      rpcRequest,
+      {
+        needsAccessToken: true
+      }
+    );
+    if (res?.error) {
+      const err = res.error;
+      const msg = err?.message || "RPC error";
+      throw new SDKError(msg, "REQUEST_FAILED" /* REQUEST_FAILED */, err);
+    }
+    return res;
   }
 };