@getpara/server-sdk 1.8.0 → 2.0.0-alpha.3

package/dist/esm/index.js

@@ -1,8 +1,472 @@
-import "./chunk-FTA5RKYX.js";
+// src/index.ts
 export * from "@getpara/core-sdk";
-import { Para as ParaServer } from "./ParaServer.js";
-var src_default = ParaServer;
+
+// src/ParaServer.ts
+import ParaCore, {
+  Environment
+} from "@getpara/core-sdk";
+import * as Sentry from "@sentry/node";
+
+// src/ServerLocalStorage.ts
+var ServerLocalStorage = class {
+  constructor() {
+    this.localStorage = {};
+    this.get = (key) => {
+      return this.localStorage[key] || null;
+    };
+    this.set = (key, value) => {
+      this.localStorage[key] = value;
+    };
+    this.removeItem = (key) => {
+      delete this.localStorage[key];
+    };
+    this.clear = (prefix) => {
+      const keys = Object.keys(this.localStorage);
+      for (let key in keys) {
+        if (key && key.startsWith(prefix)) {
+          this.removeItem(key);
+        }
+      }
+    };
+  }
+};
+
+// src/ServerSessionStorage.ts
+var ServerSessionStorage = class {
+  constructor() {
+    this.sessionStorage = {};
+    this.get = (key) => {
+      return this.sessionStorage[key] || null;
+    };
+    this.set = (key, value) => {
+      this.sessionStorage[key] = value;
+    };
+    this.removeItem = (key) => {
+      delete this.sessionStorage[key];
+    };
+    this.clear = (prefix) => {
+      const keys = Object.keys(this.sessionStorage);
+      for (let key in keys) {
+        if (key && key.startsWith(prefix)) {
+          this.removeItem(key);
+        }
+      }
+    };
+  }
+};
+
+// src/wallet/keygen.ts
+import * as uuid from "uuid";
+import { waitUntilTrue } from "@getpara/core-sdk";
+
+// src/workers/workerWrapper.ts
+import { Worker } from "worker_threads";
+import { getPortalBaseURL } from "@getpara/core-sdk";
+var CLEAR_WORKER_TIMEOUT_MS = 1e3 * 90;
+var worker;
+var resFunctionMap = {};
+function removeWorkId(workId, skipClearTimeout) {
+  const { timeoutId } = resFunctionMap[workId];
+  delete resFunctionMap[workId];
+  if (skipClearTimeout) {
+    return;
+  }
+  clearTimeout(timeoutId);
+}
+async function setupWorker(ctx, resFunction, workId) {
+  const timeoutId = setTimeout(() => {
+    removeWorkId(workId, true);
+  }, CLEAR_WORKER_TIMEOUT_MS);
+  resFunctionMap[workId] = {
+    fn: resFunction,
+    timeoutId
+  };
+  if (!worker || !worker.threadId) {
+    const workerRes = await fetch(`${getPortalBaseURL(ctx)}/static/js/mpcWorkerServer-bundle.js`);
+    worker = new Worker(await workerRes.text(), { eval: true });
+    const onmessage = async (message) => {
+      const { workId: messageWorkId } = message;
+      delete message.workId;
+      await resFunctionMap[messageWorkId].fn(message);
+      removeWorkId(messageWorkId);
+    };
+    worker.on("message", onmessage);
+    worker.on("error", (err) => {
+      throw err;
+    });
+    worker.on("exit", (code) => {
+      console.error(`worker stopped with exit code ${code}`);
+    });
+  }
+  return worker;
+}
+
+// src/wallet/keygen.ts
+async function isKeygenComplete(ctx, userId, walletId) {
+  const wallets = await ctx.client.getWallets(userId);
+  const wallet = wallets.data.wallets.find((w) => w.id === walletId);
+  return !!wallet.address;
+}
+async function isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, walletId) {
+  const wallets = await ctx.client.getPregenWallets({ [pregenIdentifierType]: [pregenIdentifier] });
+  const wallet = wallets.wallets.find((w) => w.id === walletId);
+  return !!wallet?.address;
+}
+function keygen(ctx, userId, type, secretKey, skipDistribute = false, sessionCookie, _emailProps = {}) {
+  return new Promise(async (resolve) => {
+    const workId = uuid.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (res) => {
+        await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
+        if (skipDistribute) {
+          resolve({
+            signer: res.signer,
+            walletId: res.walletId,
+            recoveryShare: null
+          });
+        }
+      },
+      workId
+    );
+    worker2.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params: { userId, secretKey, type },
+      functionType: "KEYGEN",
+      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  });
+}
+function preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, _skipDistribute = false, partnerId, sessionCookie) {
+  return new Promise(async (resolve) => {
+    const workId = uuid.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (res) => {
+        await waitUntilTrue(
+          async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
+          15e3,
+          1e3
+        );
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      },
+      workId
+    );
+    const email = void 0;
+    const params = { pregenIdentifier, pregenIdentifierType, secretKey, partnerId, email, type };
+    if (pregenIdentifierType === "EMAIL") {
+      params.email = pregenIdentifier;
+    }
+    worker2.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params,
+      functionType: "PREKEYGEN",
+      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  });
+}
+function ed25519Keygen(ctx, userId, sessionCookie, _emailProps = {}) {
+  return new Promise(async (resolve) => {
+    const workId = uuid.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (res) => {
+        await waitUntilTrue(async () => isKeygenComplete(ctx, userId, res.walletId), 15e3, 1e3);
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      },
+      workId
+    );
+    worker2.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params: { userId },
+      functionType: "ED25519_KEYGEN",
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  });
+}
+function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+  return new Promise(async (resolve) => {
+    const workId = uuid.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (res) => {
+        await waitUntilTrue(
+          async () => isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId),
+          15e3,
+          1e3
+        );
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      },
+      workId
+    );
+    const email = void 0;
+    const params = { pregenIdentifier, pregenIdentifierType, email };
+    if (pregenIdentifierType === "EMAIL") {
+      params.email = pregenIdentifier;
+    }
+    worker2.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params,
+      functionType: "ED25519_PREKEYGEN",
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  });
+}
+
+// src/wallet/signing.ts
+import * as uuid2 from "uuid";
+async function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return await new Promise(async (resolve) => {
+    const workId = uuid2.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (sendTransactionRes) => {
+        resolve(sendTransactionRes);
+      },
+      workId
+    );
+    worker2.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
+    });
+  });
+}
+async function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return await new Promise(async (resolve) => {
+    const workId = uuid2.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (sendTransactionRes) => {
+        resolve(sendTransactionRes);
+      },
+      workId
+    );
+    worker2.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
+    });
+  });
+}
+async function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
+  return await new Promise(async (resolve) => {
+    const workId = uuid2.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (signMessageRes) => {
+        resolve(signMessageRes);
+      },
+      workId
+    );
+    worker2.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
+    });
+  });
+}
+async function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+  return await new Promise(async (resolve) => {
+    const workId = uuid2.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (signMessageRes) => {
+        resolve(signMessageRes);
+      },
+      workId
+    );
+    worker2.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
+    });
+  });
+}
+
+// src/wallet/privateKey.ts
+import * as uuid3 from "uuid";
+async function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+  return await new Promise(async (resolve) => {
+    const workId = uuid3.v4();
+    const worker2 = await setupWorker(
+      ctx,
+      async (res) => {
+        resolve(res);
+      },
+      workId
+    );
+    worker2.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params: { share, walletId, userId },
+      functionType: "GET_PRIVATE_KEY",
+      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  });
+}
+
+// src/ServerUtils.ts
+var ServerUtils = class {
+  constructor() {
+    this.localStorage = new ServerLocalStorage();
+    this.sessionStorage = new ServerSessionStorage();
+    this.secureStorage = void 0;
+    this.isSyncStorage = true;
+    this.disableProviderModal = true;
+  }
+  getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+    return getPrivateKey(ctx, userId, walletId, share, sessionCookie);
+  }
+  keygen(ctx, userId, type, secretKey, sessionCookie, emailProps) {
+    return keygen(ctx, userId, type, secretKey, true, sessionCookie, emailProps);
+  }
+  refresh(_ctx, _sessionCookie, _userId, _walletId, _share, _oldPartnerId, _newPartnerId) {
+    throw new Error("Refresh function is not implemented in the ServerUtils class.");
+  }
+  preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey, sessionCookie) {
+    return preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, false, partnerId, sessionCookie);
+  }
+  signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
+    return signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS);
+  }
+  signTransaction(ctx, userId, walletId, share, message, chainId, sessionCookie, isDKLS) {
+    return signTransaction(ctx, userId, walletId, share, message, chainId, sessionCookie, isDKLS);
+  }
+  sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+    return sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS);
+  }
+  signHash(_address, _hash) {
+    throw new Error("SignHash is not implemented in the ServerUtils class.");
+  }
+  ed25519Keygen(ctx, userId, sessionCookie, emailProps) {
+    return ed25519Keygen(ctx, userId, sessionCookie, emailProps);
+  }
+  ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+    return ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie);
+  }
+  ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+    return ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie);
+  }
+  openPopup(_popupUrl) {
+    throw new Error("OpenPopup is not implemented in the ServerUtils class.");
+  }
+};
+
+// src/ParaServer.ts
+var Para = class extends ParaCore {
+  constructor(env, apiKey, opts) {
+    super(env, apiKey, opts);
+    if (env !== Environment.PROD && env !== Environment.DEV) {
+      Sentry.init({
+        environment: env.toLowerCase(),
+        dsn: "https://2a26842d951255c2721fde5c1dd2b252@o4504568036720640.ingest.us.sentry.io/4508850906791936"
+      });
+    }
+  }
+  getPlatformUtils() {
+    return new ServerUtils();
+  }
+  /**
+   * Claims a pregenerated wallet.
+   *
+   * NOTE: This function is only available on the client side.
+   * When called from the server SDK, it throws an error.
+   *
+   * @param {Object} opts the options object.
+   * @param {string} opts.pregenIdentifier - the identifier of the user claiming the wallet.
+   * @param {TPregenIdentifierType} opts.pregenIdentifierType - the type of the identifier.
+   * @returns {Promise<string | undefined>} A promise that rejects with an error.
+   */
+  async claimPregenWallets(_) {
+    throw new Error(
+      "claimPregenWallets is not available in the server SDK. This function is only supported on the client side. Please ensure you are using the client SDK to call this method."
+    );
+  }
+};
+
+// src/index.ts
+var src_default = Para;
 export {
-  ParaServer as Para,
+  Para,
   src_default as default
 };

package/dist/esm/workers/chunk-ILICZWQV.js

@@ -0,0 +1,36 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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());
+  });
+};
+
+export {
+  __require,
+  __commonJS,
+  __async
+};

package/dist/esm/{wasm/wasm_exec.js → workers/wasm_exec-CFNSOXDO.js}

@@ -1,13 +1,17 @@
 import {
-  __commonJS
-} from "../chunk-FTA5RKYX.js";
+  __async,
+  __commonJS,
+  __require
+} from "./chunk-ILICZWQV.js";
+
+// src/wasm/wasm_exec.js
 var require_wasm_exec = __commonJS({
   "src/wasm/wasm_exec.js"(exports, module) {
-    const globalThisCopy = global;
+    var globalThisCopy = global;
     if (!globalThisCopy.crypto) {
-      globalThisCopy.crypto = require("crypto");
+      globalThisCopy.crypto = __require("crypto");
     }
-    const crypto = globalThisCopy.crypto;
+    var crypto = globalThisCopy.crypto;
     (() => {
       const enosys = () => {
         const err = new Error("not implemented");
@@ -480,71 +484,73 @@ var require_wasm_exec = __commonJS({
             }
           };
         }
-        async run(instance) {
-          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;
+        run(instance) {
+          return __async(this, null, function* () {
+            if (!(instance instanceof WebAssembly.Instance)) {
+              throw new Error("Go.run: WebAssembly.Instance expected");
             }
-            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;
+            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;
           });
-          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();
-          }
-          await this._exitPromise;
         }
         _resume() {
           if (this.exited) {