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

package/dist/cjs/workers/workerWrapper.js

@@ -0,0 +1,130 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var workerWrapper_exports = {};
+__export(workerWrapper_exports, {
+  resetWorker: () => resetWorker,
+  setupWorker: () => setupWorker
+});
+module.exports = __toCommonJS(workerWrapper_exports);
+var import_worker_threads = require("worker_threads");
+var import_core_sdk = require("@getpara/core-sdk");
+const CLEAR_WORKER_TIMEOUT_MS = 1e3 * 90;
+let worker;
+const resFunctionMap = {};
+function removeWorkId(workId, skipClearTimeout) {
+  const { timeoutId } = resFunctionMap[workId];
+  delete resFunctionMap[workId];
+  if (skipClearTimeout) {
+    return;
+  }
+  clearTimeout(timeoutId);
+}
+function resetWorker() {
+  if (worker) {
+    worker.terminate();
+    worker = void 0;
+  }
+}
+function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
+  return __async(this, null, function* () {
+    const timeoutId = setTimeout(() => {
+      if (resFunctionMap[workId]) {
+        const errorMsg = `worker operation timed out after ${CLEAR_WORKER_TIMEOUT_MS}ms for workId ${workId} and opts ${JSON.stringify(resFunctionMap[workId].errorContext)}`;
+        resFunctionMap[workId].errorFn(new Error(errorMsg));
+        removeWorkId(workId, true);
+      }
+    }, CLEAR_WORKER_TIMEOUT_MS);
+    resFunctionMap[workId] = {
+      fn: resFunction,
+      errorFn: errorFunction,
+      timeoutId,
+      errorContext
+    };
+    if (!worker || !worker.threadId) {
+      const isDeno = typeof (globalThis == null ? void 0 : globalThis.Deno) !== "undefined";
+      const workerFileName = isDeno ? "mpcWorkerServer-esm.js" : "mpcWorkerServer-bundle.js";
+      const workerRes = yield fetch(`${(0, import_core_sdk.getPortalBaseURL)(ctx)}/static/js/${workerFileName}`);
+      worker = new import_worker_threads.Worker(yield workerRes.text(), { eval: true });
+      const onmessage = (message) => __async(this, null, function* () {
+        const { workId: messageWorkId } = message;
+        if (!resFunctionMap[messageWorkId]) {
+          console.warn(`received message for unknown workId: ${messageWorkId}`);
+          return;
+        }
+        delete message.workId;
+        try {
+          yield resFunctionMap[messageWorkId].fn(message);
+          removeWorkId(messageWorkId);
+        } catch (error) {
+          console.error(`error in worker message handler for workId ${messageWorkId}:`, error);
+          if (resFunctionMap[messageWorkId]) {
+            resFunctionMap[messageWorkId].errorFn(error);
+            removeWorkId(messageWorkId);
+          }
+        }
+      });
+      worker.on("message", onmessage);
+      worker.on("error", (err) => {
+        console.error("worker error:", err);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            const errorMsg = `worker error with workId ${id} and opts ${JSON.stringify(resFunctionMap[id].errorContext)}: ${err.message}`;
+            resFunctionMap[id].errorFn(new Error(errorMsg));
+            removeWorkId(id);
+          }
+        });
+      });
+      worker.on("exit", (code) => {
+        console.error(`worker stopped with exit code ${code}`);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            resFunctionMap[id].errorFn(new Error(`worker exited unexpectedly with code ${code}`));
+            removeWorkId(id);
+          }
+        });
+        worker = void 0;
+      });
+    }
+    return worker;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resetWorker,
+  setupWorker
+});

package/dist/esm/ParaServer.js

@@ -0,0 +1,45 @@
+import "./chunk-FTA5RKYX.js";
+import ParaCore, {
+  Environment
+} from "@getpara/core-sdk";
+import * as Sentry from "@sentry/node";
+import { ServerUtils } from "./ServerUtils.js";
+class Para 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"
+      });
+    }
+  }
+  async ready() {
+    this.isReady = true;
+  }
+  getPlatformUtils() {
+    return new ServerUtils();
+  }
+  async isPasskeySupported() {
+    return false;
+  }
+  /**
+   * 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."
+    );
+  }
+}
+export {
+  Para
+};

package/dist/esm/ServerLocalStorage.js

@@ -0,0 +1,26 @@
+import "./chunk-FTA5RKYX.js";
+class ServerLocalStorage {
+  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 (const key of keys) {
+        if (key && key.startsWith(prefix)) {
+          this.removeItem(key);
+        }
+      }
+    };
+  }
+}
+export {
+  ServerLocalStorage
+};

package/dist/esm/ServerSessionStorage.js

@@ -0,0 +1,26 @@
+import "./chunk-FTA5RKYX.js";
+class ServerSessionStorage {
+  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 (const key of keys) {
+        if (key && key.startsWith(prefix)) {
+          this.removeItem(key);
+        }
+      }
+    };
+  }
+}
+export {
+  ServerSessionStorage
+};

package/dist/esm/ServerUtils.js

@@ -0,0 +1,55 @@
+import "./chunk-FTA5RKYX.js";
+import { ServerLocalStorage } from "./ServerLocalStorage.js";
+import { ServerSessionStorage } from "./ServerSessionStorage.js";
+import { keygen, preKeygen, ed25519Keygen, ed25519PreKeygen } from "./wallet/keygen.js";
+import { signMessage, sendTransaction, signTransaction, ed25519Sign } from "./wallet/signing.js";
+import { getPrivateKey } from "./wallet/privateKey.js";
+class ServerUtils {
+  constructor() {
+    this.sdkType = "SERVER";
+    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, 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.");
+  }
+}
+export {
+  ServerUtils
+};

package/dist/esm/chunk-FTA5RKYX.js

@@ -0,0 +1,8 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __commonJS
+};