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

package/dist/esm/wallet/signing.js

@@ -2,103 +2,155 @@ import "../chunk-FTA5RKYX.js";
 import * as uuid from "uuid";
 import { setupWorker } from "../workers/workerWrapper.js";
 async function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
-  return await new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (sendTransactionRes) => {
-        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 = await setupWorker(
+        ctx,
+        async (sendTransactionRes) => {
+          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);
+    }
   });
 }
 async function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
-  return await new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (sendTransactionRes) => {
-        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 = await setupWorker(
+        ctx,
+        async (sendTransactionRes) => {
+          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);
+    }
   });
 }
 async function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
-  return await new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (signMessageRes) => {
-        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 = await setupWorker(
+        ctx,
+        async (signMessageRes) => {
+          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);
+    }
   });
 }
 async function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
-  return await new Promise(async (resolve) => {
+  return new Promise(async (resolve, reject) => {
     const workId = uuid.v4();
-    const worker = await setupWorker(
-      ctx,
-      async (signMessageRes) => {
-        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 = await setupWorker(
+        ctx,
+        async (signMessageRes) => {
+          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);
+    }
   });
 }
 export {

package/dist/esm/workers/walletUtils.js

@@ -1,5 +1,6 @@
 import "../chunk-FTA5RKYX.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}}`;
 async function keygenRequest(ctx, userId, walletId, protocolId) {
@@ -45,7 +46,7 @@ async function ed25519Keygen(ctx, userId) {
       })
     );
     return { signer: newSigner, walletId };
-  } catch (e) {
+  } catch {
     throw new Error(`error creating account of type SOLANA with userId ${userId} and walletId ${walletId}`);
   }
 }
@@ -67,25 +68,33 @@ async function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
       })
     );
     return { signer: newSigner, walletId };
-  } catch (e) {
+  } catch {
     throw new Error(`error creating account of type SOLANA with walletId ${walletId}`);
   }
 }
 async function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
-  const { protocolId } = await ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519");
-  try {
-    const base64Sig = await 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}`);
+  const protocolId = uuid.v4();
+  const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519", void 0, protocolId);
+  const signRes = async function() {
+    try {
+      const base64Sig = await new Promise(
+        (resolve, reject) => global.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve(result);
+        })
+      );
+      return { signature: base64Sig };
+    } catch {
+      throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const { pendingTransactionId } = await preSignMessageRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
   }
+  return await signRes;
 }
 async function keygen(ctx, userId, type, secretKey) {
   const { walletId, protocolId } = await ctx.client.createWallet(userId, {
@@ -122,7 +131,7 @@ async function keygen(ctx, userId, type, secretKey) {
       )
     );
     return { signer: newSigner, walletId };
-  } catch (e) {
+  } catch {
     throw new Error(`error creating account of type ${type} with userId ${userId} and walletId ${walletId}`);
   }
 }
@@ -161,82 +170,97 @@ async function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType,
       )
     );
     return { signer: newSigner, walletId };
-  } catch (e) {
+  } catch {
     throw new Error(`error creating account of type ${type} with walletId ${walletId}`);
   }
 }
 async function signMessage(ctx, share, walletId, userId, message) {
-  const { protocolId, pendingTransactionId } = await ctx.client.preSignMessage(userId, walletId, message);
-  if (pendingTransactionId) {
-    return { pendingTransactionId };
-  }
+  const protocolId = uuid.v4();
+  const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, message, null, null, protocolId);
   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 await 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}`);
-  }
-}
-async function signTransaction(ctx, share, walletId, userId, tx, chainId) {
-  const {
-    data: { protocolId, pendingTransactionId }
-  } = await ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId });
+  const signMessageRes = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch {
+      throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const { pendingTransactionId } = await preSignMessageRes;
   if (pendingTransactionId) {
     return { pendingTransactionId };
   }
+  return await signMessageRes;
+}
+async function signTransaction(ctx, share, walletId, userId, tx, chainId) {
+  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);
   }
   const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
   const signTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-  try {
-    return await 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}`);
-  }
-}
-async function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
+  const signTxRes = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch {
+      throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
   const {
-    data: { protocolId, pendingTransactionId }
-  } = await ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId });
+    data: { pendingTransactionId }
+  } = await signTransactionRes;
   if (pendingTransactionId) {
     return { pendingTransactionId };
   }
+  return await signTxRes;
+}
+async function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
+  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);
   }
   const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
   const sendTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-  try {
-    return await 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 = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch {
+      throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const {
+    data: { pendingTransactionId }
+  } = await sendTransactionRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
   }
+  return await sendTxRes;
 }
 async function refresh(ctx, share, walletId, userId) {
   const {
@@ -253,7 +277,7 @@ async function refresh(ctx, share, walletId, userId) {
         resolve(result);
       })
     );
-  } catch (e) {
+  } catch {
     throw new Error(`error refreshing keys for account with userId ${userId} and walletId ${walletId}`);
   }
 }
@@ -272,7 +296,7 @@ async function getPrivateKey(ctx, share, walletId, userId) {
         resolve(result);
       })
     );
-  } catch (e) {
+  } catch {
     throw new Error(`error getting private key for account with userId ${userId} and walletId ${walletId}`);
   }
 }

package/dist/esm/workers/worker.js

@@ -19,9 +19,16 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import axios from "axios";
-import { getPortalBaseURL, initClient, mpcComputationClient, paraVersion } from "@getpara/core-sdk";
+import {
+  getBaseMPCNetworkUrl,
+  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++) {
@@ -52,21 +59,24 @@ function executeMessage(ctx, message) {
   return __async(this, null, function* () {
     const { functionType, params } = message;
     switch (functionType) {
+      case "INIT": {
+        return {};
+      }
       case "KEYGEN": {
         const { userId, secretKey, type = "EVM" } = params;
         return walletUtils.keygen(ctx, userId, type, secretKey);
       }
       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 } = params;
-        return walletUtils.signMessage(ctx, share, walletId, userId, message2);
+        return withRetry(() => walletUtils.signMessage(ctx, share, walletId, userId, message2));
       }
       case "REFRESH": {
         const { share, walletId, userId } = params;
@@ -111,6 +121,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 {
@@ -134,8 +167,20 @@ function handleMessage(e) {
       disableWebSockets: !!disableWebSockets,
       cosmosPrefix
     };
-    if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+    if (!wasmLoaded && (!ctx.offloadMPCComputationURL || ctx.useDKLS)) {
       yield loadWasm(ctx);
+      if (global.initWasm) {
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        yield new Promise(
+          (resolve, reject) => global.initWasm((err, result2) => {
+            if (err) {
+              reject(err);
+            }
+            resolve(result2);
+          }, serverUrl)
+        );
+      }
+      wasmLoaded = true;
     }
     const result = yield executeMessage(ctx, e.data);
     result.workId = workId;
@@ -144,5 +189,6 @@ function handleMessage(e) {
 }
 export {
   handleMessage,
-  requestWasmWithRetries
+  requestWasmWithRetries,
+  withRetry
 };

package/dist/esm/workers/workerWrapper.js

@@ -12,33 +12,74 @@ function removeWorkId(workId, skipClearTimeout) {
   }
   clearTimeout(timeoutId);
 }
-async function setupWorker(ctx, resFunction, workId) {
+function resetWorker() {
+  if (worker) {
+    worker.terminate();
+    worker = void 0;
+  }
+}
+async function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
   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 = await fetch(`${getPortalBaseURL(ctx)}/static/js/mpcWorkerServer-bundle.js`);
+    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;
-      await resFunctionMap[messageWorkId].fn(message);
-      removeWorkId(messageWorkId);
+      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) => {
-      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;
 }
 export {
+  resetWorker,
   setupWorker
 };

package/dist/types/ParaServer.d.ts

@@ -1,7 +1,10 @@
 import ParaCore, { PlatformUtils, ConstructorOpts, Environment, CoreMethodParams, CoreMethodResponse } from '@getpara/core-sdk';
 export declare class Para extends ParaCore {
-    constructor(env: Environment, apiKey?: string, opts?: ConstructorOpts);
+    constructor(env: Environment | undefined, apiKey: string, opts?: ConstructorOpts);
+    constructor(apiKey: string, opts?: ConstructorOpts);
+    ready(): Promise<void>;
     protected getPlatformUtils(): PlatformUtils;
+    isPasskeySupported(): Promise<boolean>;
     /**
      * Claims a pregenerated wallet.
      *