@getpara/web-sdk 2.0.0-alpha.7 → 2.0.0-alpha.70

package/dist/workers/walletUtils.js

@@ -1,8 +1,9 @@
 "use client";
 import {
   __async
-} from "../chunk-M66XENHI.js";
+} from "../chunk-YJOFEY2L.js";
 import { getBaseMPCNetworkUrl } from "@getpara/core-sdk";
+import * as uuid from "uuid";
 const configCGGMPBase = (serverUrl, walletId, id) => `{"ServerUrl":"${serverUrl}", "WalletId": "${walletId}", "Id":"${id}", "Ids":["USER","CAPSULE"], "Threshold":1}`;
 const configDKLSBase = (walletId, id, disableWebSockets) => `{"walletId": "${walletId}", "id":"${id}", "otherId":"CAPSULE", "isReceiver": false, "disableWebSockets": ${disableWebSockets}}`;
 function keygenRequest(ctx, userId, walletId, protocolId) {
@@ -86,20 +87,30 @@ function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
 }
 function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
   return __async(this, null, function* () {
-    const { protocolId } = yield ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519");
-    try {
-      const base64Sig = yield new Promise(
-        (resolve, reject) => globalThis.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-      return { signature: base64Sig };
-    } catch (e) {
-      throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+    const protocolId = uuid.v4();
+    const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519", void 0, protocolId);
+    const signRes = function() {
+      return __async(this, null, function* () {
+        try {
+          const base64Sig = yield new Promise(
+            (resolve, reject) => globalThis.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve(result);
+            })
+          );
+          return { signature: base64Sig };
+        } catch (e) {
+          throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const { pendingTransactionId } = yield preSignMessageRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signRes;
   });
 }
 function keygen(ctx, userId, type, secretKey) {
@@ -179,16 +190,8 @@ function preKeygen(ctx, _partnerId, pregenIdentifier, pregenIdentifierType, type
 }
 function signMessage(ctx, share, walletId, userId, message, cosmosSignDoc) {
   return __async(this, null, function* () {
-    const { protocolId, pendingTransactionId } = yield ctx.client.preSignMessage(
-      userId,
-      walletId,
-      message,
-      null,
-      cosmosSignDoc
-    );
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, message, null, cosmosSignDoc, protocolId);
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return signMessageRequest(ctx, userId, walletId, protocolId, message, share);
     }
@@ -199,28 +202,33 @@ function signMessage(ctx, share, walletId, userId, message, cosmosSignDoc) {
       parsedShare.disableWebSockets = ctx.disableWebSockets;
     }
     share = JSON.stringify(parsedShare);
-    try {
-      return yield new Promise(
-        (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+    const signMessageRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const { pendingTransactionId } = yield preSignMessageRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signMessageRes;
   });
 }
 function signTransaction(ctx, share, walletId, userId, tx, chainId) {
   return __async(this, null, function* () {
-    const {
-      data: { protocolId, pendingTransactionId }
-    } = yield ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId });
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const signTransactionRes = ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
     }
@@ -231,28 +239,35 @@ function signTransaction(ctx, share, walletId, userId, tx, chainId) {
       parsedShare.disableWebSockets = ctx.disableWebSockets;
     }
     share = JSON.stringify(parsedShare);
-    try {
-      return yield new Promise(
-        (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+    const signTxRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const {
+      data: { pendingTransactionId }
+    } = yield signTransactionRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signTxRes;
   });
 }
 function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
   return __async(this, null, function* () {
-    const {
-      data: { protocolId, pendingTransactionId }
-    } = yield ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId });
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const sendTransactionRes = ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
     }
@@ -263,18 +278,29 @@ function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
       parsedShare.disableWebSockets = ctx.disableWebSockets;
     }
     share = JSON.stringify(parsedShare);
-    try {
-      return yield new Promise(
-        (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+    const sendTxRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const {
+      data: { pendingTransactionId }
+    } = yield sendTransactionRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield sendTxRes;
   });
 }
 function refresh(ctx, share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId) {

package/dist/workers/worker.d.ts

@@ -1,4 +1,3 @@
-import '../wasm/wasm_exec.js';
 import { Environment } from '@getpara/core-sdk';
 export interface Message {
     env: Environment;
@@ -13,7 +12,16 @@ export interface Message {
     disableWebSockets?: boolean;
     wasmOverride?: ArrayBuffer;
     returnObject?: boolean;
+    workId?: string;
 }
+/**
+ * Executes an operation with retry capabilities
+ * @param operation The function to execute
+ * @param maxRetries Maximum number of retries (default: 2)
+ * @param timeoutMs Timeout in milliseconds (default: 10000)
+ * @returns The result of the operation
+ */
+export declare function withRetry<T>(operation: () => Promise<T>, maxRetries?: number, timeoutMs?: number): Promise<T>;
 export declare function handleMessage(e: {
     data: Message;
 }, postMessage: (message: any) => void, useFetchAdapter?: boolean): Promise<boolean>;

package/dist/workers/worker.js

@@ -19,22 +19,40 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-import "../wasm/wasm_exec.js";
 import * as walletUtils from "./walletUtils.js";
-import { getPortalBaseURL, initClient, mpcComputationClient, paraVersion } from "@getpara/core-sdk";
+import {
+  getBaseMPCNetworkUrl,
+  getPortalBaseURL,
+  initClient,
+  mpcComputationClient,
+  paraVersion
+} from "@getpara/core-sdk";
+let wasmLoaded = false;
+function tryFetchWasm(url) {
+  return __async(this, null, function* () {
+    const response = yield fetch(url, { mode: "cors" });
+    const buffer = yield response.arrayBuffer();
+    const view = new Uint8Array(buffer);
+    if (view.length >= 4 && view[0] === 0 && view[1] === 97 && view[2] === 115 && view[3] === 109) {
+      return buffer;
+    }
+    throw new Error("invalid WASM magic bytes - possibly compressed data without proper Content-Encoding");
+  });
+}
 function loadWasm(ctx, wasmOverride) {
   return __async(this, null, function* () {
     if (typeof self === "undefined") {
       return;
     }
+    yield import("../wasm/wasm_exec.js");
     const goWasm = new self.Go();
     let wasmArrayBuffer = wasmOverride;
     if (!wasmArrayBuffer) {
       if (process.env.DISABLE_WASM_FETCH === "true") {
         throw new Error("fetching wasm file is disabled");
       }
-      const fetchedWasm = yield fetch(`${getPortalBaseURL(ctx)}/static/js/main.wasm`, { mode: "cors" });
-      wasmArrayBuffer = yield fetchedWasm.arrayBuffer();
+      const wasmUrl = `${getPortalBaseURL(ctx)}/static/js/main.wasm`;
+      wasmArrayBuffer = yield tryFetchWasm(`${wasmUrl}.br`).catch(() => tryFetchWasm(`${wasmUrl}.gz`)).catch(() => tryFetchWasm(wasmUrl));
     }
     const newRes = yield WebAssembly.instantiate(wasmArrayBuffer, goWasm.importObject);
     goWasm.run(newRes.instance);
@@ -44,6 +62,9 @@ function executeMessage(ctx, message) {
   return __async(this, null, function* () {
     const { functionType, params, returnObject } = message;
     switch (functionType) {
+      case "INIT": {
+        return {};
+      }
       case "KEYGEN": {
         const { userId, secretKey, type = "EVM" } = params;
         const keygenRes = yield walletUtils.keygen(ctx, userId, type, secretKey);
@@ -51,15 +72,15 @@ function executeMessage(ctx, message) {
       }
       case "SIGN_TRANSACTION": {
         const { share, walletId, userId, tx, chainId } = params;
-        return walletUtils.signTransaction(ctx, share, walletId, userId, tx, chainId);
+        return withRetry(() => walletUtils.signTransaction(ctx, share, walletId, userId, tx, chainId));
       }
       case "SEND_TRANSACTION": {
         const { share, walletId, userId, tx, chainId } = params;
-        return walletUtils.sendTransaction(ctx, share, walletId, userId, tx, chainId);
+        return withRetry(() => walletUtils.sendTransaction(ctx, share, walletId, userId, tx, chainId));
       }
       case "SIGN_MESSAGE": {
         const { share, walletId, userId, message: message2, cosmosSignDoc } = params;
-        return walletUtils.signMessage(ctx, share, walletId, userId, message2, cosmosSignDoc);
+        return withRetry(() => walletUtils.signMessage(ctx, share, walletId, userId, message2, cosmosSignDoc));
       }
       case "REFRESH": {
         const { share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId } = params;
@@ -86,7 +107,8 @@ function executeMessage(ctx, message) {
       }
       case "GET_PRIVATE_KEY": {
         const { share, walletId, userId } = params;
-        return yield walletUtils.getPrivateKey(ctx, share, walletId, userId);
+        const privateKey = yield walletUtils.getPrivateKey(ctx, share, walletId, userId);
+        return { privateKey };
       }
       case "ED25519_KEYGEN": {
         const { userId } = params;
@@ -94,7 +116,7 @@ function executeMessage(ctx, message) {
       }
       case "ED25519_SIGN": {
         const { share, walletId, userId, base64Bytes } = params;
-        return walletUtils.ed25519Sign(ctx, share, userId, walletId, base64Bytes);
+        return withRetry(() => walletUtils.ed25519Sign(ctx, share, userId, walletId, base64Bytes));
       }
       case "ED25519_PREKEYGEN": {
         const { email } = params;
@@ -111,6 +133,29 @@ function executeMessage(ctx, message) {
     }
   });
 }
+function withRetry(operation, maxRetries = 2, timeoutMs = 1e4) {
+  return __async(this, null, function* () {
+    let retries = 0;
+    while (true) {
+      try {
+        const operationPromise = operation();
+        const timeoutPromise = new Promise((_, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          operationPromise.finally(() => clearTimeout(timeoutId));
+        });
+        return yield Promise.race([operationPromise, timeoutPromise]);
+      } catch (error) {
+        retries++;
+        if (retries > maxRetries) {
+          throw error;
+        }
+        console.warn(`Operation failed (attempt ${retries}/${maxRetries}), retrying...`, error);
+      }
+    }
+  });
+}
 function handleMessage(e, postMessage, useFetchAdapter) {
   return __async(this, null, function* () {
     const {
@@ -122,7 +167,8 @@ function handleMessage(e, postMessage, useFetchAdapter) {
       sessionCookie,
       useDKLS,
       disableWebSockets,
-      wasmOverride
+      wasmOverride,
+      workId
     } = e.data;
     if (!env) {
       return true;
@@ -144,14 +190,33 @@ function handleMessage(e, postMessage, useFetchAdapter) {
       disableWebSockets: !!disableWebSockets,
       wasmOverride
     };
-    if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+    if (!wasmLoaded && (!ctx.offloadMPCComputationURL || ctx.useDKLS)) {
       yield loadWasm(ctx, wasmOverride);
+      const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+      if (globalThis.initWasm) {
+        yield new Promise(
+          (resolve, reject) => {
+            var _a;
+            return (_a = globalThis.initWasm) == null ? void 0 : _a.call(globalThis, (err, result2) => {
+              if (err) {
+                reject(err);
+              }
+              resolve(result2);
+            }, serverUrl);
+          }
+        );
+      }
+      wasmLoaded = true;
     }
     const result = yield executeMessage(ctx, e.data);
+    if (workId) {
+      result.workId = workId;
+    }
     postMessage(result);
-    return false;
+    return !!workId;
   });
 }
 export {
-  handleMessage
+  handleMessage,
+  withRetry
 };

package/dist/workers/workerWrapper.d.ts

@@ -3,4 +3,4 @@ export interface SyncWorker {
     postMessage: (message: any) => void;
     terminate: () => void;
 }
-export declare function setupWorker(ctx: Ctx, resFunction: (arg: any) => void): Promise<Worker | SyncWorker>;
+export declare function setupWorker(ctx: Ctx, resFunction: (arg: any) => Promise<void>, errorFunction: (err: Error) => void, workId: string, errorContext?: object): Promise<Worker | SyncWorker>;

package/dist/workers/workerWrapper.js

@@ -1,23 +1,35 @@
 "use client";
 import {
   __async
-} from "../chunk-M66XENHI.js";
+} from "../chunk-YJOFEY2L.js";
 import { getPortalBaseURL } from "@getpara/core-sdk";
 import { handleMessage } from "./worker.js";
-function setupWorker(ctx, resFunction) {
+const CLEAR_WORKER_TIMEOUT_MS = 1e3 * 90;
+let workerInstance;
+const resFunctionMap = {};
+function removeWorkId(workId, skipClearTimeout) {
+  const { timeoutId } = resFunctionMap[workId];
+  delete resFunctionMap[workId];
+  if (skipClearTimeout) {
+    return;
+  }
+  clearTimeout(timeoutId);
+}
+function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
   return __async(this, null, function* () {
-    const onmessage = (event) => {
-      if (event.data.functionType === "CUSTOM") {
-        return;
-      }
-      resFunction(event.data);
-    };
     if (ctx.disableWorkers) {
       const syncWorker = {
         postMessage: function(message) {
           (function() {
             return __async(this, null, function* () {
-              yield handleMessage({ data: message }, (data) => onmessage({ data }), ctx.disableWorkers);
+              try {
+                const onmessage = (event) => {
+                  resFunction(event.data);
+                };
+                yield handleMessage({ data: message }, (data) => onmessage({ data }), ctx.disableWorkers);
+              } catch (error) {
+                errorFunction(error);
+              }
             });
           })();
         },
@@ -27,17 +39,45 @@ function setupWorker(ctx, resFunction) {
       };
       return syncWorker;
     }
-    let worker;
+    const timeoutId = setTimeout(() => {
+      removeWorkId(workId, true);
+    }, CLEAR_WORKER_TIMEOUT_MS);
+    resFunctionMap[workId] = {
+      fn: resFunction,
+      timeoutId,
+      errorFn: errorFunction,
+      errorContext: errorContext || {}
+    };
     if (ctx.useLocalFiles) {
       throw new Error("useLocalFiles only supported locally");
-    } else {
+    } else if (!workerInstance) {
       const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/mpcWorker-bundle.js`);
       const workerBlob = new Blob([yield workerRes.text()], { type: "application/javascript" });
       const workerScriptURL = URL.createObjectURL(workerBlob);
-      worker = new Worker(workerScriptURL);
+      workerInstance = new Worker(workerScriptURL);
+      const onmessage = (event) => __async(this, null, function* () {
+        const { workId: messageWorkId } = event.data;
+        delete event.data.workId;
+        if (messageWorkId && resFunctionMap[messageWorkId]) {
+          yield resFunctionMap[messageWorkId].fn(event.data);
+          removeWorkId(messageWorkId);
+        }
+      });
+      workerInstance.onmessage = onmessage;
+      workerInstance.onerror = (err) => {
+        console.error("worker error:", err);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            const errorMsg = `worker error with workId ${id} and opts ${JSON.stringify(resFunctionMap[id].errorContext)}: ${err.message}`;
+            resFunctionMap[id].errorFn(new Error(errorMsg));
+            removeWorkId(id);
+          }
+        });
+        workerInstance == null ? void 0 : workerInstance.terminate();
+        workerInstance = void 0;
+      };
     }
-    worker.onmessage = onmessage;
-    return worker;
+    return workerInstance;
   });
 }
 export {

package/package.json

@@ -1,40 +1,45 @@
 {
   "name": "@getpara/web-sdk",
-  "version": "2.0.0-alpha.7",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "sideEffects": [
-    "wasm_exec.js"
-  ],
+  "version": "2.0.0-alpha.70",
   "dependencies": {
-    "@getpara/core-sdk": "2.0.0-alpha.7",
-    "@getpara/user-management-client": "2.0.0-alpha.7",
-    "@sentry/browser": "^9.1.0",
-    "base64url": "3.0.1",
+    "@getpara/core-sdk": "2.0.0-alpha.70",
+    "@getpara/user-management-client": "2.0.0-alpha.70",
+    "base64url": "^3.0.1",
     "buffer": "6.0.3",
-    "cbor-web": "8.1.0",
+    "cbor-web": "^9.0.2",
     "node-forge": "1.3.1",
     "ua-parser-js": "^2.0.2"
   },
-  "scripts": {
-    "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs && yarn post-build",
-    "typegen": "tsc --emitDeclarationOnly",
-    "old-build": "rm -rf dist && tsc && yarn post-build",
-    "post-build": "./scripts/post-build.sh",
-    "test": "vitest run --coverage"
-  },
   "devDependencies": {
     "@types/node-forge": "1.3.1",
-    "crypto-browserify": "3.12.0",
-    "stream-browserify": "3.0.0",
-    "typescript": "5.1.6",
-    "webpack": "5.76.3",
-    "webpack-cli": "5.0.1"
+    "crypto-browserify": "^3.12.0",
+    "stream-browserify": "^3.0.0",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "@farcaster/miniapp-sdk": "^0.1.2"
+  },
+  "peerDependenciesMeta": {
+    "@farcaster/miniapp-sdk": {
+      "optional": true
+    }
   },
   "files": [
     "dist",
     "package.json"
   ],
-  "gitHead": "0a6b297b70c7f9b7b93381944e3f5314252ad6a5"
+  "gitHead": "99d44cff3c68c07dc1cd8c2709b6ca4cd57dca61",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs && yarn post-build",
+    "old-build": "rm -rf dist && tsc && yarn post-build",
+    "post-build": "./scripts/post-build.sh",
+    "test": "vitest run --coverage",
+    "typegen": "tsc --emitDeclarationOnly"
+  },
+  "sideEffects": [
+    "wasm_exec.js"
+  ],
+  "type": "module",
+  "types": "dist/index.d.ts"
 }

package/dist/chunk-M66XENHI.js

@@ -1,25 +0,0 @@
-"use client";
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-export {
-  __async
-};