@getpara/server-sdk 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/esm/workers/worker.js

@@ -1,325 +1,28 @@
-import {
-  __async,
-  __require
-} from "./chunk-ILICZWQV.js";
-
-// src/workers/worker.ts
-import axios from "axios";
-import {
-  getPortalBaseURL,
-  initClient,
-  mpcComputationClient,
-  paraVersion,
-  WalletType as WalletType2
-} from "@getpara/core-sdk";
-
-// src/workers/walletUtils.ts
-import { getBaseMPCNetworkUrl, WalletScheme, WalletType } from "@getpara/core-sdk";
-var configCGGMPBase = (serverUrl, walletId, id) => `{"ServerUrl":"${serverUrl}", "WalletId": "${walletId}", "Id":"${id}", "Ids":["USER","CAPSULE"], "Threshold":1}`;
-var configDKLSBase = (walletId, id, disableWebSockets) => `{"walletId": "${walletId}", "id":"${id}", "otherId":"CAPSULE", "isReceiver": false, "disableWebSockets": ${disableWebSockets}}`;
-function keygenRequest(ctx, userId, walletId, protocolId) {
-  return __async(this, null, function* () {
-    const { data } = yield ctx.mpcComputationClient.post("/wallets", {
-      userId,
-      walletId,
-      protocolId
-    });
-    return data;
-  });
-}
-function signMessageRequest(ctx, userId, walletId, protocolId, message, signer) {
-  return __async(this, null, function* () {
-    const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/messages/sign`, {
-      userId,
-      protocolId,
-      message,
-      signer
-    });
-    return data;
-  });
-}
-function sendTransactionRequest(ctx, userId, walletId, protocolId, transaction, signer, chainId) {
-  return __async(this, null, function* () {
-    const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/transactions/send`, {
-      userId,
-      protocolId,
-      transaction,
-      signer,
-      chainId
-    });
-    return data;
-  });
-}
-function ed25519Keygen(ctx, userId) {
-  return __async(this, null, function* () {
-    const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
-      scheme: WalletScheme.ED25519,
-      type: WalletType.SOLANA
-    });
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    try {
-      const newSigner = yield new Promise(
-        (resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-      return { signer: newSigner, walletId };
-    } catch (e) {
-      throw new Error(`error creating account of type SOLANA with userId ${userId} and walletId ${walletId}`);
-    }
-  });
-}
-function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
-  return __async(this, null, function* () {
-    const { walletId, protocolId } = yield ctx.client.createPregenWallet({
-      pregenIdentifier,
-      pregenIdentifierType,
-      scheme: WalletScheme.ED25519,
-      type: WalletType.SOLANA
-    });
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    try {
-      const newSigner = yield new Promise(
-        (resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-      return { signer: newSigner, walletId };
-    } catch (e) {
-      throw new Error(`error creating account of type SOLANA with walletId ${walletId}`);
-    }
-  });
-}
-function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
-  return __async(this, null, function* () {
-    const { protocolId } = yield ctx.client.preSignMessage(userId, walletId, base64Bytes, WalletScheme.ED25519);
-    try {
-      const base64Sig = yield new Promise(
-        (resolve, reject) => global.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}`);
-    }
-  });
-}
-function keygen(ctx, userId, type, secretKey) {
-  return __async(this, null, function* () {
-    const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
-      useTwoSigners: true,
-      scheme: ctx.useDKLS ? WalletScheme.DKLS : WalletScheme.CGGMP,
-      type,
-      cosmosPrefix: type === WalletType.COSMOS ? ctx.cosmosPrefix : void 0
-    });
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return {
-        signer: (yield keygenRequest(ctx, userId, walletId, protocolId)).signer,
-        walletId
-      };
-    }
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const signerConfigUser = ctx.useDKLS ? configDKLSBase(walletId, "USER", ctx.disableWebSockets) : configCGGMPBase(serverUrl, walletId, "USER");
-    const createAccountFn = ctx.useDKLS ? global.dklsCreateAccount : global.createAccountV2;
-    try {
-      const newSigner = yield new Promise(
-        (resolve, reject) => createAccountFn(
-          signerConfigUser,
-          serverUrl,
-          protocolId,
-          secretKey,
-          () => {
-          },
-          // no-op for deprecated callback to update progress percentage
-          (err, result) => {
-            if (err) {
-              reject(err);
-            }
-            resolve(result);
-          }
-        )
-      );
-      return { signer: newSigner, walletId };
-    } catch (e) {
-      throw new Error(`error creating account of type ${type} with userId ${userId} and walletId ${walletId}`);
-    }
-  });
-}
-function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey) {
-  return __async(this, null, function* () {
-    const { walletId, protocolId } = yield ctx.client.createPregenWallet({
-      pregenIdentifier,
-      pregenIdentifierType,
-      type,
-      cosmosPrefix: type === WalletType.COSMOS ? ctx.cosmosPrefix : void 0
-    });
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return {
-        signer: (yield keygenRequest(ctx, partnerId, walletId, protocolId)).signer,
-        walletId
-      };
-    }
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const signerConfigUser = ctx.useDKLS ? configDKLSBase(walletId, "USER", ctx.disableWebSockets) : configCGGMPBase(serverUrl, walletId, "USER");
-    const createAccountFn = ctx.useDKLS ? global.dklsCreateAccount : global.createAccountV2;
-    try {
-      const newSigner = yield new Promise(
-        (resolve, reject) => createAccountFn(
-          signerConfigUser,
-          serverUrl,
-          protocolId,
-          secretKey,
-          () => {
-          },
-          // no-op for deprecated callback to update progress percentage
-          (err, result) => {
-            if (err) {
-              reject(err);
-            }
-            resolve(result);
-          }
-        )
-      );
-      return { signer: newSigner, walletId };
-    } catch (e) {
-      throw new Error(`error creating account of type ${type} with  walletId ${walletId}`);
-    }
-  });
-}
-function signMessage(ctx, share, walletId, userId, message) {
-  return __async(this, null, function* () {
-    const { protocolId, pendingTransactionId } = yield ctx.client.preSignMessage(userId, walletId, message);
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return signMessageRequest(ctx, userId, walletId, protocolId, message, share);
-    }
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const signMessageFn = ctx.useDKLS ? global.dklsSignMessage : global.signMessage;
-    try {
-      return 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}`);
-    }
-  });
-}
-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 };
-    }
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
-    }
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const signTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    try {
-      return 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}`);
-    }
-  });
-}
-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 };
-    }
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
-    }
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const sendTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    try {
-      return 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}`);
-    }
-  });
-}
-function refresh(ctx, share, walletId, userId) {
-  return __async(this, null, function* () {
-    const {
-      data: { protocolId }
-    } = yield ctx.client.refreshKeys(userId, walletId);
-    const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
-    const refreshFn = ctx.useDKLS ? global.dklsRefresh : global.refresh;
-    try {
-      return new Promise(
-        (resolve, reject) => refreshFn(share, serverUrl, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-    } catch (e) {
-      throw new Error(`error refreshing keys for account with userId ${userId} and walletId ${walletId}`);
-    }
-  });
-}
-function getPrivateKey(ctx, share, walletId, userId) {
-  return __async(this, null, function* () {
-    const paraShare = yield ctx.client.getParaShare(userId, walletId);
-    if (!paraShare) {
-      console.error("unable to retrieve Para share");
-      return "";
-    }
-    try {
-      return new Promise(
-        (resolve, reject) => global.getPrivateKey(share, paraShare, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-    } catch (e) {
-      throw new Error(`error getting private key for account with userId ${userId} and walletId ${walletId}`);
-    }
+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());
   });
-}
-
-// src/workers/worker.ts
-var rawWasm;
+};
+import axios from "axios";
+import { getPortalBaseURL, initClient, mpcComputationClient, paraVersion } from "@getpara/core-sdk";
+import * as walletUtils from "./walletUtils.js";
+let rawWasm;
+let wasmLoaded = false;
 function requestWasmWithRetries(ctx, retries = 3) {
   return __async(this, null, function* () {
     for (let i = 0; i < retries; i++) {
@@ -335,8 +38,8 @@ function requestWasmWithRetries(ctx, retries = 3) {
 }
 function loadWasm(ctx) {
   return __async(this, null, function* () {
-    yield import("./wasm_exec-CFNSOXDO.js");
-    global.WebSocket = __require("ws");
+    yield import("../wasm/wasm_exec.js");
+    global.WebSocket = require("ws");
     const goWasm = new global.Go();
     if (!rawWasm) {
       rawWasm = (yield requestWasmWithRetries(ctx)).data;
@@ -351,46 +54,48 @@ function executeMessage(ctx, message) {
     const { functionType, params } = message;
     switch (functionType) {
       case "KEYGEN": {
-        const { userId, secretKey, type = WalletType2.EVM } = params;
-        return keygen(ctx, userId, type, secretKey);
+        const { userId, secretKey, type = "EVM" } = params;
+        return walletUtils.keygen(ctx, userId, type, secretKey);
       }
       case "SIGN_TRANSACTION": {
         const { share, walletId, userId, tx, chainId } = params;
-        return 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 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 } = params;
-        return signMessage(ctx, share, walletId, userId, message2);
+        return withRetry(() => walletUtils.signMessage(ctx, share, walletId, userId, message2));
       }
       case "REFRESH": {
         const { share, walletId, userId } = params;
-        return refresh(ctx, share, walletId, userId);
+        const signer = yield walletUtils.refresh(ctx, share, walletId, userId);
+        return { signer };
       }
       case "PREKEYGEN": {
-        const { email, partnerId, secretKey, type = WalletType2.EVM } = params;
+        const { email, partnerId, secretKey, type = "EVM" } = params;
         let { pregenIdentifier, pregenIdentifierType } = params;
         if (email !== "null" && email !== "undefined" && email !== "" && email != null) {
           pregenIdentifier = email;
           pregenIdentifierType = "EMAIL";
         }
-        const keygenRes = yield preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey);
+        const keygenRes = yield walletUtils.preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey);
         return keygenRes;
       }
       case "GET_PRIVATE_KEY": {
         const { share, walletId, userId } = params;
-        return yield getPrivateKey(ctx, share, walletId, userId);
+        const privateKey = yield walletUtils.getPrivateKey(ctx, share, walletId, userId);
+        return { privateKey };
       }
       case "ED25519_KEYGEN": {
         const { userId } = params;
-        return ed25519Keygen(ctx, userId);
+        return walletUtils.ed25519Keygen(ctx, userId);
       }
       case "ED25519_SIGN": {
         const { share, walletId, userId, base64Bytes } = params;
-        return ed25519Sign(ctx, share, userId, walletId, base64Bytes);
+        return walletUtils.ed25519Sign(ctx, share, userId, walletId, base64Bytes);
       }
       case "ED25519_PREKEYGEN": {
         const { email } = params;
@@ -399,7 +104,7 @@ function executeMessage(ctx, message) {
           pregenIdentifier = email;
           pregenIdentifierType = "EMAIL";
         }
-        return ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType);
+        return walletUtils.ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType);
       }
       default: {
         throw new Error(`functionType: ${functionType} not supported`);
@@ -407,6 +112,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) {
   return __async(this, null, function* () {
     const {
@@ -430,8 +158,19 @@ function handleMessage(e) {
       disableWebSockets: !!disableWebSockets,
       cosmosPrefix
     };
-    if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+    if (!wasmLoaded && (!ctx.offloadMPCComputationURL || ctx.useDKLS)) {
       yield loadWasm(ctx);
+      if (global.initWasm) {
+        yield new Promise(
+          (resolve, reject) => global.initWasm((err, result2) => {
+            if (err) {
+              reject(err);
+            }
+            resolve(result2);
+          })
+        );
+      }
+      wasmLoaded = true;
     }
     const result = yield executeMessage(ctx, e.data);
     result.workId = workId;
@@ -439,5 +178,7 @@ function handleMessage(e) {
   });
 }
 export {
-  handleMessage
+  handleMessage,
+  requestWasmWithRetries,
+  withRetry
 };

package/dist/esm/workers/workerWrapper.js

@@ -0,0 +1,85 @@
+import "../chunk-FTA5RKYX.js";
+import { Worker } from "worker_threads";
+import { getPortalBaseURL } from "@getpara/core-sdk";
+const CLEAR_WORKER_TIMEOUT_MS = 1e3 * 90;
+let worker;
+const resFunctionMap = {};
+function removeWorkId(workId, skipClearTimeout) {
+  const { timeoutId } = resFunctionMap[workId];
+  delete resFunctionMap[workId];
+  if (skipClearTimeout) {
+    return;
+  }
+  clearTimeout(timeoutId);
+}
+function resetWorker() {
+  if (worker) {
+    worker.terminate();
+    worker = void 0;
+  }
+}
+async function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
+  const timeoutId = setTimeout(() => {
+    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,
+    errorFn: errorFunction,
+    timeoutId,
+    errorContext
+  };
+  if (!worker || !worker.threadId) {
+    const isDeno = typeof globalThis?.Deno !== "undefined";
+    const workerFileName = isDeno ? "mpcWorkerServer-esm.js" : "mpcWorkerServer-bundle.js";
+    const workerRes = await fetch(`${getPortalBaseURL(ctx)}/static/js/${workerFileName}`);
+    worker = new Worker(await workerRes.text(), { eval: true });
+    const onmessage = async (message) => {
+      const { workId: messageWorkId } = message;
+      if (!resFunctionMap[messageWorkId]) {
+        console.warn(`received message for unknown workId: ${messageWorkId}`);
+        return;
+      }
+      delete message.workId;
+      try {
+        await 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) => {
+      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;
+}
+export {
+  resetWorker,
+  setupWorker
+};

package/dist/types/ParaServer.d.ts

@@ -1,7 +1,9 @@
-import ParaCore, { PlatformUtils, ConstructorOpts, Environment, TPregenIdentifierType } from '@getpara/core-sdk';
+import ParaCore, { PlatformUtils, ConstructorOpts, Environment, CoreMethodParams, CoreMethodResponse } from '@getpara/core-sdk';
 export declare class Para extends ParaCore {
     constructor(env: Environment, apiKey?: string, opts?: ConstructorOpts);
+    protected ready(): Promise<void>;
     protected getPlatformUtils(): PlatformUtils;
+    isPasskeySupported(): Promise<boolean>;
     /**
      * Claims a pregenerated wallet.
      *
@@ -13,8 +15,5 @@ export declare class Para extends ParaCore {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType - the type of the identifier.
      * @returns {Promise<string | undefined>} A promise that rejects with an error.
      */
-    claimPregenWallets({}?: {
-        pregenIdentifier?: string;
-        pregenIdentifierType?: TPregenIdentifierType;
-    }): Promise<string | undefined>;
+    claimPregenWallets(_: CoreMethodParams<'claimPregenWallets'>): CoreMethodResponse<'claimPregenWallets'>;
 }

package/dist/types/ServerUtils.d.ts

@@ -1,19 +1,18 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Ctx, SignatureRes, PlatformUtils, TPregenIdentifierType, WalletType } from '@getpara/core-sdk';
-import { BackupKitEmailProps } from '@getpara/user-management-client';
+import type { Ctx, SignatureRes, PlatformUtils, TPregenIdentifierType, TWalletType } from '@getpara/core-sdk';
+import { BackupKitEmailProps, SDKType } from '@getpara/user-management-client';
 import { ServerLocalStorage } from './ServerLocalStorage.js';
 import { ServerSessionStorage } from './ServerSessionStorage.js';
 export declare class ServerUtils implements PlatformUtils {
+    sdkType: SDKType;
     getPrivateKey(ctx: Ctx, userId: string, walletId: string, share: string, sessionCookie: string): Promise<string>;
-    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
+    keygen(ctx: Ctx, userId: string, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
         signer: string;
         walletId: string;
     }>;
     refresh(_ctx: Ctx, _sessionCookie: string, _userId: string, _walletId: string, _share: string, _oldPartnerId?: string, _newPartnerId?: string): Promise<{
         signer: string;
     }>;
-    preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
     sessionCookie: string): Promise<{
         signer: string;
         walletId: string;

package/dist/types/wallet/keygen.d.ts

@@ -1,11 +1,13 @@
 import { Ctx, TPregenIdentifierType } from '@getpara/core-sdk';
-import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
-export declare function keygen(ctx: Ctx, userId: string, type: WalletType, secretKey: string | null, skipDistribute?: boolean, sessionCookie?: string, _emailProps?: BackupKitEmailProps): Promise<{
+import { BackupKitEmailProps, TWalletType } from '@getpara/user-management-client';
+export declare function isKeygenComplete(ctx: Ctx, userId: string, walletId: string): Promise<boolean>;
+export declare function isPreKeygenComplete(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, walletId: string): Promise<boolean>;
+export declare function keygen(ctx: Ctx, userId: string, type: TWalletType, secretKey: string | null, sessionCookie?: string, _emailProps?: BackupKitEmailProps): Promise<{
     signer: string;
     walletId: string;
     recoveryShare: string | null;
 }>;
-export declare function preKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: WalletType, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
+export declare function preKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: TWalletType, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
     signer: string;
     walletId: string;
     recoveryShare: string | null;

package/dist/types/workers/walletUtils.d.ts

@@ -1,4 +1,4 @@
-import { Ctx, TPregenIdentifierType, SignatureRes, WalletType } from '@getpara/core-sdk';
+import { Ctx, TPregenIdentifierType, SignatureRes, TWalletType } from '@getpara/core-sdk';
 export declare function ed25519Keygen(ctx: Ctx, userId: string): Promise<{
     signer: string;
     walletId: string;
@@ -7,14 +7,12 @@ export declare function ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pre
     signer: string;
     walletId: string;
 }>;
-export declare function ed25519Sign(ctx: Ctx, share: string, userId: string, walletId: string, base64Bytes: string): Promise<{
-    signature: string;
-}>;
-export declare function keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null): Promise<{
+export declare function ed25519Sign(ctx: Ctx, share: string, userId: string, walletId: string, base64Bytes: string): Promise<SignatureRes>;
+export declare function keygen(ctx: Ctx, userId: string, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null): Promise<{
     signer: string;
     walletId: string;
 }>;
-export declare function preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null): Promise<{
+export declare function preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null): Promise<{
     signer: string;
     walletId: string;
 }>;