@getpara/server-sdk 1.11.0 → 1.13.0

package/dist/cjs/wallet/signing.js

@@ -57,109 +57,161 @@ var uuid = __toESM(require("uuid"));
 var import_workerWrapper = require("../workers/workerWrapper.js");
 function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (sendTransactionRes) => __async(this, null, function* () {
-          resolve(sendTransactionRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        cosmosPrefix: ctx.cosmosPrefix,
-        params: { share, walletId, userId, tx, chainId },
-        functionType: "SIGN_TRANSACTION",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (sendTransactionRes) => __async(this, null, function* () {
+            resolve(sendTransactionRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, tx, chainId },
+            functionType: "SIGN_TRANSACTION",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          cosmosPrefix: ctx.cosmosPrefix,
+          params: { share, walletId, userId, tx, chainId },
+          functionType: "SIGN_TRANSACTION",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (sendTransactionRes) => __async(this, null, function* () {
-          resolve(sendTransactionRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, tx, chainId },
-        functionType: "SEND_TRANSACTION",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (sendTransactionRes) => __async(this, null, function* () {
+            resolve(sendTransactionRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, tx, chainId },
+            functionType: "SEND_TRANSACTION",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, tx, chainId },
+          functionType: "SEND_TRANSACTION",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (signMessageRes) => __async(this, null, function* () {
-          resolve(signMessageRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, message },
-        functionType: "SIGN_MESSAGE",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (signMessageRes) => __async(this, null, function* () {
+            resolve(signMessageRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, message },
+            functionType: "SIGN_MESSAGE",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, message },
+          functionType: "SIGN_MESSAGE",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (signMessageRes) => __async(this, null, function* () {
-          resolve(signMessageRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, base64Bytes },
-        functionType: "ED25519_SIGN",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (signMessageRes) => __async(this, null, function* () {
+            resolve(signMessageRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, base64Bytes },
+            functionType: "ED25519_SIGN",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, base64Bytes },
+          functionType: "ED25519_SIGN",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }

package/dist/cjs/workers/workerWrapper.js

@@ -53,30 +53,62 @@ function removeWorkId(workId, skipClearTimeout) {
   }
   clearTimeout(timeoutId);
 }
-function setupWorker(ctx, resFunction, workId) {
+function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
   return __async(this, null, function* () {
     const timeoutId = setTimeout(() => {
-      removeWorkId(workId, true);
+      if (resFunctionMap[workId]) {
+        const errorMsg = `worker operation timed out after ${CLEAR_WORKER_TIMEOUT_MS}ms for workId ${workId} and opts ${JSON.stringify(resFunctionMap[workId].errorContext)}`;
+        resFunctionMap[workId].errorFn(new Error(errorMsg));
+        removeWorkId(workId, true);
+      }
     }, CLEAR_WORKER_TIMEOUT_MS);
     resFunctionMap[workId] = {
       fn: resFunction,
-      timeoutId
+      errorFn: errorFunction,
+      timeoutId,
+      errorContext
     };
     if (!worker || !worker.threadId) {
       const workerRes = yield fetch(`${(0, import_core_sdk.getPortalBaseURL)(ctx)}/static/js/mpcWorkerServer-bundle.js`);
       worker = new import_worker_threads.Worker(yield workerRes.text(), { eval: true });
       const onmessage = (message) => __async(this, null, function* () {
         const { workId: messageWorkId } = message;
+        if (!resFunctionMap[messageWorkId]) {
+          console.warn(`received message for unknown workId: ${messageWorkId}`);
+          return;
+        }
         delete message.workId;
-        yield resFunctionMap[messageWorkId].fn(message);
-        removeWorkId(messageWorkId);
+        try {
+          yield resFunctionMap[messageWorkId].fn(message);
+          removeWorkId(messageWorkId);
+        } catch (error) {
+          console.error(`error in worker message handler for workId ${messageWorkId}:`, error);
+          if (resFunctionMap[messageWorkId]) {
+            resFunctionMap[messageWorkId].errorFn(error);
+            removeWorkId(messageWorkId);
+          }
+        }
       });
       worker.on("message", onmessage);
       worker.on("error", (err) => {
-        throw 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);
+          }
+        });
       });
       worker.on("exit", (code) => {
         console.error(`worker stopped with exit code ${code}`);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            resFunctionMap[id].errorFn(new Error(`worker exited unexpectedly with code ${code}`));
+            removeWorkId(id);
+          }
+        });
+        worker = void 0;
       });
     }
     return worker;

package/dist/esm/ParaServer.js

@@ -1,16 +1,9 @@
 import "./chunk-FTA5RKYX.js";
-import ParaCore, { Environment } from "@getpara/core-sdk";
-import * as Sentry from "@sentry/node";
+import ParaCore from "@getpara/core-sdk";
 import { ServerUtils } from "./ServerUtils.js";
 class Para extends ParaCore {
   constructor(env, apiKey, opts) {
     super(env, apiKey, opts);
-    if (env !== Environment.PROD && env !== Environment.DEV) {
-      Sentry.init({
-        environment: env.toLowerCase(),
-        dsn: "https://2a26842d951255c2721fde5c1dd2b252@o4504568036720640.ingest.us.sentry.io/4508850906791936"
-      });
-    }
   }
   getPlatformUtils() {
     return new ServerUtils();

package/dist/esm/ServerUtils.js

@@ -6,6 +6,7 @@ import { signMessage, sendTransaction, signTransaction, ed25519Sign } from "./wa
 import { getPrivateKey } from "./wallet/privateKey.js";
 class ServerUtils {
   constructor() {
+    this.sdkType = "SERVER";
     this.localStorage = new ServerLocalStorage();
     this.sessionStorage = new ServerSessionStorage();
     this.secureStorage = void 0;

package/dist/esm/wallet/keygen.js

@@ -13,141 +13,211 @@ async function isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType,
   return !!wallet?.address;
 }
 function keygen(ctx, userId, type, secretKey, sessionCookie, _emailProps = {}) {
-  return new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (res) => {
-        await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
-        resolve({
-          signer: res.signer,
-          walletId: res.walletId,
-          recoveryShare: null
-        });
-      },
-      workId
-    );
-    worker.postMessage({
-      env: ctx.env,
-      apiKey: ctx.apiKey,
-      cosmosPrefix: ctx.cosmosPrefix,
-      params: { userId, secretKey, type },
-      functionType: "KEYGEN",
-      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-      disableWorkers: ctx.disableWorkers,
-      sessionCookie,
-      useDKLS: ctx.useDKLS,
-      disableWebSockets: ctx.disableWebSockets,
-      wasmOverride: ctx.wasmOverride,
-      workId
-    });
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (res) => {
+          try {
+            await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
+            resolve({
+              signer: res.signer,
+              walletId: res.walletId,
+              recoveryShare: null
+            });
+          } catch (error) {
+            reject(error);
+          }
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          userId,
+          type,
+          functionType: "KEYGEN",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { userId, secretKey, type },
+        functionType: "KEYGEN",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: ctx.useDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
   });
 }
 function preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, _skipDistribute = false, partnerId, sessionCookie) {
-  return new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (res) => {
-        await waitUntilTrue(
-          async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
-          15e3,
-          1e3
-        );
-        resolve({
-          signer: res.signer,
-          walletId: res.walletId,
-          recoveryShare: null
-        });
-      },
-      workId
-    );
-    const email = void 0;
-    const params = { pregenIdentifier, pregenIdentifierType, secretKey, partnerId, email, type };
-    if (pregenIdentifierType === "EMAIL") {
-      params.email = pregenIdentifier;
+    try {
+      const email = void 0;
+      const params = { pregenIdentifier, pregenIdentifierType, secretKey, partnerId, email, type };
+      if (pregenIdentifierType === "EMAIL") {
+        params.email = pregenIdentifier;
+      }
+      const worker = await setupWorker(
+        ctx,
+        async (res) => {
+          try {
+            await waitUntilTrue(
+              async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
+              15e3,
+              1e3
+            );
+            resolve({
+              signer: res.signer,
+              walletId: res.walletId,
+              recoveryShare: null
+            });
+          } catch (error) {
+            reject(error);
+          }
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          ...params,
+          secretKey: null,
+          functionType: "PREKEYGEN",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params,
+        functionType: "PREKEYGEN",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: ctx.useDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
     }
-    worker.postMessage({
-      env: ctx.env,
-      apiKey: ctx.apiKey,
-      cosmosPrefix: ctx.cosmosPrefix,
-      params,
-      functionType: "PREKEYGEN",
-      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-      disableWorkers: ctx.disableWorkers,
-      sessionCookie,
-      useDKLS: ctx.useDKLS,
-      disableWebSockets: ctx.disableWebSockets,
-      wasmOverride: ctx.wasmOverride,
-      workId
-    });
   });
 }
 function ed25519Keygen(ctx, userId, sessionCookie, _emailProps = {}) {
-  return new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (res) => {
-        await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
-        resolve({
-          signer: res.signer,
-          walletId: res.walletId,
-          recoveryShare: null
-        });
-      },
-      workId
-    );
-    worker.postMessage({
-      env: ctx.env,
-      apiKey: ctx.apiKey,
-      cosmosPrefix: ctx.cosmosPrefix,
-      params: { userId },
-      functionType: "ED25519_KEYGEN",
-      disableWorkers: ctx.disableWorkers,
-      sessionCookie,
-      disableWebSockets: ctx.disableWebSockets,
-      wasmOverride: ctx.wasmOverride,
-      workId
-    });
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (res) => {
+          try {
+            await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
+            resolve({
+              signer: res.signer,
+              walletId: res.walletId,
+              recoveryShare: null
+            });
+          } catch (error) {
+            reject(error);
+          }
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          userId,
+          functionType: "ED25519_KEYGEN",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { userId },
+        functionType: "ED25519_KEYGEN",
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
   });
 }
 function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
-  return new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (res) => {
-        await waitUntilTrue(
-          async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
-          15e3,
-          1e3
-        );
-        resolve({
-          signer: res.signer,
-          walletId: res.walletId,
-          recoveryShare: null
-        });
-      },
-      workId
-    );
-    const email = void 0;
-    const params = { pregenIdentifier, pregenIdentifierType, email };
-    if (pregenIdentifierType === "EMAIL") {
-      params.email = pregenIdentifier;
+    try {
+      const email = void 0;
+      const params = { pregenIdentifier, pregenIdentifierType, email };
+      if (pregenIdentifierType === "EMAIL") {
+        params.email = pregenIdentifier;
+      }
+      const worker = await setupWorker(
+        ctx,
+        async (res) => {
+          try {
+            await waitUntilTrue(
+              async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
+              15e3,
+              1e3
+            );
+            resolve({
+              signer: res.signer,
+              walletId: res.walletId,
+              recoveryShare: null
+            });
+          } catch (error) {
+            reject(error);
+          }
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params,
+          functionType: "ED25519_PREKEYGEN",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params,
+        functionType: "ED25519_PREKEYGEN",
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
     }
-    worker.postMessage({
-      env: ctx.env,
-      apiKey: ctx.apiKey,
-      cosmosPrefix: ctx.cosmosPrefix,
-      params,
-      functionType: "ED25519_PREKEYGEN",
-      disableWorkers: ctx.disableWorkers,
-      sessionCookie,
-      disableWebSockets: ctx.disableWebSockets,
-      wasmOverride: ctx.wasmOverride,
-      workId
-    });
   });
 }
 export {