@getpara/server-sdk 2.0.0-alpha.17 → 2.0.0-alpha.19

package/dist/cjs/workers/walletUtils.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -50,6 +60,7 @@ __export(walletUtils_exports, {
 });
 module.exports = __toCommonJS(walletUtils_exports);
 var import_core_sdk = require("@getpara/core-sdk");
+var uuid = __toESM(require("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) {
@@ -133,20 +144,27 @@ 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) => 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 = function() {
+      return __async(this, null, function* () {
+        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}`);
+        }
+      });
+    }();
+    yield preSignMessageRes;
+    return yield signRes;
   });
 }
 function keygen(ctx, userId, type, secretKey) {
@@ -233,81 +251,102 @@ function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type,
 }
 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 };
-    }
+    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 = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const signMessageFn = ctx.useDKLS ? global.dklsSignMessage : global.signMessage;
-    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);
     }
     const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const signTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    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);
     }
     const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const sendTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    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) {

package/dist/cjs/workers/worker.js

@@ -48,13 +48,15 @@ var __async = (__this, __arguments, generator) => {
 var worker_exports = {};
 __export(worker_exports, {
   handleMessage: () => handleMessage,
-  requestWasmWithRetries: () => requestWasmWithRetries
+  requestWasmWithRetries: () => requestWasmWithRetries,
+  withRetry: () => withRetry
 });
 module.exports = __toCommonJS(worker_exports);
 var import_axios = __toESM(require("axios"));
 var import_core_sdk = require("@getpara/core-sdk");
 var walletUtils = __toESM(require("./walletUtils.js"));
 let rawWasm;
+let wasmLoaded = false;
 function requestWasmWithRetries(ctx, retries = 3) {
   return __async(this, null, function* () {
     for (let i = 0; i < retries; i++) {
@@ -91,15 +93,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 } = 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;
@@ -144,6 +146,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 {
@@ -167,8 +192,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;
@@ -178,5 +214,6 @@ function handleMessage(e) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handleMessage,
-  requestWasmWithRetries
+  requestWasmWithRetries,
+  withRetry
 });

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) {
@@ -72,20 +73,25 @@ async function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
   }
 }
 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 (e) {
+      throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  await preSignMessageRes;
+  return await signRes;
 }
 async function keygen(ctx, userId, type, secretKey) {
   const { walletId, protocolId } = await ctx.client.createWallet(userId, {
@@ -166,77 +172,92 @@ async function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType,
   }
 }
 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 (e) {
+      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 (e) {
+      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 (e) {
+      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 {

package/dist/esm/workers/worker.js

@@ -22,6 +22,7 @@ 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++) {
@@ -58,15 +59,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 } = 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 +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 {
@@ -134,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;
@@ -144,5 +179,6 @@ function handleMessage(e) {
 }
 export {
   handleMessage,
-  requestWasmWithRetries
+  requestWasmWithRetries,
+  withRetry
 };

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

@@ -13,6 +13,14 @@ interface Message {
     workId: string;
 }
 export declare function requestWasmWithRetries(ctx: Ctx, retries?: number): Promise<import("axios").AxiosResponse<any, any>>;
+/**
+ * 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;
 }): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpara/server-sdk",
-  "version": "2.0.0-alpha.17",
+  "version": "2.0.0-alpha.19",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -9,8 +9,8 @@
     "wasm_exec.js"
   ],
   "dependencies": {
-    "@getpara/core-sdk": "2.0.0-alpha.17",
-    "@getpara/user-management-client": "2.0.0-alpha.17",
+    "@getpara/core-sdk": "2.0.0-alpha.19",
+    "@getpara/user-management-client": "2.0.0-alpha.19",
     "@sentry/node": "^9.1.0",
     "uuid": "^11.1.0",
     "ws": "^8.14.2"
@@ -31,5 +31,5 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "5cb0f3dee5564995c465ead160ed817ba2ba37a7"
+  "gitHead": "80d2c5d7e1203fb12378aa29bfd4d7003c7d7075"
 }