@getpara/server-sdk 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/esm/ParaServer.js

@@ -1,22 +1,19 @@
 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"
-      });
-    }
+  constructor(envOrApiKey, apiKeyOrOpts, opts) {
+    super(envOrApiKey, apiKeyOrOpts, opts);
+  }
+  async ready() {
+    this.isReady = true;
   }
   getPlatformUtils() {
     return new ServerUtils();
   }
+  async isPasskeySupported() {
+    return false;
+  }
   /**
    * Claims a pregenerated wallet.
    *

package/dist/esm/ServerUtils.js

@@ -1,7 +1,7 @@
 import "./chunk-FTA5RKYX.js";
 import { ServerLocalStorage } from "./ServerLocalStorage.js";
 import { ServerSessionStorage } from "./ServerSessionStorage.js";
-import { keygen, preKeygen, ed25519Keygen, ed25519PreKeygen } from "./wallet/keygen.js";
+import { keygen, preKeygen, ed25519Keygen, ed25519PreKeygen, initializeWorker } from "./wallet/keygen.js";
 import { signMessage, sendTransaction, signTransaction, ed25519Sign } from "./wallet/signing.js";
 import { getPrivateKey } from "./wallet/privateKey.js";
 class ServerUtils {
@@ -46,9 +46,12 @@ class ServerUtils {
   ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
     return ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie);
   }
-  openPopup(_popupUrl) {
+  async openPopup(_popupUrl) {
     throw new Error("OpenPopup is not implemented in the ServerUtils class.");
   }
+  async initializeWorker(ctx) {
+    return initializeWorker(ctx);
+  }
 }
 export {
   ServerUtils

package/dist/esm/wallet/keygen.js

@@ -13,146 +13,247 @@ 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();
+    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);
+    }
+  });
+}
+async function initializeWorker(ctx) {
+  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 worker = await setupWorker(
+        ctx,
+        async () => {
+          resolve();
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          functionType: "INIT",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        functionType: "INIT",
+        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 {
   ed25519Keygen,
   ed25519PreKeygen,
+  initializeWorker,
   isKeygenComplete,
   isPreKeygenComplete,
   keygen,

package/dist/esm/wallet/privateKey.js

@@ -2,29 +2,42 @@ import "../chunk-FTA5RKYX.js";
 import * as uuid from "uuid";
 import { setupWorker } from "../workers/workerWrapper.js";
 async function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
-  return await new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (res) => {
-        resolve(res.privateKey);
-      },
-      workId
-    );
-    worker.postMessage({
-      env: ctx.env,
-      apiKey: ctx.apiKey,
-      cosmosPrefix: ctx.cosmosPrefix,
-      params: { share, walletId, userId },
-      functionType: "GET_PRIVATE_KEY",
-      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) => {
+          resolve(res.privateKey);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId },
+          functionType: "GET_PRIVATE_KEY",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId },
+        functionType: "GET_PRIVATE_KEY",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: ctx.useDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
   });
 }
 export {