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

package/dist/cjs/workers/worker.js

@@ -4,9 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -48,903 +45,23 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-
-// src/wasm/wasm_exec.js
-var require_wasm_exec = __commonJS({
-  "src/wasm/wasm_exec.js"(exports2, module2) {
-    "use strict";
-    var globalThisCopy = global;
-    if (!globalThisCopy.crypto) {
-      globalThisCopy.crypto = require("crypto");
-    }
-    var crypto = globalThisCopy.crypto;
-    (() => {
-      const enosys = () => {
-        const err = new Error("not implemented");
-        err.code = "ENOSYS";
-        return err;
-      };
-      if (!globalThis.fs) {
-        let outputBuf = "";
-        globalThis.fs = {
-          constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 },
-          // unused
-          writeSync(fd, buf) {
-            outputBuf += decoder.decode(buf);
-            const nl = outputBuf.lastIndexOf("\n");
-            if (nl != -1) {
-              console.log(outputBuf.substring(0, nl));
-              outputBuf = outputBuf.substring(nl + 1);
-            }
-            return buf.length;
-          },
-          write(fd, buf, offset, length, position, callback) {
-            if (offset !== 0 || length !== buf.length || position !== null) {
-              callback(enosys());
-              return;
-            }
-            const n = this.writeSync(fd, buf);
-            callback(null, n);
-          },
-          chmod(path, mode, callback) {
-            callback(enosys());
-          },
-          chown(path, uid, gid, callback) {
-            callback(enosys());
-          },
-          close(fd, callback) {
-            callback(enosys());
-          },
-          fchmod(fd, mode, callback) {
-            callback(enosys());
-          },
-          fchown(fd, uid, gid, callback) {
-            callback(enosys());
-          },
-          fstat(fd, callback) {
-            callback(enosys());
-          },
-          fsync(fd, callback) {
-            callback(null);
-          },
-          ftruncate(fd, length, callback) {
-            callback(enosys());
-          },
-          lchown(path, uid, gid, callback) {
-            callback(enosys());
-          },
-          link(path, link, callback) {
-            callback(enosys());
-          },
-          lstat(path, callback) {
-            callback(enosys());
-          },
-          mkdir(path, perm, callback) {
-            callback(enosys());
-          },
-          open(path, flags, mode, callback) {
-            callback(enosys());
-          },
-          read(fd, buffer, offset, length, position, callback) {
-            callback(enosys());
-          },
-          readdir(path, callback) {
-            callback(enosys());
-          },
-          readlink(path, callback) {
-            callback(enosys());
-          },
-          rename(from, to, callback) {
-            callback(enosys());
-          },
-          rmdir(path, callback) {
-            callback(enosys());
-          },
-          stat(path, callback) {
-            callback(enosys());
-          },
-          symlink(path, link, callback) {
-            callback(enosys());
-          },
-          truncate(path, length, callback) {
-            callback(enosys());
-          },
-          unlink(path, callback) {
-            callback(enosys());
-          },
-          utimes(path, atime, mtime, callback) {
-            callback(enosys());
-          }
-        };
-      }
-      if (!globalThis.process) {
-        globalThis.process = {
-          getuid() {
-            return -1;
-          },
-          getgid() {
-            return -1;
-          },
-          geteuid() {
-            return -1;
-          },
-          getegid() {
-            return -1;
-          },
-          getgroups() {
-            throw enosys();
-          },
-          pid: -1,
-          ppid: -1,
-          umask() {
-            throw enosys();
-          },
-          cwd() {
-            throw enosys();
-          },
-          chdir() {
-            throw enosys();
-          }
-        };
-      }
-      if (!globalThis.crypto) {
-        throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
-      }
-      if (!globalThis.performance) {
-        throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
-      }
-      if (!globalThis.TextEncoder) {
-        throw new Error("globalThis.TextEncoder is not available, polyfill required");
-      }
-      if (!globalThis.TextDecoder) {
-        throw new Error("globalThis.TextDecoder is not available, polyfill required");
-      }
-      const encoder = new TextEncoder("utf-8");
-      const decoder = new TextDecoder("utf-8");
-      globalThis.Go = class {
-        constructor() {
-          this.argv = ["js"];
-          this.env = {};
-          this.exit = (code) => {
-            if (code !== 0) {
-              console.warn("exit code:", code);
-            }
-          };
-          this._exitPromise = new Promise((resolve) => {
-            this._resolveExitPromise = resolve;
-          });
-          this._pendingEvent = null;
-          this._scheduledTimeouts = /* @__PURE__ */ new Map();
-          this._nextCallbackTimeoutID = 1;
-          const setInt64 = (addr, v) => {
-            this.mem.setUint32(addr + 0, v, true);
-            this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
-          };
-          const setInt32 = (addr, v) => {
-            this.mem.setUint32(addr + 0, v, true);
-          };
-          const getInt64 = (addr) => {
-            const low = this.mem.getUint32(addr + 0, true);
-            const high = this.mem.getInt32(addr + 4, true);
-            return low + high * 4294967296;
-          };
-          const loadValue = (addr) => {
-            const f = this.mem.getFloat64(addr, true);
-            if (f === 0) {
-              return void 0;
-            }
-            if (!isNaN(f)) {
-              return f;
-            }
-            const id = this.mem.getUint32(addr, true);
-            return this._values[id];
-          };
-          const storeValue = (addr, v) => {
-            const nanHead = 2146959360;
-            if (typeof v === "number" && v !== 0) {
-              if (isNaN(v)) {
-                this.mem.setUint32(addr + 4, nanHead, true);
-                this.mem.setUint32(addr, 0, true);
-                return;
-              }
-              this.mem.setFloat64(addr, v, true);
-              return;
-            }
-            if (v === void 0) {
-              this.mem.setFloat64(addr, 0, true);
-              return;
-            }
-            let id = this._ids.get(v);
-            if (id === void 0) {
-              id = this._idPool.pop();
-              if (id === void 0) {
-                id = this._values.length;
-              }
-              this._values[id] = v;
-              this._goRefCounts[id] = 0;
-              this._ids.set(v, id);
-            }
-            this._goRefCounts[id]++;
-            let typeFlag = 0;
-            switch (typeof v) {
-              case "object":
-                if (v !== null) {
-                  typeFlag = 1;
-                }
-                break;
-              case "string":
-                typeFlag = 2;
-                break;
-              case "symbol":
-                typeFlag = 3;
-                break;
-              case "function":
-                typeFlag = 4;
-                break;
-            }
-            this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
-            this.mem.setUint32(addr, id, true);
-          };
-          const loadSlice = (addr) => {
-            const array = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            return new Uint8Array(this._inst.exports.mem.buffer, array, len);
-          };
-          const loadSliceOfValues = (addr) => {
-            const array = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            const a = new Array(len);
-            for (let i = 0; i < len; i++) {
-              a[i] = loadValue(array + i * 8);
-            }
-            return a;
-          };
-          const loadString = (addr) => {
-            const saddr = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
-          };
-          const timeOrigin = Date.now() - performance.now();
-          this.importObject = {
-            _gotest: {
-              add: (a, b) => a + b
-            },
-            gojs: {
-              // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
-              // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
-              // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
-              // This changes the SP, thus we have to update the SP used by the imported function.
-              // func wasmExit(code int32)
-              "runtime.wasmExit": (sp) => {
-                sp >>>= 0;
-                const code = this.mem.getInt32(sp + 8, true);
-                this.exited = true;
-                delete this._inst;
-                delete this._values;
-                delete this._goRefCounts;
-                delete this._ids;
-                delete this._idPool;
-                this.exit(code);
-              },
-              // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
-              "runtime.wasmWrite": (sp) => {
-                sp >>>= 0;
-                const fd = getInt64(sp + 8);
-                const p = getInt64(sp + 16);
-                const n = this.mem.getInt32(sp + 24, true);
-                fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
-              },
-              // func resetMemoryDataView()
-              "runtime.resetMemoryDataView": (sp) => {
-                sp >>>= 0;
-                this.mem = new DataView(this._inst.exports.mem.buffer);
-              },
-              // func nanotime1() int64
-              "runtime.nanotime1": (sp) => {
-                sp >>>= 0;
-                setInt64(sp + 8, (timeOrigin + performance.now()) * 1e6);
-              },
-              // func walltime() (sec int64, nsec int32)
-              "runtime.walltime": (sp) => {
-                sp >>>= 0;
-                const msec = (/* @__PURE__ */ new Date()).getTime();
-                setInt64(sp + 8, msec / 1e3);
-                this.mem.setInt32(sp + 16, msec % 1e3 * 1e6, true);
-              },
-              // func scheduleTimeoutEvent(delay int64) int32
-              "runtime.scheduleTimeoutEvent": (sp) => {
-                sp >>>= 0;
-                const id = this._nextCallbackTimeoutID;
-                this._nextCallbackTimeoutID++;
-                this._scheduledTimeouts.set(id, setTimeout(
-                  () => {
-                    this._resume();
-                    while (this._scheduledTimeouts.has(id)) {
-                      console.warn("scheduleTimeoutEvent: missed timeout event");
-                      this._resume();
-                    }
-                  },
-                  getInt64(sp + 8)
-                ));
-                this.mem.setInt32(sp + 16, id, true);
-              },
-              // func clearTimeoutEvent(id int32)
-              "runtime.clearTimeoutEvent": (sp) => {
-                sp >>>= 0;
-                const id = this.mem.getInt32(sp + 8, true);
-                clearTimeout(this._scheduledTimeouts.get(id));
-                this._scheduledTimeouts.delete(id);
-              },
-              // func getRandomData(r []byte)
-              "runtime.getRandomData": (sp) => {
-                sp >>>= 0;
-                crypto.getRandomValues(loadSlice(sp + 8));
-              },
-              // func finalizeRef(v ref)
-              "syscall/js.finalizeRef": (sp) => {
-                sp >>>= 0;
-                const id = this.mem.getUint32(sp + 8, true);
-                this._goRefCounts[id]--;
-                if (this._goRefCounts[id] === 0) {
-                  const v = this._values[id];
-                  this._values[id] = null;
-                  this._ids.delete(v);
-                  this._idPool.push(id);
-                }
-              },
-              // func stringVal(value string) ref
-              "syscall/js.stringVal": (sp) => {
-                sp >>>= 0;
-                storeValue(sp + 24, loadString(sp + 8));
-              },
-              // func valueGet(v ref, p string) ref
-              "syscall/js.valueGet": (sp) => {
-                sp >>>= 0;
-                const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
-                sp = this._inst.exports.getsp() >>> 0;
-                storeValue(sp + 32, result);
-              },
-              // func valueSet(v ref, p string, x ref)
-              "syscall/js.valueSet": (sp) => {
-                sp >>>= 0;
-                Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
-              },
-              // func valueDelete(v ref, p string)
-              "syscall/js.valueDelete": (sp) => {
-                sp >>>= 0;
-                Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
-              },
-              // func valueIndex(v ref, i int) ref
-              "syscall/js.valueIndex": (sp) => {
-                sp >>>= 0;
-                storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
-              },
-              // valueSetIndex(v ref, i int, x ref)
-              "syscall/js.valueSetIndex": (sp) => {
-                sp >>>= 0;
-                Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
-              },
-              // func valueCall(v ref, m string, args []ref) (ref, bool)
-              "syscall/js.valueCall": (sp) => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const m = Reflect.get(v, loadString(sp + 16));
-                  const args = loadSliceOfValues(sp + 32);
-                  const result = Reflect.apply(m, v, args);
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 56, result);
-                  this.mem.setUint8(sp + 64, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 56, err);
-                  this.mem.setUint8(sp + 64, 0);
-                }
-              },
-              // func valueInvoke(v ref, args []ref) (ref, bool)
-              "syscall/js.valueInvoke": (sp) => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const args = loadSliceOfValues(sp + 16);
-                  const result = Reflect.apply(v, void 0, args);
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 40, result);
-                  this.mem.setUint8(sp + 48, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 40, err);
-                  this.mem.setUint8(sp + 48, 0);
-                }
-              },
-              // func valueNew(v ref, args []ref) (ref, bool)
-              "syscall/js.valueNew": (sp) => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const args = loadSliceOfValues(sp + 16);
-                  const result = Reflect.construct(v, args);
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 40, result);
-                  this.mem.setUint8(sp + 48, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0;
-                  storeValue(sp + 40, err);
-                  this.mem.setUint8(sp + 48, 0);
-                }
-              },
-              // func valueLength(v ref) int
-              "syscall/js.valueLength": (sp) => {
-                sp >>>= 0;
-                setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
-              },
-              // valuePrepareString(v ref) (ref, int)
-              "syscall/js.valuePrepareString": (sp) => {
-                sp >>>= 0;
-                const str = encoder.encode(String(loadValue(sp + 8)));
-                storeValue(sp + 16, str);
-                setInt64(sp + 24, str.length);
-              },
-              // valueLoadString(v ref, b []byte)
-              "syscall/js.valueLoadString": (sp) => {
-                sp >>>= 0;
-                const str = loadValue(sp + 8);
-                loadSlice(sp + 16).set(str);
-              },
-              // func valueInstanceOf(v ref, t ref) bool
-              "syscall/js.valueInstanceOf": (sp) => {
-                sp >>>= 0;
-                this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
-              },
-              // func copyBytesToGo(dst []byte, src ref) (int, bool)
-              "syscall/js.copyBytesToGo": (sp) => {
-                sp >>>= 0;
-                const dst = loadSlice(sp + 8);
-                const src = loadValue(sp + 32);
-                if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
-                  this.mem.setUint8(sp + 48, 0);
-                  return;
-                }
-                const toCopy = src.subarray(0, dst.length);
-                dst.set(toCopy);
-                setInt64(sp + 40, toCopy.length);
-                this.mem.setUint8(sp + 48, 1);
-              },
-              // func copyBytesToJS(dst ref, src []byte) (int, bool)
-              "syscall/js.copyBytesToJS": (sp) => {
-                sp >>>= 0;
-                const dst = loadValue(sp + 8);
-                const src = loadSlice(sp + 16);
-                if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
-                  this.mem.setUint8(sp + 48, 0);
-                  return;
-                }
-                const toCopy = src.subarray(0, dst.length);
-                dst.set(toCopy);
-                setInt64(sp + 40, toCopy.length);
-                this.mem.setUint8(sp + 48, 1);
-              },
-              "debug": (value) => {
-                console.log(value);
-              }
-            }
-          };
-        }
-        run(instance) {
-          return __async(this, null, function* () {
-            if (!(instance instanceof WebAssembly.Instance)) {
-              throw new Error("Go.run: WebAssembly.Instance expected");
-            }
-            this._inst = instance;
-            this.mem = new DataView(this._inst.exports.mem.buffer);
-            this._values = [
-              // JS values that Go currently has references to, indexed by reference id
-              NaN,
-              0,
-              null,
-              true,
-              false,
-              globalThis,
-              this
-            ];
-            this._goRefCounts = new Array(this._values.length).fill(Infinity);
-            this._ids = /* @__PURE__ */ new Map([
-              // mapping from JS values to reference ids
-              [0, 1],
-              [null, 2],
-              [true, 3],
-              [false, 4],
-              [globalThis, 5],
-              [this, 6]
-            ]);
-            this._idPool = [];
-            this.exited = false;
-            let offset = 4096;
-            const strPtr = (str) => {
-              const ptr = offset;
-              const bytes = encoder.encode(str + "\0");
-              new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
-              offset += bytes.length;
-              if (offset % 8 !== 0) {
-                offset += 8 - offset % 8;
-              }
-              return ptr;
-            };
-            const argc = this.argv.length;
-            const argvPtrs = [];
-            this.argv.forEach((arg) => {
-              argvPtrs.push(strPtr(arg));
-            });
-            argvPtrs.push(0);
-            const keys = Object.keys(this.env).sort();
-            keys.forEach((key) => {
-              argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
-            });
-            argvPtrs.push(0);
-            const argv = offset;
-            argvPtrs.forEach((ptr) => {
-              this.mem.setUint32(offset, ptr, true);
-              this.mem.setUint32(offset + 4, 0, true);
-              offset += 8;
-            });
-            const wasmMinDataAddr = 4096 + 8192;
-            if (offset >= wasmMinDataAddr) {
-              throw new Error("total length of command line and environment variables exceeds limit");
-            }
-            this._inst.exports.run(argc, argv);
-            if (this.exited) {
-              this._resolveExitPromise();
-            }
-            yield this._exitPromise;
-          });
-        }
-        _resume() {
-          if (this.exited) {
-            throw new Error("Go program has already exited");
-          }
-          this._inst.exports.resume();
-          if (this.exited) {
-            this._resolveExitPromise();
-          }
-        }
-        _makeFuncWrapper(id) {
-          const go = this;
-          return function() {
-            const event = { id, this: this, args: arguments };
-            go._pendingEvent = event;
-            go._resume();
-            return event.result;
-          };
-        }
-      };
-    })();
-    module2.exports = {
-      globalThisCopy
-    };
-  }
-});
-
-// src/workers/worker.ts
 var worker_exports = {};
 __export(worker_exports, {
-  handleMessage: () => handleMessage
+  handleMessage: () => handleMessage,
+  requestWasmWithRetries: () => requestWasmWithRetries,
+  withRetry: () => withRetry
 });
 module.exports = __toCommonJS(worker_exports);
 var import_axios = __toESM(require("axios"));
-var import_core_sdk2 = require("@getpara/core-sdk");
-
-// src/workers/walletUtils.ts
 var import_core_sdk = require("@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: import_core_sdk.WalletScheme.ED25519,
-      type: import_core_sdk.WalletType.SOLANA
-    });
-    const serverUrl = (0, import_core_sdk.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: import_core_sdk.WalletScheme.ED25519,
-      type: import_core_sdk.WalletType.SOLANA
-    });
-    const serverUrl = (0, import_core_sdk.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, import_core_sdk.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 ? import_core_sdk.WalletScheme.DKLS : import_core_sdk.WalletScheme.CGGMP,
-      type,
-      cosmosPrefix: type === import_core_sdk.WalletType.COSMOS ? ctx.cosmosPrefix : void 0
-    });
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return {
-        signer: (yield keygenRequest(ctx, userId, walletId, protocolId)).signer,
-        walletId
-      };
-    }
-    const serverUrl = (0, import_core_sdk.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 === import_core_sdk.WalletType.COSMOS ? ctx.cosmosPrefix : void 0
-    });
-    if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
-      return {
-        signer: (yield keygenRequest(ctx, partnerId, walletId, protocolId)).signer,
-        walletId
-      };
-    }
-    const serverUrl = (0, import_core_sdk.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 = (0, import_core_sdk.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 = (0, import_core_sdk.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 = (0, import_core_sdk.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 = (0, import_core_sdk.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}`);
-    }
-  });
-}
-
-// src/workers/worker.ts
-var rawWasm;
+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++) {
       try {
-        return yield import_axios.default.get(`${(0, import_core_sdk2.getPortalBaseURL)(ctx, true, true)}/static/js/main.wasm`, { responseType: "arraybuffer" });
+        return yield import_axios.default.get(`${(0, import_core_sdk.getPortalBaseURL)(ctx, true, true)}/static/js/main.wasm`, { responseType: "arraybuffer" });
       } catch (e) {
         if (i === retries - 1) {
           throw e;
@@ -955,7 +72,7 @@ function requestWasmWithRetries(ctx, retries = 3) {
 }
 function loadWasm(ctx) {
   return __async(this, null, function* () {
-    yield Promise.resolve().then(() => __toESM(require_wasm_exec()));
+    yield import("../wasm/wasm_exec.js");
     global.WebSocket = require("ws");
     const goWasm = new global.Go();
     if (!rawWasm) {
@@ -971,46 +88,48 @@ function executeMessage(ctx, message) {
     const { functionType, params } = message;
     switch (functionType) {
       case "KEYGEN": {
-        const { userId, secretKey, type = import_core_sdk2.WalletType.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 = import_core_sdk2.WalletType.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;
@@ -1019,7 +138,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`);
@@ -1027,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 {
@@ -1043,15 +185,26 @@ function handleMessage(e) {
     const ctx = {
       env,
       apiKey,
-      client: (0, import_core_sdk2.initClient)({ env, version: import_core_sdk2.paraVersion, apiKey, retrieveSessionCookie: () => sessionCookie }),
+      client: (0, import_core_sdk.initClient)({ env, version: import_core_sdk.paraVersion, apiKey, retrieveSessionCookie: () => sessionCookie }),
       offloadMPCComputationURL,
-      mpcComputationClient: offloadMPCComputationURL ? import_core_sdk2.mpcComputationClient.initClient(offloadMPCComputationURL, !!disableWorkers) : void 0,
+      mpcComputationClient: offloadMPCComputationURL ? import_core_sdk.mpcComputationClient.initClient(offloadMPCComputationURL, !!disableWorkers) : void 0,
       useDKLS,
       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;
@@ -1060,5 +213,7 @@ function handleMessage(e) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  handleMessage
+  handleMessage,
+  requestWasmWithRetries,
+  withRetry
 });