@getpara/core-sdk 2.0.0-alpha.3 → 2.0.0-alpha.6

package/dist/esm/chunk-7B52C2XE.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+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 {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __async
+};

package/dist/esm/constants.js

@@ -0,0 +1,43 @@
+import "./chunk-7B52C2XE.js";
+const PARA_CORE_VERSION = "2.0.0-alpha.6";
+const PREFIX = "@CAPSULE/";
+const LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;
+const LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
+const LOCAL_STORAGE_PHONE = `${PREFIX}phone`;
+const LOCAL_STORAGE_COUNTRY_CODE = `${PREFIX}countryCode`;
+const LOCAL_STORAGE_FARCASTER_USERNAME = `${PREFIX}farcasterUsername`;
+const LOCAL_STORAGE_TELEGRAM_USER_ID = `${PREFIX}telegramUserId`;
+const LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID = `${PREFIX}externalWalletUserId`;
+const LOCAL_STORAGE_USER_ID = `${PREFIX}userId`;
+const LOCAL_STORAGE_ED25519_WALLETS = `${PREFIX}ed25519Wallets`;
+const LOCAL_STORAGE_WALLETS = `${PREFIX}wallets`;
+const LOCAL_STORAGE_EXTERNAL_WALLETS = `${PREFIX}externalWallets`;
+const LOCAL_STORAGE_CURRENT_WALLET_IDS = `${PREFIX}currentWalletIds`;
+const LOCAL_STORAGE_SESSION_COOKIE = `${PREFIX}sessionCookie`;
+const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = `${PREFIX}loginEncryptionKeyPair`;
+const POLLING_INTERVAL_MS = 2e3;
+const SHORT_POLLING_INTERVAL_MS = 1e3;
+const POLLING_TIMEOUT_MS = 3e5;
+const EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID = "EXTERNAL_WALLET_CONNECTION_ONLY";
+export {
+  EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
+  LOCAL_STORAGE_AUTH_INFO,
+  LOCAL_STORAGE_COUNTRY_CODE,
+  LOCAL_STORAGE_CURRENT_WALLET_IDS,
+  LOCAL_STORAGE_ED25519_WALLETS,
+  LOCAL_STORAGE_EMAIL,
+  LOCAL_STORAGE_EXTERNAL_WALLETS,
+  LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID,
+  LOCAL_STORAGE_FARCASTER_USERNAME,
+  LOCAL_STORAGE_PHONE,
+  LOCAL_STORAGE_SESSION_COOKIE,
+  LOCAL_STORAGE_TELEGRAM_USER_ID,
+  LOCAL_STORAGE_USER_ID,
+  LOCAL_STORAGE_WALLETS,
+  PARA_CORE_VERSION,
+  POLLING_INTERVAL_MS,
+  POLLING_TIMEOUT_MS,
+  PREFIX,
+  SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR,
+  SHORT_POLLING_INTERVAL_MS
+};

package/dist/esm/cryptography/utils.js

@@ -0,0 +1,282 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import base64url from "base64url";
+import forge from "node-forge";
+import { getPortalBaseURL } from "../utils/index.js";
+const rsa = forge.pki.rsa;
+const RSA_ENCRYPTION_SCHEME = "RSA-OAEP";
+const CONSTANT_IV = "794241bc819a125a7b78ea313decc0bc";
+const CONSTANT_IV_AES = new Uint8Array([23, 66, 157, 146, 179, 158, 117, 120, 184, 73, 123, 81]);
+function getSHA256HashHex(str) {
+  const md = forge.md.sha256.create();
+  md.update(str);
+  return md.digest().toHex();
+}
+function getPublicKeyHex(keyPair) {
+  const pem = forge.pki.publicKeyToRSAPublicKeyPem(keyPair.publicKey);
+  return Buffer.from(pem, "utf-8").toString("hex");
+}
+function publicKeyFromHex(publicKeyHex) {
+  const pem = publicKeyHexToPem(publicKeyHex);
+  return forge.pki.publicKeyFromPem(pem);
+}
+function publicKeyHexToPem(publicKeyHex) {
+  return Buffer.from(publicKeyHex, "hex").toString("utf-8");
+}
+function encodePrivateKeyToPemHex(keyPair) {
+  const pem = forge.pki.privateKeyToPem(keyPair.privateKey);
+  return Buffer.from(pem, "utf-8").toString("hex");
+}
+function decodePrivateKeyPemHex(privateKeyPemHex) {
+  const pem = Buffer.from(privateKeyPemHex, "hex").toString("utf-8");
+  return forge.pki.privateKeyFromPem(pem);
+}
+function encryptPrivateKey(keyPair, key) {
+  return __async(this, null, function* () {
+    const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
+    const cryptoKey = yield window.crypto.subtle.importKey(
+      "raw",
+      Buffer.from(key, "base64"),
+      {
+        name: "AES-GCM",
+        length: 256
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    const encodedPlaintext = new TextEncoder().encode(privateKeyPemHex);
+    const ciphertext = yield window.crypto.subtle.encrypt(
+      { name: "AES-GCM", iv: CONSTANT_IV_AES },
+      cryptoKey,
+      encodedPlaintext
+    );
+    return Buffer.from(ciphertext).toString("base64");
+  });
+}
+function decryptPrivateKey(encryptedPrivateKeyPemHex, key) {
+  return __async(this, null, function* () {
+    const secretKey = yield crypto.subtle.importKey(
+      "raw",
+      Buffer.from(key, "base64"),
+      {
+        name: "AES-GCM",
+        length: 256
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    const cleartext = yield crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: CONSTANT_IV_AES },
+      secretKey,
+      Buffer.from(encryptedPrivateKeyPemHex, "base64")
+    );
+    const privateKeyPemHex = new TextDecoder().decode(cleartext);
+    const privateKey = decodePrivateKeyPemHex(privateKeyPemHex);
+    return privateKey;
+  });
+}
+function getAsymmetricKeyPair(ctx, seedValue) {
+  return __async(this, null, function* () {
+    const prng = forge.random.createInstance();
+    if (seedValue) {
+      prng.seedFileSync = (_n) => seedValue;
+      prng.seedFile = (_n, cb) => {
+        cb(null, seedValue);
+      };
+    }
+    const options = {
+      bits: 2048,
+      e: 65537,
+      prng
+    };
+    if (!ctx.disableWorkers) {
+      options.workLoad = 100;
+      options.workers = seedValue ? 1 : -1;
+      const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/prime.worker.min.js`);
+      const workerBlob = new Blob([yield workerRes.text()], { type: "application/javascript" });
+      options.workerScript = URL.createObjectURL(workerBlob);
+    }
+    return new Promise(
+      (resolve, reject) => rsa.generateKeyPair(options, (err, keypair) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(keypair);
+      })
+    );
+  });
+}
+function getPublicKeyFromSignature(ctx, userHandle) {
+  return __async(this, null, function* () {
+    const encodedUserHandle = base64url.encode(userHandle);
+    const keyPair = yield getAsymmetricKeyPair(ctx, encodedUserHandle);
+    return getPublicKeyHex(keyPair);
+  });
+}
+function symmetricKeyEncryptMessage(message) {
+  const key = forge.random.getBytesSync(16);
+  const cipher = forge.cipher.createCipher("AES-CBC", key);
+  cipher.start({ iv: CONSTANT_IV });
+  cipher.update(forge.util.createBuffer(message));
+  cipher.finish();
+  const encryptedMessageHex = cipher.output.toHex();
+  return { key, encryptedMessageHex };
+}
+function decipherEncryptedMessageHex(key, encryptedMessageHex) {
+  const decipher = forge.cipher.createDecipher("AES-CBC", key);
+  decipher.start({ iv: CONSTANT_IV });
+  decipher.update(forge.util.createBuffer(forge.util.hexToBytes(encryptedMessageHex)));
+  decipher.finish();
+  return decipher.output.toString();
+}
+function decryptWithKeyPair(keyPair, encryptedMessageHex, encryptedKeyHex) {
+  const encryptedKey = Buffer.from(encryptedKeyHex, "hex").toString("utf-8");
+  const key = keyPair.privateKey.decrypt(encryptedKey, RSA_ENCRYPTION_SCHEME);
+  return decipherEncryptedMessageHex(key, encryptedMessageHex);
+}
+function decryptWithPrivateKey(privateKey, encryptedMessageHex, encryptedKeyHex) {
+  const encryptedKey = Buffer.from(encryptedKeyHex, "hex").toString("utf-8");
+  const key = privateKey.decrypt(encryptedKey, RSA_ENCRYPTION_SCHEME);
+  return decipherEncryptedMessageHex(key, encryptedMessageHex);
+}
+function decryptWithDerivedPrivateKey(_0, _1) {
+  return __async(this, arguments, function* (ctx, {
+    seedValue,
+    encryptedMessageHex,
+    encryptedKeyHex
+  }) {
+    const keyPair = yield getAsymmetricKeyPair(ctx, seedValue);
+    return decryptWithPrivateKey(keyPair.privateKey, encryptedMessageHex, encryptedKeyHex);
+  });
+}
+function getDerivedPrivateKeyAndDecrypt(ctx, seedValue, encryptedShares) {
+  return __async(this, null, function* () {
+    return Promise.all(
+      encryptedShares.map((share) => __async(this, null, function* () {
+        return {
+          walletId: share.walletId,
+          walletScheme: share.walletScheme,
+          partnerId: share.partnerId,
+          signer: yield decryptWithDerivedPrivateKey(ctx, {
+            seedValue,
+            encryptedMessageHex: share.encryptedShare,
+            encryptedKeyHex: share.encryptedKey
+          }),
+          protocolId: share.protocolId
+        };
+      }))
+    );
+  });
+}
+function decryptPrivateKeyAndDecryptShare(encryptionKey, encryptedShares, encryptedPrivateKey) {
+  return __async(this, null, function* () {
+    let privateKey;
+    try {
+      privateKey = yield decryptPrivateKey(encryptedPrivateKey, encryptionKey);
+    } catch (e) {
+    }
+    try {
+      privateKey = yield decryptPrivateKeyWithPassword(encryptedPrivateKey, encryptionKey);
+    } catch (e) {
+    }
+    if (!privateKey) {
+      throw new Error("Could not decrypt private key");
+    }
+    return encryptedShares.map((share) => ({
+      walletId: share.walletId,
+      walletScheme: share.walletScheme,
+      partnerId: share.partnerId,
+      signer: decryptWithPrivateKey(privateKey, share.encryptedShare, share.encryptedKey),
+      protocolId: share.protocolId
+    }));
+  });
+}
+function encryptWithDerivedPublicKey(publicKeyHex, message) {
+  const { key, encryptedMessageHex } = symmetricKeyEncryptMessage(message);
+  const publicKeyPem = publicKeyHexToPem(publicKeyHex);
+  const publicKey = forge.pki.publicKeyFromPem(publicKeyPem);
+  const encryptedKey = publicKey.encrypt(key, RSA_ENCRYPTION_SCHEME);
+  const encryptedKeyHex = Buffer.from(encryptedKey, "utf-8").toString("hex");
+  return { encryptedMessageHex, encryptedKeyHex };
+}
+function hashPasswordWithSalt(password) {
+  const salt = generateSalt();
+  const saltedPassword = salt + password;
+  const hash = getSHA256HashHex(saltedPassword);
+  return { salt, hash };
+}
+function generateSalt(length = 16) {
+  return forge.util.bytesToHex(forge.random.getBytesSync(length));
+}
+function deriveCryptoKeyFromPassword(hashedPassword) {
+  return __async(this, null, function* () {
+    const keyBuffer = Buffer.from(hashedPassword, "hex");
+    return yield window.crypto.subtle.importKey(
+      "raw",
+      keyBuffer,
+      {
+        name: "AES-GCM",
+        length: 256
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+  });
+}
+function encryptPrivateKeyWithPassword(keyPair, hashedPassword) {
+  return __async(this, null, function* () {
+    const cryptoKey = yield deriveCryptoKeyFromPassword(hashedPassword);
+    const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
+    const encodedPlaintext = new TextEncoder().encode(privateKeyPemHex);
+    const ciphertext = yield window.crypto.subtle.encrypt(
+      { name: "AES-GCM", iv: CONSTANT_IV_AES },
+      cryptoKey,
+      encodedPlaintext
+    );
+    return Buffer.from(ciphertext).toString("base64");
+  });
+}
+function decryptPrivateKeyWithPassword(encryptedPrivateKeyPemHex, hashedPassword) {
+  return __async(this, null, function* () {
+    const secretKey = yield crypto.subtle.importKey(
+      "raw",
+      Buffer.from(hashedPassword, "hex"),
+      {
+        name: "AES-GCM",
+        length: 256
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    const cleartext = yield crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: CONSTANT_IV_AES },
+      secretKey,
+      Buffer.from(encryptedPrivateKeyPemHex, "base64")
+    );
+    const privateKeyPemHex = new TextDecoder().decode(cleartext);
+    const privateKey = decodePrivateKeyPemHex(privateKeyPemHex);
+    return privateKey;
+  });
+}
+export {
+  decodePrivateKeyPemHex,
+  decryptPrivateKey,
+  decryptPrivateKeyAndDecryptShare,
+  decryptPrivateKeyWithPassword,
+  decryptWithKeyPair,
+  decryptWithPrivateKey,
+  encodePrivateKeyToPemHex,
+  encryptPrivateKey,
+  encryptPrivateKeyWithPassword,
+  encryptWithDerivedPublicKey,
+  getAsymmetricKeyPair,
+  getDerivedPrivateKeyAndDecrypt,
+  getPublicKeyFromSignature,
+  getPublicKeyHex,
+  getSHA256HashHex,
+  hashPasswordWithSalt,
+  publicKeyFromHex,
+  publicKeyHexToPem,
+  symmetricKeyEncryptMessage
+};

package/dist/esm/errors.js

@@ -0,0 +1,27 @@
+import "./chunk-7B52C2XE.js";
+class TransactionReviewError extends Error {
+  constructor(transactionReviewUrl) {
+    super("transaction review error");
+    this.name = "TransactionReviewError";
+    this.transactionReviewUrl = transactionReviewUrl;
+  }
+}
+class TransactionReviewDenied extends Error {
+  constructor() {
+    super("transaction review has been denied by the user");
+    this.name = "TransactionReviewDenied";
+  }
+}
+class TransactionReviewTimeout extends Error {
+  constructor(transactionReviewUrl, pendingTransactionId) {
+    super("transaction review has timed out");
+    this.name = "TransactionReviewTimeout";
+    this.transactionReviewUrl = transactionReviewUrl;
+    this.pendingTransactionId = pendingTransactionId;
+  }
+}
+export {
+  TransactionReviewDenied,
+  TransactionReviewError,
+  TransactionReviewTimeout
+};

package/dist/esm/external/mpcComputationClient.js

@@ -0,0 +1,30 @@
+import "../chunk-7B52C2XE.js";
+import axios from "axios";
+function initClient(baseURL, useAdapter) {
+  const client = axios.create({ baseURL });
+  if (useAdapter) {
+    client.defaults.adapter = function(config) {
+      return fetch(config.baseURL + config.url, {
+        method: config.method,
+        headers: config.headers,
+        body: config.data,
+        credentials: config.withCredentials ? "include" : void 0
+      }).then(
+        (response) => response.text().then((text) => ({
+          data: text,
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+          config,
+          request: fetch
+        }))
+      ).catch(function(reason) {
+        throw reason;
+      });
+    };
+  }
+  return client;
+}
+export {
+  initClient
+};

package/dist/esm/external/userManagementClient.js

@@ -0,0 +1,71 @@
+import "../chunk-7B52C2XE.js";
+import Client from "@getpara/user-management-client";
+import { Environment } from "../types/index.js";
+function getBaseOAuthUrl(env) {
+  switch (env) {
+    case Environment.DEV:
+      return "http://localhost:8080/";
+    case Environment.SANDBOX:
+      return "https://api.sandbox.usecapsule.com/";
+    case Environment.BETA:
+      return "https://api.beta.usecapsule.com/";
+    case Environment.PROD:
+      return "https://api.usecapsule.com/";
+    default:
+      throw new Error(`unsupported env: ${env}`);
+  }
+}
+function getBaseUrl(env) {
+  switch (env) {
+    case Environment.DEV:
+      return "http://localhost:8080/";
+    case Environment.SANDBOX:
+      return "https://api.sandbox.getpara.com/";
+    case Environment.BETA:
+      return "https://api.beta.getpara.com/";
+    case Environment.PROD:
+      return "https://api.getpara.com/";
+    default:
+      throw new Error(`unsupported env: ${env}`);
+  }
+}
+function getBaseMPCNetworkUrl(env, useWebsocket) {
+  const prefix = useWebsocket ? "ws" : "http";
+  switch (env) {
+    case Environment.DEV:
+      return `${prefix}://localhost:3000`;
+    case Environment.SANDBOX:
+      return `${prefix}s://mpc-network.sandbox.getpara.com`;
+    case Environment.BETA:
+      return `${prefix}s://mpc-network.beta.getpara.com`;
+    case Environment.PROD:
+      return `${prefix}s://mpc-network.prod.getpara.com`;
+    default:
+      throw new Error(`unsupported env: ${env}`);
+  }
+}
+function initClient({
+  env,
+  version,
+  apiKey,
+  partnerId,
+  useFetchAdapter = false,
+  retrieveSessionCookie,
+  persistSessionCookie
+}) {
+  return new Client({
+    userManagementHost: getBaseUrl(env),
+    version: [Environment.DEV, Environment.SANDBOX].includes(env) ? "dev" : version,
+    apiKey,
+    partnerId,
+    opts: { useFetchAdapter },
+    retrieveSessionCookie,
+    persistSessionCookie
+  });
+}
+export {
+  getBaseMPCNetworkUrl,
+  getBaseOAuthUrl,
+  getBaseUrl,
+  initClient
+};