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

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/shares/KeyContainer.js

@@ -0,0 +1,89 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var KeyContainer_exports = {};
+__export(KeyContainer_exports, {
+  KeyContainer: () => KeyContainer
+});
+module.exports = __toCommonJS(KeyContainer_exports);
+var import_ecies = require("@celo/utils/lib/ecies.js");
+var eutil = __toESM(require("@ethereumjs/util"));
+var forge = __toESM(require("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 = (0, import_ecies.Encrypt)(pubkey, Buffer.from(backup, "ucs2")).toString("base64");
+      return data;
+    } catch (error) {
+      throw Error("Error encrypting backup");
+    }
+  }
+  static encryptWithPublicKey(publicKey, backup) {
+    try {
+      const data = (0, import_ecies.Encrypt)(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 = (0, import_ecies.Decrypt)(Buffer.from(this.backupDecryptionKey, "hex"), buf);
+      return Buffer.from(data.buffer).toString("ucs2");
+    } catch (error) {
+      throw Error("Error decrypting backup");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyContainer
+});

package/dist/cjs/shares/recovery.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __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 recovery_exports = {};
+__export(recovery_exports, {
+  sendRecoveryForShare: () => sendRecoveryForShare
+});
+module.exports = __toCommonJS(recovery_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+var import_KeyContainer = require("./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 import_KeyContainer.KeyContainer(walletId, "", "");
+      const { recoveryPublicKeys: recoveryPublicKeys2 } = yield ctx.client.persistRecoveryPublicKeys(userId, [
+        recoveryPrivateKeyContainer.getPublicEncryptionKeyHex()
+      ]);
+      const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
+      userBackupKeyShareOptsArr = [
+        {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: import_user_management_client.KeyShareType.USER,
+          encryptor: import_user_management_client.EncryptorType.RECOVERY,
+          recoveryPublicKeyId: recoveryPublicKeys2[0].id
+        }
+      ];
+    } else {
+      userBackupKeyShareOptsArr = recoveryPublicKeys.map((recoveryPublicKey) => {
+        const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
+        const encryptedUserBackup = import_KeyContainer.KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, "hex"), userSigner);
+        return {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: import_user_management_client.KeyShareType.USER,
+          encryptor: import_user_management_client.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) : "";
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendRecoveryForShare
+});

package/dist/cjs/shares/shareDistribution.js

@@ -0,0 +1,104 @@
+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 shareDistribution_exports = {};
+__export(shareDistribution_exports, {
+  distributeNewShare: () => distributeNewShare
+});
+module.exports = __toCommonJS(shareDistribution_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+var import_utils = require("../cryptography/utils.js");
+var import_recovery = require("./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 } = (0, import_utils.encryptWithDerivedPublicKey)(key.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: import_user_management_client.KeyShareType.USER,
+        encryptor: import_user_management_client.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 } = (0, import_utils.encryptWithDerivedPublicKey)(password.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: import_user_management_client.KeyShareType.USER,
+        encryptor: import_user_management_client.EncryptorType.PASSWORD,
+        passwordId: password.id,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
+    return yield (0, import_recovery.sendRecoveryForShare)({
+      ctx,
+      userId,
+      walletId,
+      otherEncryptedShares: allEncryptedShares,
+      userSigner: userShare,
+      ignoreRedistributingBackupEncryptedShare,
+      emailProps
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  distributeNewShare
+});

package/dist/cjs/transmission/transmissionUtils.js

@@ -0,0 +1,93 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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 transmissionUtils_exports = {};
+__export(transmissionUtils_exports, {
+  retrieve: () => retrieve,
+  upload: () => upload
+});
+module.exports = __toCommonJS(transmissionUtils_exports);
+var import_ecies = require("@celo/utils/lib/ecies.js");
+var import_buffer = require("buffer");
+var eutil = __toESM(require("@ethereumjs/util"));
+var import_crypto = require("crypto");
+function upload(message, userManagementClient) {
+  return __async(this, null, function* () {
+    let secret;
+    let publicKeyUint8Array;
+    while (true) {
+      try {
+        secret = (0, import_crypto.randomBytes)(32).toString("hex");
+        publicKeyUint8Array = eutil.privateToPublic(import_buffer.Buffer.from(secret, "hex"));
+        break;
+      } catch (e) {
+        continue;
+      }
+    }
+    const pubkey = import_buffer.Buffer.from(publicKeyUint8Array);
+    const data = (0, import_ecies.Encrypt)(pubkey, import_buffer.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 = import_buffer.Buffer.from(data, "base64");
+    const res = import_buffer.Buffer.from((0, import_ecies.Decrypt)(import_buffer.Buffer.from(secret, "hex"), buf).buffer).toString("ucs2");
+    return res;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  retrieve,
+  upload
+});

package/dist/cjs/types/auth.js

@@ -0,0 +1,33 @@
+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 auth_exports = {};
+__export(auth_exports, {
+  AccountLinkError: () => AccountLinkError
+});
+module.exports = __toCommonJS(auth_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountLinkError
+});

package/dist/cjs/types/config.js

@@ -0,0 +1,43 @@
+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 config_exports = {};
+__export(config_exports, {
+  EnabledFlow: () => EnabledFlow,
+  Environment: () => Environment
+});
+module.exports = __toCommonJS(config_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnabledFlow,
+  Environment
+});

package/dist/cjs/types/coreApi.js

@@ -0,0 +1,89 @@
+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 coreApi_exports = {};
+__export(coreApi_exports, {
+  PARA_CORE_METHODS: () => PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS: () => PARA_INTERNAL_METHODS
+});
+module.exports = __toCommonJS(coreApi_exports);
+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"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS
+});

package/dist/cjs/types/events.js

@@ -0,0 +1,41 @@
+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 events_exports = {};
+__export(events_exports, {
+  ParaEvent: () => ParaEvent
+});
+module.exports = __toCommonJS(events_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParaEvent
+});

package/dist/cjs/types/index.js

@@ -0,0 +1,54 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  Network: () => import_user_management_client.Network,
+  OnRampAsset: () => import_user_management_client.OnRampAsset,
+  OnRampProvider: () => import_user_management_client.OnRampProvider,
+  OnRampPurchaseStatus: () => import_user_management_client.OnRampPurchaseStatus
+});
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./auth.js"), module.exports);
+__reExport(types_exports, require("./config.js"), module.exports);
+__reExport(types_exports, require("./coreApi.js"), module.exports);
+__reExport(types_exports, require("./wallet.js"), module.exports);
+__reExport(types_exports, require("./methods.js"), module.exports);
+__reExport(types_exports, require("./theme.js"), module.exports);
+__reExport(types_exports, require("./onRamps.js"), module.exports);
+__reExport(types_exports, require("./popup.js"), module.exports);
+__reExport(types_exports, require("./recovery.js"), module.exports);
+__reExport(types_exports, require("./events.js"), module.exports);
+var import_user_management_client = require("@getpara/user-management-client");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Network,
+  OnRampAsset,
+  OnRampProvider,
+  OnRampPurchaseStatus,
+  ...require("./auth.js"),
+  ...require("./config.js"),
+  ...require("./coreApi.js"),
+  ...require("./wallet.js"),
+  ...require("./methods.js"),
+  ...require("./theme.js"),
+  ...require("./onRamps.js"),
+  ...require("./popup.js"),
+  ...require("./recovery.js"),
+  ...require("./events.js")
+});