@getpara/core-sdk 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

package/dist/esm/shares/KeyContainer.js

@@ -0,0 +1,57 @@
+import "../chunk-7B52C2XE.js";
+import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
+import * as eutil from "@ethereumjs/util";
+import * as forge from "node-forge";
+class KeyContainer {
+  constructor(walletId, keyshare, address) {
+    this.walletId = walletId;
+    this.keyshare = keyshare;
+    this.address = address;
+    this.backupDecryptionKey = Buffer.from(forge.random.getBytesSync(32), "binary").toString("hex");
+  }
+  static buildFrom(serializedContainer) {
+    try {
+      const parsedObject = JSON.parse(serializedContainer);
+      return Object.assign(new KeyContainer("", "", ""), parsedObject);
+    } catch (e) {
+      const container = new KeyContainer("", "", "");
+      container.backupDecryptionKey = serializedContainer.split("|")[0];
+      return container;
+    }
+  }
+  getPublicEncryptionKey() {
+    return Buffer.from(eutil.privateToPublic(Buffer.from(this.backupDecryptionKey, "hex")));
+  }
+  getPublicEncryptionKeyHex() {
+    return this.getPublicEncryptionKey().toString("hex");
+  }
+  encryptForSelf(backup) {
+    try {
+      const pubkey = this.getPublicEncryptionKey();
+      const data = ECIESEncrypt(pubkey, Buffer.from(backup, "ucs2")).toString("base64");
+      return data;
+    } catch (error) {
+      throw Error("Error encrypting backup");
+    }
+  }
+  static encryptWithPublicKey(publicKey, backup) {
+    try {
+      const data = ECIESEncrypt(publicKey, Buffer.from(backup, "ucs2")).toString("base64");
+      return data;
+    } catch (error) {
+      throw Error("Error encrypting backup");
+    }
+  }
+  decrypt(encryptedBackup) {
+    try {
+      const buf = Buffer.from(encryptedBackup, "base64");
+      const data = ECIESDecrypt(Buffer.from(this.backupDecryptionKey, "hex"), buf);
+      return Buffer.from(data.buffer).toString("ucs2");
+    } catch (error) {
+      throw Error("Error decrypting backup");
+    }
+  }
+}
+export {
+  KeyContainer
+};

package/dist/esm/shares/recovery.js

@@ -0,0 +1,74 @@
+import {
+  __async,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
+import { KeyContainer } from "./KeyContainer.js";
+function sendRecoveryForShare(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    userId,
+    walletId,
+    otherEncryptedShares = [],
+    userSigner,
+    ignoreRedistributingBackupEncryptedShare = false,
+    emailProps = {},
+    forceRefresh = false
+  }) {
+    if (ignoreRedistributingBackupEncryptedShare) {
+      yield ctx.client.uploadUserKeyShares(
+        userId,
+        otherEncryptedShares.map((share) => __spreadValues({
+          walletId
+        }, share))
+      );
+      return "";
+    }
+    let userBackupKeyShareOptsArr;
+    let recoveryPrivateKeyContainer;
+    const { recoveryPublicKeys } = yield ctx.client.getRecoveryPublicKeys(userId);
+    if (forceRefresh || !(recoveryPublicKeys == null ? void 0 : recoveryPublicKeys.length)) {
+      recoveryPrivateKeyContainer = new KeyContainer(walletId, "", "");
+      const { recoveryPublicKeys: recoveryPublicKeys2 } = yield ctx.client.persistRecoveryPublicKeys(userId, [
+        recoveryPrivateKeyContainer.getPublicEncryptionKeyHex()
+      ]);
+      const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
+      userBackupKeyShareOptsArr = [
+        {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId: recoveryPublicKeys2[0].id
+        }
+      ];
+    } else {
+      userBackupKeyShareOptsArr = recoveryPublicKeys.map((recoveryPublicKey) => {
+        const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
+        const encryptedUserBackup = KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, "hex"), userSigner);
+        return {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId
+        };
+      });
+    }
+    yield ctx.client.uploadUserKeyShares(userId, [
+      ...otherEncryptedShares.map((share) => __spreadValues({
+        walletId
+      }, share)),
+      ...ignoreRedistributingBackupEncryptedShare ? [] : userBackupKeyShareOptsArr
+    ]);
+    yield ctx.client.distributeParaShare(__spreadValues({
+      userId,
+      walletId,
+      useDKLS: ctx.useDKLS
+    }, emailProps));
+    return recoveryPrivateKeyContainer ? JSON.stringify(recoveryPrivateKeyContainer) : "";
+  });
+}
+export {
+  sendRecoveryForShare
+};

package/dist/esm/shares/shareDistribution.js

@@ -0,0 +1,64 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
+import { encryptWithDerivedPublicKey } from "../cryptography/utils.js";
+import { sendRecoveryForShare } from "./recovery.js";
+function distributeNewShare(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    userId,
+    walletId,
+    userShare,
+    ignoreRedistributingBackupEncryptedShare = false,
+    emailProps = {},
+    partnerId,
+    protocolId
+  }) {
+    const publicKeysRes = yield ctx.client.getSessionPublicKeys(userId);
+    const biometricEncryptedShares = publicKeysRes.data.keys.map((key) => {
+      if (!key.publicKey) {
+        return;
+      }
+      const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(key.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: KeyShareType.USER,
+        encryptor: EncryptorType.BIOMETRICS,
+        biometricPublicKey: key.sigDerivedPublicKey,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const passwords = yield ctx.client.getPasswords({ userId });
+    const passwordEncryptedShares = passwords.map((password) => {
+      if (password.status === "PENDING") {
+        return;
+      }
+      const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(password.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: KeyShareType.USER,
+        encryptor: EncryptorType.PASSWORD,
+        passwordId: password.id,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
+    return yield sendRecoveryForShare({
+      ctx,
+      userId,
+      walletId,
+      otherEncryptedShares: allEncryptedShares,
+      userSigner: userShare,
+      ignoreRedistributingBackupEncryptedShare,
+      emailProps
+    });
+  });
+}
+export {
+  distributeNewShare
+};

package/dist/esm/transmission/transmissionUtils.js

@@ -0,0 +1,42 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
+import { Buffer } from "buffer";
+import * as eutil from "@ethereumjs/util";
+import { randomBytes } from "crypto";
+function upload(message, userManagementClient) {
+  return __async(this, null, function* () {
+    let secret;
+    let publicKeyUint8Array;
+    while (true) {
+      try {
+        secret = randomBytes(32).toString("hex");
+        publicKeyUint8Array = eutil.privateToPublic(Buffer.from(secret, "hex"));
+        break;
+      } catch (e) {
+        continue;
+      }
+    }
+    const pubkey = Buffer.from(publicKeyUint8Array);
+    const data = ECIESEncrypt(pubkey, Buffer.from(message, "ucs2")).toString("base64");
+    const {
+      data: { id }
+    } = yield userManagementClient.tempTrasmissionInit(data);
+    return encodeURIComponent(id + "|" + secret);
+  });
+}
+function retrieve(uriEncodedMessage, userManagementClient) {
+  return __async(this, null, function* () {
+    const [id, secret] = decodeURIComponent(uriEncodedMessage).split("|");
+    const response = yield userManagementClient.tempTrasmission(id);
+    const data = response.data.message;
+    const buf = Buffer.from(data, "base64");
+    const res = Buffer.from(ECIESDecrypt(Buffer.from(secret, "hex"), buf).buffer).toString("ucs2");
+    return res;
+  });
+}
+export {
+  retrieve,
+  upload
+};

package/dist/esm/types/auth.js

@@ -0,0 +1,11 @@
+import "../chunk-7B52C2XE.js";
+var AccountLinkError = /* @__PURE__ */ ((AccountLinkError2) => {
+  AccountLinkError2["NotAuthenticated"] = "No user is currently authenticated";
+  AccountLinkError2["Conflict"] = "Account already linked";
+  AccountLinkError2["Canceled"] = "Account linking was canceled";
+  AccountLinkError2["Unknown"] = "An unknown error occurred";
+  return AccountLinkError2;
+})(AccountLinkError || {});
+export {
+  AccountLinkError
+};

package/dist/esm/types/config.js

@@ -0,0 +1,20 @@
+import "../chunk-7B52C2XE.js";
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["DEV"] = "DEV";
+  Environment2["SANDBOX"] = "SANDBOX";
+  Environment2["BETA"] = "BETA";
+  Environment2["PROD"] = "PROD";
+  Environment2["DEVELOPMENT"] = "BETA";
+  Environment2["PRODUCTION"] = "PROD";
+  return Environment2;
+})(Environment || {});
+var EnabledFlow = /* @__PURE__ */ ((EnabledFlow2) => {
+  EnabledFlow2["BUY"] = "BUY";
+  EnabledFlow2["RECEIVE"] = "RECEIVE";
+  EnabledFlow2["WITHDRAW"] = "WITHDRAW";
+  return EnabledFlow2;
+})(EnabledFlow || {});
+export {
+  EnabledFlow,
+  Environment
+};

package/dist/esm/types/coreApi.js

@@ -0,0 +1,66 @@
+import "../chunk-7B52C2XE.js";
+const PARA_CORE_METHODS = [
+  "getAuthInfo",
+  "signUpOrLogIn",
+  "verifyNewAccount",
+  "waitForLogin",
+  "waitForSignup",
+  "waitForWalletCreation",
+  "getOAuthUrl",
+  "verifyOAuth",
+  "getFarcasterConnectUri",
+  "verifyFarcaster",
+  "verifyTelegram",
+  "resendVerificationCode",
+  "loginExternalWallet",
+  "verifyExternalWallet",
+  "setup2fa",
+  "enable2fa",
+  "verify2fa",
+  "logout",
+  "clearStorage",
+  "isSessionActive",
+  "isFullyLoggedIn",
+  "refreshSession",
+  "keepSessionAlive",
+  "exportSession",
+  "importSession",
+  "getVerificationToken",
+  "getWallets",
+  "getWalletsByType",
+  "fetchWallets",
+  "createWallet",
+  "createWalletPerType",
+  "getPregenWallets",
+  "hasPregenWallet",
+  "updatePregenWalletIdentifier",
+  "createPregenWallet",
+  "createPregenWalletPerType",
+  "claimPregenWallets",
+  "createGuestWallets",
+  "distributeNewWalletShare",
+  "getUserShare",
+  "setUserShare",
+  "refreshShare",
+  "signMessage",
+  "signTransaction",
+  "initiateOnRampTransaction",
+  "getWalletBalance",
+  "issueJwt",
+  "getLinkedAccounts",
+  "accountLinkInProgress"
+];
+const PARA_INTERNAL_METHODS = [
+  "linkAccount",
+  "unlinkAccount",
+  "verifyEmailOrPhoneLink",
+  "verifyOAuthLink",
+  "verifyFarcasterLink",
+  "verifyTelegramLink",
+  "verifyExternalWalletLink",
+  "accountLinkInProgress"
+];
+export {
+  PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS
+};

package/dist/esm/types/events.js

@@ -0,0 +1,19 @@
+import "../chunk-7B52C2XE.js";
+const EVENT_PREFIX = "para";
+var ParaEvent = ((ParaEvent2) => {
+  ParaEvent2["LOGIN_EVENT"] = `${EVENT_PREFIX}Login`;
+  ParaEvent2["ACCOUNT_CREATION_EVENT"] = `${EVENT_PREFIX}AccountCreation`;
+  ParaEvent2["ACCOUNT_SETUP_EVENT"] = `${EVENT_PREFIX}AccountSetup`;
+  ParaEvent2["LOGOUT_EVENT"] = `${EVENT_PREFIX}Logout`;
+  ParaEvent2["SIGN_MESSAGE_EVENT"] = `${EVENT_PREFIX}SignMessage`;
+  ParaEvent2["SIGN_TRANSACTION_EVENT"] = `${EVENT_PREFIX}SignTransaction`;
+  ParaEvent2["EXTERNAL_WALLET_CHANGE_EVENT"] = `${EVENT_PREFIX}ExternalWalletChange`;
+  ParaEvent2["WALLETS_CHANGE_EVENT"] = `${EVENT_PREFIX}WalletsChange`;
+  ParaEvent2["WALLET_CREATED"] = `${EVENT_PREFIX}WalletCreated`;
+  ParaEvent2["PREGEN_WALLET_CLAIMED"] = `${EVENT_PREFIX}PregenWalletClaimed`;
+  ParaEvent2["GUEST_WALLETS_CREATED"] = `${EVENT_PREFIX}GuestWalletsCreated`;
+  return ParaEvent2;
+})(ParaEvent || {});
+export {
+  ParaEvent
+};

package/dist/esm/types/index.js

@@ -0,0 +1,23 @@
+import "../chunk-7B52C2XE.js";
+export * from "./auth.js";
+export * from "./config.js";
+export * from "./coreApi.js";
+export * from "./wallet.js";
+export * from "./methods.js";
+export * from "./theme.js";
+export * from "./onRamps.js";
+export * from "./popup.js";
+export * from "./recovery.js";
+export * from "./events.js";
+import {
+  Network,
+  OnRampAsset,
+  OnRampProvider,
+  OnRampPurchaseStatus
+} from "@getpara/user-management-client";
+export {
+  Network,
+  OnRampAsset,
+  OnRampProvider,
+  OnRampPurchaseStatus
+};

package/dist/esm/types/onRamps.js

@@ -0,0 +1,11 @@
+import "../chunk-7B52C2XE.js";
+var OnRampMethod = /* @__PURE__ */ ((OnRampMethod2) => {
+  OnRampMethod2["ACH"] = "ACH";
+  OnRampMethod2["DEBIT"] = "Debit";
+  OnRampMethod2["CREDIT"] = "Credit";
+  OnRampMethod2["APPLE_PAY"] = "Apple Pay";
+  return OnRampMethod2;
+})(OnRampMethod || {});
+export {
+  OnRampMethod
+};

package/dist/esm/types/popup.js

@@ -0,0 +1,13 @@
+import "../chunk-7B52C2XE.js";
+var PopupType = /* @__PURE__ */ ((PopupType2) => {
+  PopupType2["SIGN_TRANSACTION_REVIEW"] = "SIGN_TRANSACTION_REVIEW";
+  PopupType2["SIGN_MESSAGE_REVIEW"] = "SIGN_MESSAGE_REVIEW";
+  PopupType2["LOGIN_PASSKEY"] = "LOGIN_PASSKEY";
+  PopupType2["CREATE_PASSKEY"] = "CREATE_PASSKEY";
+  PopupType2["OAUTH"] = "OAUTH";
+  PopupType2["ON_RAMP_TRANSACTION"] = "ON_RAMP_TRANSACTION";
+  return PopupType2;
+})(PopupType || {});
+export {
+  PopupType
+};

package/dist/esm/types/recovery.js

@@ -0,0 +1,12 @@
+import "../chunk-7B52C2XE.js";
+var RecoveryStatus = /* @__PURE__ */ ((RecoveryStatus2) => {
+  RecoveryStatus2["INITIATED"] = "INITIATED";
+  RecoveryStatus2["READY"] = "READY";
+  RecoveryStatus2["EXPIRED"] = "EXPIRED";
+  RecoveryStatus2["FINISHED"] = "FINISHED";
+  RecoveryStatus2["CANCELLED"] = "CANCELLED";
+  return RecoveryStatus2;
+})(RecoveryStatus || {});
+export {
+  RecoveryStatus
+};

package/dist/esm/types/wallet.js

@@ -0,0 +1,9 @@
+import "../chunk-7B52C2XE.js";
+var PregenIdentifierType = /* @__PURE__ */ ((PregenIdentifierType2) => {
+  PregenIdentifierType2["EMAIL"] = "EMAIL";
+  PregenIdentifierType2["PHONE"] = "PHONE";
+  return PregenIdentifierType2;
+})(PregenIdentifierType || {});
+export {
+  PregenIdentifierType
+};

package/dist/esm/utils/autobind.js

@@ -0,0 +1,19 @@
+import "../chunk-7B52C2XE.js";
+function autoBind(instance) {
+  let proto = instance;
+  while (proto && proto !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      const value = instance[key];
+      if (typeof value === "function" && key !== "constructor") {
+        try {
+          instance[key] = value.bind(instance);
+        } catch (e) {
+        }
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
+export {
+  autoBind
+};

package/dist/esm/utils/events.js

@@ -0,0 +1,11 @@
+import {
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+function dispatchEvent(type, data, error) {
+  typeof window !== "undefined" && !!window.dispatchEvent && window.dispatchEvent(
+    new CustomEvent(type, { detail: __spreadValues({ data }, error && { error: new Error(error) }) })
+  );
+}
+export {
+  dispatchEvent
+};

package/dist/esm/utils/formatting.js

@@ -0,0 +1,76 @@
+import "../chunk-7B52C2XE.js";
+import { toBech32 } from "@cosmjs/encoding";
+import { sha256 } from "@noble/hashes/sha256";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+import elliptic from "elliptic";
+const secp256k1 = new elliptic.ec("secp256k1");
+function hexStringToBase64(hexString) {
+  if (hexString.substring(0, 2) === "0x") {
+    hexString = hexString.substring(2);
+  }
+  return Buffer.from(hexString, "hex").toString("base64");
+}
+function hexToSignature(hexSig) {
+  return {
+    r: `0x${hexSig.slice(2, 66)}`,
+    s: `0x${hexSig.slice(66, 130)}`,
+    v: BigInt(hexSig.slice(130, 132))
+  };
+}
+function hexToUint8Array(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+function hexToDecimal(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return `${parseInt(hex, 16)}`;
+}
+function decimalToHex(decimal) {
+  return `0x${parseInt(decimal).toString(16)}`;
+}
+function compressPubkey(pubkey) {
+  switch (pubkey.length) {
+    case 33:
+      return pubkey;
+    case 65:
+      return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(true, "array"));
+    default:
+      throw new Error("Invalid pubkey length");
+  }
+}
+function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
+  if (pubkeyData.length !== 33) {
+    throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
+  }
+  return ripemd160(sha256(pubkeyData));
+}
+function getCosmosAddress(publicKey, prefix) {
+  const uncompressedPublicKey = new Uint8Array(
+    Buffer.from(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey, "hex")
+  );
+  const compressedPublicKey = compressPubkey(uncompressedPublicKey);
+  return toBech32(prefix, rawSecp256k1PubkeyToRawAddress(compressedPublicKey));
+}
+function truncateAddress(str, addressType, {
+  prefix = addressType === "COSMOS" ? "cosmos" : void 0,
+  targetLength
+} = {}) {
+  const minimum = addressType === "COSMOS" ? prefix.length : addressType === "EVM" ? 2 : 0;
+  const margin = targetLength !== void 0 ? (targetLength - minimum) / 2 : 4;
+  return `${str.slice(0, minimum + margin)}...${str.slice(-1 * margin)}`;
+}
+export {
+  compressPubkey,
+  decimalToHex,
+  getCosmosAddress,
+  hexStringToBase64,
+  hexToDecimal,
+  hexToSignature,
+  hexToUint8Array,
+  rawSecp256k1PubkeyToRawAddress,
+  truncateAddress
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,11 @@
+export * from "./autobind.js";
+export * from "./events.js";
+export * from "./formatting.js";
+export * from "./json.js";
+export * from "./listeners.js";
+export * from "./onRamps.js";
+export * from "./phone.js";
+export * from "./polling.js";
+export * from "./types.js";
+export * from "./url.js";
+export * from "./wallet.js";

package/dist/esm/utils/json.js

@@ -0,0 +1,15 @@
+import "../chunk-7B52C2XE.js";
+function jsonParse(data, validate) {
+  try {
+    const res = JSON.parse(data);
+    if (validate && !validate(res)) {
+      return void 0;
+    }
+    return res;
+  } catch (e) {
+    return void 0;
+  }
+}
+export {
+  jsonParse
+};

package/dist/esm/utils/listeners.js

@@ -0,0 +1,38 @@
+import "../chunk-7B52C2XE.js";
+import * as constants from "../constants.js";
+function storageListener(e) {
+  if (!e.url.includes(window.location.origin)) {
+    return;
+  }
+  if (e.key === constants.LOCAL_STORAGE_EXTERNAL_WALLETS) {
+    this.updateExternalWalletsFromStorage();
+  }
+  if (e.key === constants.SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR) {
+    this.updateLoginEncryptionKeyPairFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_SESSION_COOKIE) {
+    this.updateSessionCookieFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_CURRENT_WALLET_IDS) {
+    this.updateWalletIdsFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_WALLETS || e.key === constants.LOCAL_STORAGE_ED25519_WALLETS) {
+    this.updateWalletsFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_AUTH_INFO) {
+    this.updateAuthInfoFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_USER_ID) {
+    this.updateUserIdFromStorage();
+  }
+}
+function setupListeners() {
+  if (typeof window !== "undefined" && window.addEventListener && window.location) {
+    window.removeEventListener("storage", storageListener.bind(this));
+    window.addEventListener("storage", storageListener.bind(this));
+  }
+}
+export {
+  setupListeners,
+  storageListener
+};