@getpara/core-sdk 1.7.0 → 1.8.0

package/dist/cjs/index.js

@@ -1,41 +1,9 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -48,6 +16,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -57,3978 +26,85 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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 __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());
-  });
-};
-
-// src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AuthMethod: () => import_user_management_client6.AuthMethod,
-  EmailTheme: () => import_user_management_client6.EmailTheme,
-  EnabledFlow: () => EnabledFlow,
-  Environment: () => Environment,
-  KeyContainer: () => KeyContainer,
-  NON_ED25519: () => import_user_management_client6.NON_ED25519,
-  Network: () => import_user_management_client6.Network,
-  OAuthMethod: () => import_user_management_client6.OAuthMethod,
-  OnRampAsset: () => import_user_management_client6.OnRampAsset,
-  OnRampMethod: () => OnRampMethod,
-  OnRampProvider: () => import_user_management_client6.OnRampProvider,
-  OnRampPurchaseStatus: () => import_user_management_client6.OnRampPurchaseStatus,
-  OnRampPurchaseType: () => import_user_management_client6.OnRampPurchaseType,
-  PREGEN_IDENTIFIER_TYPES: () => import_user_management_client6.PREGEN_IDENTIFIER_TYPES,
-  ParaEvent: () => ParaEvent,
-  PopupType: () => PopupType,
-  PregenIdentifierType: () => PregenIdentifierType,
-  RecoveryStatus: () => RecoveryStatus,
-  STORAGE_PREFIX: () => PREFIX,
-  TransactionReviewDenied: () => TransactionReviewDenied,
-  TransactionReviewError: () => TransactionReviewError,
-  TransactionReviewTimeout: () => TransactionReviewTimeout,
-  WalletScheme: () => import_user_management_client6.WalletScheme,
-  WalletType: () => import_user_management_client6.WalletType,
-  decimalToHex: () => decimalToHex,
-  decryptPrivateKey: () => decryptPrivateKey,
-  decryptPrivateKeyAndDecryptShare: () => decryptPrivateKeyAndDecryptShare,
-  decryptPrivateKeyWithPassword: () => decryptPrivateKeyWithPassword,
-  decryptWithKeyPair: () => decryptWithKeyPair,
-  decryptWithPrivateKey: () => decryptWithPrivateKey,
+  AuthMethod: () => import_user_management_client.AuthMethod,
+  EmailTheme: () => import_user_management_client.EmailTheme,
+  KeyContainer: () => import_KeyContainer.KeyContainer,
+  NON_ED25519: () => import_user_management_client.NON_ED25519,
+  Network: () => import_user_management_client.Network,
+  OAuthMethod: () => import_user_management_client.OAuthMethod,
+  OnRampAsset: () => import_user_management_client.OnRampAsset,
+  OnRampMethod: () => import_types.OnRampMethod,
+  OnRampProvider: () => import_user_management_client.OnRampProvider,
+  OnRampPurchaseStatus: () => import_user_management_client.OnRampPurchaseStatus,
+  OnRampPurchaseType: () => import_user_management_client.OnRampPurchaseType,
+  PREGEN_IDENTIFIER_TYPES: () => import_user_management_client.PREGEN_IDENTIFIER_TYPES,
+  PopupType: () => import_types.PopupType,
+  PregenIdentifierType: () => import_types.PregenIdentifierType,
+  RecoveryStatus: () => import_types.RecoveryStatus,
+  STORAGE_PREFIX: () => import_constants.PREFIX,
+  WalletScheme: () => import_user_management_client.WalletScheme,
+  WalletType: () => import_user_management_client.WalletType,
+  decryptPrivateKey: () => import_utils2.decryptPrivateKey,
+  decryptPrivateKeyAndDecryptShare: () => import_utils2.decryptPrivateKeyAndDecryptShare,
+  decryptPrivateKeyWithPassword: () => import_utils2.decryptPrivateKeyWithPassword,
+  decryptWithKeyPair: () => import_utils2.decryptWithKeyPair,
+  decryptWithPrivateKey: () => import_utils2.decryptWithPrivateKey,
   default: () => src_default,
-  distributeNewShare: () => distributeNewShare,
-  encodePrivateKeyToPemHex: () => encodePrivateKeyToPemHex,
-  encryptPrivateKey: () => encryptPrivateKey,
-  encryptPrivateKeyWithPassword: () => encryptPrivateKeyWithPassword,
-  encryptWithDerivedPublicKey: () => encryptWithDerivedPublicKey,
-  entityToWallet: () => entityToWallet,
-  getAsymmetricKeyPair: () => getAsymmetricKeyPair,
-  getBaseMPCNetworkUrl: () => getBaseMPCNetworkUrl,
-  getBaseOAuthUrl: () => getBaseOAuthUrl,
-  getBaseUrl: () => getBaseUrl,
-  getCosmosAddress: () => getCosmosAddress,
-  getDerivedPrivateKeyAndDecrypt: () => getDerivedPrivateKeyAndDecrypt,
-  getOnRampAssets: () => getOnRampAssets,
-  getOnRampNetworks: () => getOnRampNetworks,
-  getPortalBaseURL: () => getPortalBaseURL,
-  getPortalDomain: () => getPortalDomain,
-  getPublicKeyFromSignature: () => getPublicKeyFromSignature,
-  getPublicKeyHex: () => getPublicKeyHex,
-  getSHA256HashHex: () => getSHA256HashHex,
-  hashPasswordWithSalt: () => hashPasswordWithSalt,
-  hexStringToBase64: () => hexStringToBase64,
-  hexToDecimal: () => hexToDecimal,
-  hexToSignature: () => hexToSignature,
-  hexToUint8Array: () => hexToUint8Array,
-  initClient: () => initClient,
-  isWalletSupported: () => isWalletSupported,
-  mpcComputationClient: () => mpcComputationClient_exports,
-  normalizePhoneNumber: () => normalizePhoneNumber,
+  distributeNewShare: () => import_shareDistribution.distributeNewShare,
+  encodePrivateKeyToPemHex: () => import_utils2.encodePrivateKeyToPemHex,
+  encryptPrivateKey: () => import_utils2.encryptPrivateKey,
+  encryptPrivateKeyWithPassword: () => import_utils2.encryptPrivateKeyWithPassword,
+  encryptWithDerivedPublicKey: () => import_utils2.encryptWithDerivedPublicKey,
+  entityToWallet: () => import_utils.entityToWallet,
+  getAsymmetricKeyPair: () => import_utils2.getAsymmetricKeyPair,
+  getBaseUrl: () => import_userManagementClient.getBaseUrl,
+  getDerivedPrivateKeyAndDecrypt: () => import_utils2.getDerivedPrivateKeyAndDecrypt,
+  getOnRampAssets: () => import_onRamps.getOnRampAssets,
+  getOnRampNetworks: () => import_onRamps.getOnRampNetworks,
+  getPortalBaseURL: () => import_url.getPortalBaseURL,
+  getPortalDomain: () => import_utils.getPortalDomain,
+  getPublicKeyFromSignature: () => import_utils2.getPublicKeyFromSignature,
+  getPublicKeyHex: () => import_utils2.getPublicKeyHex,
+  getSHA256HashHex: () => import_utils2.getSHA256HashHex,
+  hashPasswordWithSalt: () => import_utils2.hashPasswordWithSalt,
+  initClient: () => import_userManagementClient.initClient,
+  isWalletSupported: () => import_wallet.isWalletSupported,
+  mpcComputationClient: () => mpcComputationClient,
   paraVersion: () => paraVersion,
-  publicKeyFromHex: () => publicKeyFromHex,
-  stringToPhoneNumber: () => stringToPhoneNumber,
-  toAssetInfoArray: () => toAssetInfoArray,
-  transmissionUtilsRetrieve: () => retrieve,
-  truncateAddress: () => truncateAddress,
-  waitUntilTrue: () => waitUntilTrue
+  publicKeyFromHex: () => import_utils2.publicKeyFromHex,
+  stringToPhoneNumber: () => import_utils.stringToPhoneNumber,
+  toAssetInfoArray: () => import_onRamps.toAssetInfoArray,
+  transmissionUtilsRetrieve: () => import_transmissionUtils.retrieve
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/ParaCore.ts
-var import_buffer2 = require("buffer");
-var import_user_management_client5 = require("@getpara/user-management-client");
-var import_node_forge2 = __toESM(require("node-forge"));
-
-// src/cryptography/utils.ts
-var import_base64url = __toESM(require("base64url"));
-var import_node_forge = __toESM(require("node-forge"));
-
-// src/utils/events.ts
-function dispatchEvent(type, data, error) {
-  typeof window !== "undefined" && !!window.dispatchEvent && window.dispatchEvent(
-    new CustomEvent(type, { detail: __spreadValues({ data }, error && { error: new Error(error) }) })
-  );
-}
-
-// src/utils/formatting.ts
-var import_encoding = require("@cosmjs/encoding");
-var import_sha256 = require("@noble/hashes/sha256");
-var import_ripemd160 = require("@noble/hashes/ripemd160");
-var import_elliptic = __toESM(require("elliptic"));
-var import_libphonenumber_js = __toESM(require("libphonenumber-js"));
-var secp256k1 = new import_elliptic.default.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 (0, import_ripemd160.ripemd160)((0, import_sha256.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 (0, import_encoding.toBech32)(prefix, rawSecp256k1PubkeyToRawAddress(compressedPublicKey));
-}
-function truncateAddress(str, addressType, { prefix = addressType === "COSMOS" ? "cosmos" : void 0 } = {}) {
-  const headLength = (addressType === "COSMOS" ? prefix.length : addressType === "SOLANA" ? 0 : 2) + 4;
-  return `${str.slice(0, headLength)}...${str.slice(-4)}`;
-}
-function stringToPhoneNumber(str) {
-  var _a;
-  return (_a = (0, import_libphonenumber_js.default)(str)) == null ? void 0 : _a.formatInternational().replace(/[^\d+]/g, "");
-}
-function normalizePhoneNumber(countryCode, number) {
-  return stringToPhoneNumber(`${countryCode[0] !== "+" ? "+" : ""}${countryCode}${number}`);
-}
-
-// src/utils/onRamps.ts
-function toAssetInfoArray(data) {
-  const result = [];
-  Object.keys(data).forEach((walletType) => {
-    const networks = data[walletType];
-    Object.keys(networks).forEach((network) => {
-      const assets = networks[network];
-      Object.keys(assets).forEach((asset) => {
-        const providerInfo = assets[asset];
-        result.push([walletType, network, asset, providerInfo]);
-      });
-    });
-  });
-  return result;
-}
-function getOnRampNetworks(data, { walletType, allowed } = {}) {
-  return [
-    ...new Set(
-      toAssetInfoArray(data).filter(([type, network]) => (!walletType || type === walletType) && (!allowed || allowed.includes(network))).map(([_, network]) => network)
-    )
-  ];
-}
-function getOnRampAssets(data, {
-  walletType,
-  network,
-  allowed
-} = {}) {
-  return [
-    ...new Set(
-      toAssetInfoArray(data).filter(
-        ([t, n, a]) => (!walletType || t === walletType) && (!network || n === network) && (!Array.isArray(allowed) || allowed.includes(a))
-      ).map(([, , asset]) => asset)
-    )
-  ];
-}
-
-// src/utils/polling.ts
-function waitUntilTrue(condition, timeoutMs, intervalMs) {
-  return __async(this, null, function* () {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-      if (yield condition()) {
-        return true;
-      }
-      yield new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return false;
-  });
-}
-
-// src/types/config.ts
-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 || {});
-
-// src/types/wallet.ts
-var PregenIdentifierType = /* @__PURE__ */ ((PregenIdentifierType2) => {
-  PregenIdentifierType2["EMAIL"] = "EMAIL";
-  PregenIdentifierType2["PHONE"] = "PHONE";
-  return PregenIdentifierType2;
-})(PregenIdentifierType || {});
-
-// src/types/onRamps.ts
-var OnRampMethod = /* @__PURE__ */ ((OnRampMethod2) => {
-  OnRampMethod2["ACH"] = "ACH";
-  OnRampMethod2["DEBIT"] = "Debit";
-  OnRampMethod2["CREDIT"] = "Credit";
-  OnRampMethod2["APPLE_PAY"] = "Apple Pay";
-  return OnRampMethod2;
-})(OnRampMethod || {});
-
-// src/types/popup.ts
-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 || {});
-
-// src/types/recovery.ts
-var RecoveryStatus = /* @__PURE__ */ ((RecoveryStatus3) => {
-  RecoveryStatus3["INITIATED"] = "INITIATED";
-  RecoveryStatus3["READY"] = "READY";
-  RecoveryStatus3["EXPIRED"] = "EXPIRED";
-  RecoveryStatus3["FINISHED"] = "FINISHED";
-  RecoveryStatus3["CANCELLED"] = "CANCELLED";
-  return RecoveryStatus3;
-})(RecoveryStatus || {});
-
-// src/types/events.ts
-var 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`;
-  return ParaEvent2;
-})(ParaEvent || {});
-
-// src/utils/url.ts
-function getPortalDomain(env, isE2E) {
-  if (isE2E) {
-    return `localhost`;
-  }
-  switch (env) {
-    case "DEV" /* DEV */:
-      return "localhost";
-    case "SANDBOX" /* SANDBOX */:
-      return "app.sandbox.usecapsule.com";
-    case "BETA" /* BETA */:
-      return "app.beta.usecapsule.com";
-    case "PROD" /* PROD */:
-      return "app.usecapsule.com";
-    default:
-      throw new Error(`env: ${env} not supported`);
-  }
-}
-function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm) {
-  if (isE2E) {
-    if (isForWasm) {
-      return `https://app.sandbox.usecapsule.com`;
-    }
-    return `http://localhost:3003`;
-  }
-  const domain = getPortalDomain(env);
-  if (env === "DEV" /* DEV */) {
-    if (useLocalIp) {
-      return `http://127.0.0.1:3003`;
-    }
-    return `http://${domain}:3003`;
-  }
-  return `https://${domain}`;
-}
-function getParaConnectDomain(env) {
-  switch (env) {
-    case "DEV" /* DEV */:
-      return "localhost";
-    case "SANDBOX" /* SANDBOX */:
-      return "connect.sandbox.getpara.com";
-    case "BETA" /* BETA */:
-      return "connect.beta.getpara.com";
-    case "PROD" /* PROD */:
-      return "connect.getpara.com";
-    default:
-      throw new Error(`env: ${env} not supported`);
-  }
-}
-function getParaConnectBaseUrl({ env }, useLocalIp) {
-  const domain = getParaConnectDomain(env);
-  if (env === "DEV" /* DEV */) {
-    if (useLocalIp) {
-      return `http://127.0.0.1:3008`;
-    }
-    return `http://${domain}:3008`;
-  }
-  return `https://${domain}`;
-}
-function constructUrl({
-  base,
-  path,
-  params = {}
-}) {
-  const url = new URL(path, base);
-  Object.entries(params).forEach(([key, value]) => {
-    if (!!value && value !== "undefined" && value !== "null") url.searchParams.set(key, value.toString());
-  });
-  return url.toString();
-}
-
-// src/utils/wallet.ts
+var import_ParaCore = require("./ParaCore.js");
 var import_user_management_client = require("@getpara/user-management-client");
-var WalletSchemeTypeMap = {
-  [import_user_management_client.WalletScheme.DKLS]: {
-    [import_user_management_client.WalletType.EVM]: true,
-    [import_user_management_client.WalletType.COSMOS]: true
-  },
-  [import_user_management_client.WalletScheme.CGGMP]: {
-    [import_user_management_client.WalletType.EVM]: true,
-    [import_user_management_client.WalletType.COSMOS]: true
-  },
-  [import_user_management_client.WalletScheme.ED25519]: {
-    [import_user_management_client.WalletType.SOLANA]: true
-  }
-};
-function isPregenIdentifierMatch(a, b, type) {
-  if (!a || !b) {
-    return false;
-  }
-  switch (type) {
-    case "EMAIL":
-      return a.toLowerCase() === b.toLowerCase();
-    case "PHONE":
-      return stringToPhoneNumber(a) === stringToPhoneNumber(b);
-    case "CUSTOM_ID":
-      return a === b;
-    default:
-      return a.replace(/^@/g, "").toLowerCase() === b.replace(/^@/g, "").toLowerCase();
-  }
-}
-function isWalletSupported(types, wallet) {
-  return types.some((walletType) => {
-    var _a;
-    return !!((_a = WalletSchemeTypeMap[wallet == null ? void 0 : wallet.scheme]) == null ? void 0 : _a[walletType]);
-  });
-}
-function getSchemes(types) {
-  return Object.keys(WalletSchemeTypeMap).filter((scheme) => {
-    if (scheme === import_user_management_client.WalletScheme.CGGMP) {
-      return false;
-    }
-    return (Array.isArray(types) ? types : Object.keys(types)).some((type) => WalletSchemeTypeMap[scheme][type]);
-  });
-}
-function getWalletTypes(schemes) {
-  return [
-    ...new Set(
-      schemes.reduce((acc, scheme) => {
-        return [...acc, ...Object.keys(WalletSchemeTypeMap[scheme]).filter((type) => WalletSchemeTypeMap[scheme][type])];
-      }, [])
-    )
-  ];
-}
-function getEquivalentTypes(types) {
-  return getWalletTypes(getSchemes((Array.isArray(types) ? types : [types]).map((t) => import_user_management_client.WalletType[t])));
-}
-function entityToWallet(w) {
-  return __spreadProps(__spreadValues({}, w), {
-    scheme: w.scheme,
-    type: w.type,
-    pregenIdentifierType: w.pregenIdentifierType
-  });
-}
-function migrateWallet(obj) {
-  if (["USER", "PREGEN"].includes(obj.type)) {
-    obj.isPregen = obj.type === "PREGEN";
-    obj.type = obj.scheme === import_user_management_client.WalletScheme.ED25519 ? import_user_management_client.WalletType.SOLANA : import_user_management_client.WalletType.EVM;
-  }
-  if (!!obj.scheme && !obj.type) {
-    obj.type = obj.scheme === import_user_management_client.WalletScheme.ED25519 ? import_user_management_client.WalletType.SOLANA : import_user_management_client.WalletType.EVM;
-  }
-  return obj;
-}
-
-// src/cryptography/utils.ts
-var rsa = import_node_forge.default.pki.rsa;
-var RSA_ENCRYPTION_SCHEME = "RSA-OAEP";
-var CONSTANT_IV = "794241bc819a125a7b78ea313decc0bc";
-var CONSTANT_IV_AES = new Uint8Array([23, 66, 157, 146, 179, 158, 117, 120, 184, 73, 123, 81]);
-function getSHA256HashHex(str) {
-  const md = import_node_forge.default.md.sha256.create();
-  md.update(str);
-  return md.digest().toHex();
-}
-function getPublicKeyHex(keyPair) {
-  const pem = import_node_forge.default.pki.publicKeyToRSAPublicKeyPem(keyPair.publicKey);
-  return Buffer.from(pem, "utf-8").toString("hex");
-}
-function publicKeyFromHex(publicKeyHex) {
-  const pem = publicKeyHexToPem(publicKeyHex);
-  return import_node_forge.default.pki.publicKeyFromPem(pem);
-}
-function publicKeyHexToPem(publicKeyHex) {
-  return Buffer.from(publicKeyHex, "hex").toString("utf-8");
-}
-function encodePrivateKeyToPemHex(keyPair) {
-  const pem = import_node_forge.default.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 import_node_forge.default.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 = import_node_forge.default.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 = import_base64url.default.encode(userHandle);
-    const keyPair = yield getAsymmetricKeyPair(ctx, encodedUserHandle);
-    return getPublicKeyHex(keyPair);
-  });
-}
-function symmetricKeyEncryptMessage(message) {
-  const key = import_node_forge.default.random.getBytesSync(16);
-  const cipher = import_node_forge.default.cipher.createCipher("AES-CBC", key);
-  cipher.start({ iv: CONSTANT_IV });
-  cipher.update(import_node_forge.default.util.createBuffer(message));
-  cipher.finish();
-  const encryptedMessageHex = cipher.output.toHex();
-  return { key, encryptedMessageHex };
-}
-function decipherEncryptedMessageHex(key, encryptedMessageHex) {
-  const decipher = import_node_forge.default.cipher.createDecipher("AES-CBC", key);
-  decipher.start({ iv: CONSTANT_IV });
-  decipher.update(import_node_forge.default.util.createBuffer(import_node_forge.default.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 = import_node_forge.default.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 import_node_forge.default.util.bytesToHex(import_node_forge.default.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;
-  });
-}
-
-// src/external/userManagementClient.ts
-var import_user_management_client2 = __toESM(require("@getpara/user-management-client"));
-function getBaseOAuthUrl(env) {
-  switch (env) {
-    case "DEV" /* DEV */:
-      return "http://localhost:8080/";
-    case "SANDBOX" /* SANDBOX */:
-      return "https://api.sandbox.usecapsule.com/";
-    case "BETA" /* BETA */:
-      return "https://api.beta.usecapsule.com/";
-    case "PROD" /* PROD */:
-      return "https://api.usecapsule.com/";
-    default:
-      throw new Error(`unsupported env: ${env}`);
-  }
-}
-function getBaseUrl(env) {
-  switch (env) {
-    case "DEV" /* DEV */:
-      return "http://localhost:8080/";
-    case "SANDBOX" /* SANDBOX */:
-      return "https://api.sandbox.getpara.com/";
-    case "BETA" /* BETA */:
-      return "https://api.beta.getpara.com/";
-    case "PROD" /* 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 "DEV" /* DEV */:
-      return `${prefix}://localhost:3000`;
-    case "SANDBOX" /* SANDBOX */:
-      return `${prefix}s://mpc-network.sandbox.getpara.com`;
-    case "BETA" /* BETA */:
-      return `${prefix}s://mpc-network.beta.getpara.com`;
-    case "PROD" /* 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 import_user_management_client2.default({
-    userManagementHost: getBaseUrl(env),
-    version: ["DEV" /* DEV */, "SANDBOX" /* SANDBOX */].includes(env) ? "dev" : version,
-    apiKey,
-    partnerId,
-    opts: { useFetchAdapter },
-    retrieveSessionCookie,
-    persistSessionCookie
-  });
-}
-
-// src/external/mpcComputationClient.ts
-var mpcComputationClient_exports = {};
-__export(mpcComputationClient_exports, {
-  initClient: () => initClient2
-});
-var import_axios = __toESM(require("axios"));
-function initClient2(baseURL, useAdapter) {
-  const client = import_axios.default.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;
-}
-
-// src/shares/shareDistribution.ts
-var import_user_management_client4 = require("@getpara/user-management-client");
-
-// src/shares/recovery.ts
-var import_user_management_client3 = require("@getpara/user-management-client");
-
-// src/shares/KeyContainer.ts
-var import_ecies = require("@celo/utils/lib/ecies.js");
-var eutil = __toESM(require("ethereumjs-util"));
-var forge2 = __toESM(require("node-forge"));
-var KeyContainer = class _KeyContainer {
-  constructor(walletId, keyshare, address) {
-    this.walletId = walletId;
-    this.keyshare = keyshare;
-    this.address = address;
-    this.backupDecryptionKey = Buffer.from(forge2.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");
-    }
-  }
-};
-
-// src/shares/recovery.ts
-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: import_user_management_client3.KeyShareType.USER,
-          encryptor: import_user_management_client3.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: import_user_management_client3.KeyShareType.USER,
-          encryptor: import_user_management_client3.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) : "";
-  });
-}
-
-// src/shares/shareDistribution.ts
-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: import_user_management_client4.KeyShareType.USER,
-        encryptor: import_user_management_client4.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: import_user_management_client4.KeyShareType.USER,
-        encryptor: import_user_management_client4.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
-    });
-  });
-}
-
-// src/transmission/transmissionUtils.ts
-var import_ecies2 = require("@celo/utils/lib/ecies.js");
-var import_buffer = require("buffer");
-var eutil2 = __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 = eutil2.privateToPublic(import_buffer.Buffer.from(secret, "hex"));
-        break;
-      } catch (e) {
-        continue;
-      }
-    }
-    const pubkey = import_buffer.Buffer.from(publicKeyUint8Array);
-    const data = (0, import_ecies2.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_ecies2.Decrypt)(import_buffer.Buffer.from(secret, "hex"), buf).buffer).toString("ucs2");
-    return res;
-  });
-}
-
-// src/errors.ts
-var TransactionReviewError = class extends Error {
-  constructor(transactionReviewUrl) {
-    super("transaction review error");
-    this.name = "TransactionReviewError";
-    this.transactionReviewUrl = transactionReviewUrl;
-  }
-};
-var TransactionReviewDenied = class extends Error {
-  constructor() {
-    super("transaction review has been denied by the user");
-    this.name = "TransactionReviewDenied";
-  }
-};
-var TransactionReviewTimeout = class extends Error {
-  constructor(transactionReviewUrl, pendingTransactionId) {
-    super("transaction review has timed out");
-    this.name = "TransactionReviewTimeout";
-    this.transactionReviewUrl = transactionReviewUrl;
-    this.pendingTransactionId = pendingTransactionId;
-  }
-};
-
-// src/constants.ts
-var PARA_CORE_VERSION = '1.7.0';
-var PREFIX = "@CAPSULE/";
-var LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
-var LOCAL_STORAGE_PHONE = `${PREFIX}phone`;
-var LOCAL_STORAGE_COUNTRY_CODE = `${PREFIX}countryCode`;
-var LOCAL_STORAGE_FARCASTER_USERNAME = `${PREFIX}farcasterUsername`;
-var LOCAL_STORAGE_TELEGRAM_USER_ID = `${PREFIX}telegramUserId`;
-var LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID = `${PREFIX}externalWalletUserId`;
-var LOCAL_STORAGE_USER_ID = `${PREFIX}userId`;
-var LOCAL_STORAGE_ED25519_WALLETS = `${PREFIX}ed25519Wallets`;
-var LOCAL_STORAGE_WALLETS = `${PREFIX}wallets`;
-var LOCAL_STORAGE_EXTERNAL_WALLETS = `${PREFIX}externalWallets`;
-var LOCAL_STORAGE_CURRENT_WALLET_IDS = `${PREFIX}currentWalletIds`;
-var LOCAL_STORAGE_SESSION_COOKIE = `${PREFIX}sessionCookie`;
-var SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = `${PREFIX}loginEncryptionKeyPair`;
-var POLLING_INTERVAL_MS = 2e3;
-var SHORT_POLLING_INTERVAL_MS = 1e3;
-
-// src/utils/listeners.ts
-function storageListener(e) {
-  if (!e.url.includes(window.location.origin)) {
-    return;
-  }
-  if (e.key === LOCAL_STORAGE_EXTERNAL_WALLETS) {
-    this.updateExternalWalletsFromStorage();
-  }
-  if (e.key === SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR) {
-    this.updateLoginEncryptionKeyPairFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_SESSION_COOKIE) {
-    this.updateSessionCookieFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_CURRENT_WALLET_IDS) {
-    this.updateWalletIdsFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_WALLETS || e.key === LOCAL_STORAGE_ED25519_WALLETS) {
-    this.updateWalletsFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_EMAIL) {
-    this.updateEmailFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_COUNTRY_CODE) {
-    this.updateCountryCodeFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_PHONE) {
-    this.updatePhoneFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_USER_ID) {
-    this.updateUserIdFromStorage();
-  }
-  if (e.key === LOCAL_STORAGE_TELEGRAM_USER_ID) {
-    this.updateTelegramUserIdFromStorage();
-  }
-}
-function setupListeners() {
-  if (typeof window !== "undefined" && window.addEventListener && window.location) {
-    window.removeEventListener("storage", storageListener.bind(this));
-    window.addEventListener("storage", storageListener.bind(this));
-  }
-}
-
-// src/ParaCore.ts
-if (typeof global !== "undefined") {
-  global.Buffer = global.Buffer || import_buffer2.Buffer;
-} else if (typeof window !== "undefined") {
-  window.Buffer = window.Buffer || import_buffer2.Buffer;
-  window.global = window.global || window;
-} else {
-  self.Buffer = self.Buffer || import_buffer2.Buffer;
-  self.global = self.global || self;
-}
-var { pki, jsbn } = import_node_forge2.default;
-var _supportedWalletTypes, _supportedWalletTypesOpt;
-var _ParaCore = class _ParaCore {
-  /**
-   * Constructs a new `ParaCore` instance.
-   * @param env - `Environment` to use.
-   * @param apiKey - API key to use.
-   * @param opts - Additional constructor options; see `ConstructorOpts`.
-   * @returns - A new ParaCore instance.
-   */
-  constructor(env, apiKey, opts) {
-    this.isAwaitingAccountCreation = false;
-    this.isAwaitingLogin = false;
-    this.isAwaitingFarcaster = false;
-    this.isAwaitingOAuth = false;
-    /**
-     * The IDs of the currently active wallets, for each supported wallet type. Any signer integrations will default to the first viable wallet ID in this dictionary.
-     */
-    this.currentWalletIds = {};
-    __privateAdd(this, _supportedWalletTypes);
-    __privateAdd(this, _supportedWalletTypesOpt);
-    this.localStorageGetItem = (key) => {
-      return this.platformUtils.localStorage.get(key);
-    };
-    this.localStorageSetItem = (key, value) => {
-      return this.platformUtils.localStorage.set(key, value);
-    };
-    this.sessionStorageGetItem = (key) => {
-      return this.platformUtils.sessionStorage.get(key);
-    };
-    this.sessionStorageSetItem = (key, value) => {
-      return this.platformUtils.sessionStorage.set(key, value);
-    };
-    this.sessionStorageRemoveItem = (key) => {
-      return this.platformUtils.sessionStorage.removeItem(key);
-    };
-    this.retrieveSessionCookie = () => {
-      return this.sessionCookie;
-    };
-    /**
-     * Remove all local storage and prefixed session storage.
-     * @param {'local' | 'session' | 'secure' | 'all'} type - Type of storage to clear. Defaults to 'all'.
-     */
-    this.clearStorage = (type = "all") => __async(this, null, function* () {
-      const isAll = type === "all";
-      (isAll || type === "local") && this.platformUtils.localStorage.clear(PREFIX);
-      (isAll || type === "session") && this.platformUtils.sessionStorage.clear(PREFIX);
-      if ((isAll || type === "secure") && this.platformUtils.secureStorage) {
-        this.platformUtils.secureStorage.clear(PREFIX);
-      }
-    });
-    this.initializeFromStorage = () => {
-      this.updateEmailFromStorage();
-      this.updateCountryCodeFromStorage();
-      this.updatePhoneFromStorage();
-      this.updateUserIdFromStorage();
-      this.updateTelegramUserIdFromStorage();
-      this.updateWalletsFromStorage();
-      this.updateWalletIdsFromStorage();
-      this.updateSessionCookieFromStorage();
-      this.updateLoginEncryptionKeyPairFromStorage();
-      this.updateExternalWalletsFromStorage();
-    };
-    this.updateTelegramUserIdFromStorage = () => {
-      this.telegramUserId = this.localStorageGetItem(LOCAL_STORAGE_TELEGRAM_USER_ID) || void 0;
-    };
-    this.updateUserIdFromStorage = () => {
-      this.userId = this.localStorageGetItem(LOCAL_STORAGE_USER_ID) || void 0;
-    };
-    this.updatePhoneFromStorage = () => {
-      this.phone = this.localStorageGetItem(LOCAL_STORAGE_PHONE) || void 0;
-    };
-    this.updateCountryCodeFromStorage = () => {
-      this.countryCode = this.localStorageGetItem(LOCAL_STORAGE_COUNTRY_CODE) || void 0;
-    };
-    this.updateEmailFromStorage = () => {
-      this.email = this.localStorageGetItem(LOCAL_STORAGE_EMAIL) || void 0;
-    };
-    this.updateWalletsFromStorage = () => __async(this, null, function* () {
-      var _a;
-      const _currentWalletIds = (_a = this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS)) != null ? _a : void 0;
-      const currentWalletIds = [void 0, null, "undefined"].includes(_currentWalletIds) ? {} : (() => {
-        const fromJson = JSON.parse(_currentWalletIds);
-        return Array.isArray(fromJson) ? Object.keys(import_user_management_client5.WalletType).reduce((acc, type) => {
-          const wallet = Object.values(this.wallets).find(
-            (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
-          );
-          return __spreadValues(__spreadValues({}, acc), wallet && !acc[type] ? { [type]: [wallet.id] } : {});
-        }, {}) : fromJson;
-      })();
-      this.setCurrentWalletIds(currentWalletIds);
-      const stringWallets = this.platformUtils.secureStorage ? this.platformUtils.secureStorage.get(LOCAL_STORAGE_WALLETS) : this.localStorageGetItem(LOCAL_STORAGE_WALLETS);
-      const _wallets = JSON.parse(stringWallets || "{}");
-      const stringEd25519Wallets = this.platformUtils.secureStorage ? this.platformUtils.secureStorage.get(LOCAL_STORAGE_ED25519_WALLETS) : this.localStorageGetItem(LOCAL_STORAGE_ED25519_WALLETS);
-      const _ed25519Wallets = JSON.parse(stringEd25519Wallets || "{}");
-      const wallets = __spreadValues(__spreadValues({}, Object.keys(_wallets).reduce((res, key) => {
-        return __spreadProps(__spreadValues({}, res), {
-          [key]: migrateWallet(_wallets[key])
-        });
-      }, {})), Object.keys(_ed25519Wallets).reduce((res, key) => {
-        return __spreadValues(__spreadValues({}, res), !res[key] ? { [key]: migrateWallet(_ed25519Wallets[key]) } : {});
-      }, {}));
-      this.setWallets(wallets);
-    });
-    this.updateWalletIdsFromStorage = () => {
-      var _a;
-      const _currentWalletIds = (_a = this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS)) != null ? _a : void 0;
-      const currentWalletIds = [void 0, null, "undefined"].includes(_currentWalletIds) ? {} : (() => {
-        const fromJson = JSON.parse(_currentWalletIds);
-        return Array.isArray(fromJson) ? Object.keys(import_user_management_client5.WalletType).reduce((acc, type) => {
-          const wallet = Object.values(this.wallets).find(
-            (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
-          );
-          return __spreadValues(__spreadValues({}, acc), wallet && !acc[type] ? { [type]: [wallet.id] } : {});
-        }, {}) : fromJson;
-      })();
-      this.setCurrentWalletIds(currentWalletIds);
-      if (Object.values(this.wallets).filter((w) => this.isWalletOwned(w)).length > 0 && this.currentWalletIdsArray.length === 0) {
-        this.findWalletId(void 0, { forbidPregen: true });
-      }
-    };
-    this.updateSessionCookieFromStorage = () => {
-      this.sessionCookie = this.localStorageGetItem(LOCAL_STORAGE_SESSION_COOKIE) || this.sessionStorageGetItem(LOCAL_STORAGE_SESSION_COOKIE) || void 0;
-    };
-    this.updateLoginEncryptionKeyPairFromStorage = () => {
-      const loginEncryptionKey = this.sessionStorageGetItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR);
-      if (loginEncryptionKey && loginEncryptionKey !== "undefined") {
-        this.loginEncryptionKeyPair = this.convertEncryptionKeyPair(JSON.parse(loginEncryptionKey));
-      }
-    };
-    this.updateExternalWalletsFromStorage = () => {
-      const stringExternalWallets = this.localStorageGetItem(LOCAL_STORAGE_EXTERNAL_WALLETS);
-      const _externalWallets = JSON.parse(stringExternalWallets || "{}");
-      this.setExternalWallets(_externalWallets);
-    };
-    /**
-     * Creates several new wallets with the desired types. If no types are provided, this method
-     * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
-     * object that are not already present. This is automatically called upon account creation to ensure that
-     * the user has a wallet of each required type.
-     *
-     * @deprecated alias for `createWalletPerType`
-     **/
-    this.createWalletPerMissingType = this.createWalletPerType;
-    if (!opts) opts = {};
-    let isE2E = false;
-    if (env === "E2E") {
-      isE2E = true;
-      env = "SANDBOX" /* SANDBOX */;
-    }
-    this.emailPrimaryColor = opts.emailPrimaryColor;
-    this.emailTheme = opts.emailTheme;
-    this.homepageUrl = opts.homepageUrl;
-    this.supportUrl = opts.supportUrl;
-    this.xUrl = opts.xUrl;
-    this.githubUrl = opts.githubUrl;
-    this.linkedinUrl = opts.linkedinUrl;
-    this.portalBackgroundColor = opts.portalBackgroundColor;
-    this.portalPrimaryButtonColor = opts.portalPrimaryButtonColor;
-    this.portalTextColor = opts.portalTextColor;
-    this.portalPrimaryButtonTextColor = opts.portalPrimaryButtonTextColor;
-    this.portalTheme = opts.portalTheme;
-    this.platformUtils = this.getPlatformUtils();
-    this.disableProviderModal = this.platformUtils.disableProviderModal;
-    if (opts.useStorageOverrides) {
-      this.localStorageGetItem = opts.localStorageGetItemOverride;
-      this.localStorageSetItem = opts.localStorageSetItemOverride;
-      this.sessionStorageGetItem = opts.sessionStorageGetItemOverride;
-      this.sessionStorageSetItem = opts.sessionStorageSetItemOverride;
-      this.sessionStorageRemoveItem = opts.sessionStorageRemoveItemOverride;
-      this.clearStorage = opts.clearStorageOverride;
-    }
-    if (opts.useSessionStorage) {
-      this.localStorageGetItem = this.sessionStorageGetItem;
-      this.localStorageSetItem = this.sessionStorageSetItem;
-    }
-    this.persistSessionCookie = (cookie) => {
-      this.sessionCookie = cookie;
-      (opts.useSessionStorage ? this.sessionStorageSetItem : this.localStorageSetItem)(
-        LOCAL_STORAGE_SESSION_COOKIE,
-        cookie
-      );
-    };
-    this.ctx = {
-      env,
-      apiKey,
-      client: initClient({
-        env,
-        version: _ParaCore.version,
-        apiKey,
-        partnerId: this.isPortal(env) ? opts.portalPartnerId : void 0,
-        useFetchAdapter: !!opts.disableWorkers,
-        retrieveSessionCookie: this.retrieveSessionCookie,
-        persistSessionCookie: this.persistSessionCookie
-      }),
-      disableWorkers: opts.disableWorkers,
-      offloadMPCComputationURL: opts.offloadMPCComputationURL,
-      useLocalFiles: opts.useLocalFiles,
-      useDKLS: opts.useDKLSForCreation || !opts.offloadMPCComputationURL,
-      disableWebSockets: !!opts.disableWebSockets,
-      wasmOverride: opts.wasmOverride,
-      cosmosPrefix: this.cosmosPrefix,
-      isE2E
-    };
-    if (opts.offloadMPCComputationURL) {
-      this.ctx.mpcComputationClient = initClient2(opts.offloadMPCComputationURL, opts.disableWorkers);
-    }
-    try {
-      __privateSet(this, _supportedWalletTypes, opts.supportedWalletTypes ? (() => {
-        if (Object.values(opts.supportedWalletTypes).every(
-          (config) => !!config && typeof config === "object" && config.optional
-        )) {
-          throw new Error("at least one wallet type must be non-optional");
-        }
-        if (!Object.keys(opts.supportedWalletTypes).every((type) => Object.values(import_user_management_client5.WalletType).includes(type))) {
-          throw new Error("unsupported wallet type");
-        }
-        __privateSet(this, _supportedWalletTypesOpt, opts.supportedWalletTypes);
-        return Object.entries(opts.supportedWalletTypes).reduce((acc, [key, value]) => {
-          var _a;
-          if (!value) {
-            return acc;
-          }
-          if (key === import_user_management_client5.WalletType.COSMOS && typeof value === "object" && !!value.prefix) {
-            this.cosmosPrefix = value.prefix;
-          }
-          return [...acc, { type: key, optional: value === true ? false : (_a = value.optional) != null ? _a : false }];
-        }, []);
-      })() : void 0);
-    } catch (e) {
-      __privateSet(this, _supportedWalletTypes, void 0);
-    }
-    if (!this.platformUtils.isSyncStorage || opts.useStorageOverrides) {
-      return;
-    }
-    this.initializeFromStorage();
-    setupListeners.bind(this)();
-  }
-  get isEmail() {
-    return !!this.email && !this.phone && !this.countryCode && !this.farcasterUsername && !this.telegramUserId && !this.externalWalletWithParaAuth;
-  }
-  get isPhone() {
-    return !!this.phone && !!this.countryCode && !this.email && !this.farcasterUsername && !this.telegramUserId && !this.externalWalletWithParaAuth;
-  }
-  get isFarcaster() {
-    return !!this.farcasterUsername && !this.email && !this.phone && !this.countryCode && !this.telegramUserId && !this.externalWalletWithParaAuth;
-  }
-  get isTelegram() {
-    return !!this.telegramUserId && !this.email && !this.phone && !this.countryCode && !this.farcasterUsername && !this.externalWalletWithParaAuth;
-  }
-  get externalWalletWithParaAuth() {
-    const externalWallets = Object.values(this.externalWallets);
-    return externalWallets.find((w) => w.isExternalWithParaAuth);
-  }
-  get isExternalWalletAuth() {
-    return !!this.externalWalletWithParaAuth && !this.email && !this.phone && !this.countryCode && !this.farcasterUsername && !this.telegramUserId;
-  }
-  get currentWalletIdsArray() {
-    return this.supportedWalletTypes.reduce((acc, { type }) => {
-      var _a;
-      return [
-        ...acc,
-        ...((_a = this.currentWalletIds[type]) != null ? _a : []).map((id) => {
-          return [id, type];
-        })
-      ];
-    }, []);
-  }
-  get currentWalletIdsUnique() {
-    return [...new Set(Object.values(this.currentWalletIds).flat())];
-  }
-  /**
-   * A map of pre-generated wallet identifiers that can be claimed in the current instance.
-   */
-  get pregenIds() {
-    return __spreadValues({}, Object.values(this.wallets).filter((wallet) => !this.userId || this.isPregenWalletClaimable(wallet)).reduce((acc, wallet) => {
-      var _a, _b;
-      if (((_a = acc[wallet.pregenIdentifierType]) != null ? _a : []).includes(wallet.pregenIdentifier)) {
-        return acc;
-      }
-      return __spreadProps(__spreadValues({}, acc), {
-        [wallet.pregenIdentifierType]: [
-          .../* @__PURE__ */ new Set([...(_b = acc[wallet.pregenIdentifierType]) != null ? _b : [], wallet.pregenIdentifier])
-        ]
-      });
-    }, {}));
-  }
-  /**
-   * Whether the instance has multiple wallets connected.
-   */
-  get isMultiWallet() {
-    return this.currentWalletIdsArray.length > 1;
-  }
-  get supportedWalletTypes() {
-    var _a;
-    return (_a = __privateGet(this, _supportedWalletTypes)) != null ? _a : [];
-  }
-  get isWalletTypeEnabled() {
-    return this.supportedWalletTypes.reduce((acc, { type }) => {
-      return __spreadProps(__spreadValues({}, acc), { [type]: true });
-    }, {});
-  }
-  convertBigInt(bigInt) {
-    const convertedBigInt = new jsbn.BigInteger(null);
-    convertedBigInt.data = bigInt.data;
-    convertedBigInt.s = bigInt.s;
-    convertedBigInt.t = bigInt.t;
-    return convertedBigInt;
-  }
-  convertEncryptionKeyPair(jsonKeyPair) {
-    return {
-      privateKey: pki.setRsaPrivateKey(
-        this.convertBigInt(jsonKeyPair.privateKey.n),
-        this.convertBigInt(jsonKeyPair.privateKey.e),
-        this.convertBigInt(jsonKeyPair.privateKey.d),
-        this.convertBigInt(jsonKeyPair.privateKey.p),
-        this.convertBigInt(jsonKeyPair.privateKey.q),
-        this.convertBigInt(jsonKeyPair.privateKey.dP),
-        this.convertBigInt(jsonKeyPair.privateKey.dQ),
-        this.convertBigInt(jsonKeyPair.privateKey.qInv)
-      ),
-      publicKey: pki.setRsaPublicKey(
-        this.convertBigInt(jsonKeyPair.publicKey.n),
-        this.convertBigInt(jsonKeyPair.publicKey.e)
-      )
-    };
-  }
-  isPortal(envOverride) {
-    var _a;
-    if (typeof window === "undefined") return false;
-    return !!((_a = window.location) == null ? void 0 : _a.host) && getPortalBaseURL(envOverride ? { env: envOverride } : this.ctx).includes(window.location.host);
-  }
-  isParaConnect() {
-    var _a;
-    if (typeof window === "undefined") return false;
-    return !!((_a = window.location) == null ? void 0 : _a.host) && getParaConnectBaseUrl(this.ctx).includes(window.location.host);
-  }
-  requireApiKey() {
-    if (!this.ctx.apiKey) {
-      throw new Error(
-        `in order to create a wallet or user with Para, you
-        must provide an API key to the Para instance`
-      );
-    }
-  }
-  isWalletSupported(wallet) {
-    var _a, _b;
-    return !__privateGet(this, _supportedWalletTypes) || isWalletSupported((_b = (_a = this.supportedWalletTypes) == null ? void 0 : _a.map(({ type }) => type)) != null ? _b : [], wallet);
-  }
-  isWalletOwned(wallet) {
-    return this.isWalletSupported(wallet) && !(wallet == null ? void 0 : wallet.pregenIdentifier) && !(wallet == null ? void 0 : wallet.pregenIdentifierType) && !!this.userId && (wallet == null ? void 0 : wallet.userId) === this.userId;
-  }
-  isPregenWalletUnclaimed(wallet) {
-    return this.isWalletSupported(wallet) && (!(wallet == null ? void 0 : wallet.userId) || (wallet == null ? void 0 : wallet.isPregen) && !!(wallet == null ? void 0 : wallet.pregenIdentifier) && !!(wallet == null ? void 0 : wallet.pregenIdentifierType));
-  }
-  isPregenWalletClaimable(wallet) {
-    return this.isWalletSupported(wallet) && this.isPregenWalletUnclaimed(wallet) && (!["EMAIL", "PHONE", "TELEGRAM"].includes(wallet == null ? void 0 : wallet.pregenIdentifierType) || isPregenIdentifierMatch(
-      (wallet == null ? void 0 : wallet.pregenIdentifierType) === "EMAIL" ? this.email : (wallet == null ? void 0 : wallet.pregenIdentifierType) === "TELEGRAM" ? this.telegramUserId : this.getPhoneNumber(),
-      wallet == null ? void 0 : wallet.pregenIdentifier,
-      wallet == null ? void 0 : wallet.pregenIdentifierType
-    ));
-  }
-  isWalletUsable(walletId, { type: types, scheme: schemes, forbidPregen = false } = {}, throwError = false) {
-    var _a;
-    let error;
-    if ((_a = this.externalWallets) == null ? void 0 : _a[walletId]) {
-      return true;
-    }
-    if (!this.wallets[walletId]) {
-      error = `wallet with id ${walletId} does not exist`;
-    } else {
-      const wallet = this.wallets[walletId];
-      const [isUnclaimed, isOwned] = [this.isPregenWalletUnclaimed(wallet), this.isWalletOwned(wallet)];
-      if (forbidPregen && isUnclaimed) {
-        error = `pre-generated wallet with id ${wallet == null ? void 0 : wallet.id} cannot be selected`;
-      } else if (!isOwned && !isUnclaimed) {
-        error = `wallet with id ${wallet == null ? void 0 : wallet.id} is not owned by the current user`;
-      } else if (!this.isWalletSupported(wallet)) {
-        error = `wallet with id ${wallet == null ? void 0 : wallet.id} and type ${wallet == null ? void 0 : wallet.type} is not supported, supported types are: ${this.supportedWalletTypes.map(({ type }) => type).join(", ")}`;
-      } else if (types && (!getEquivalentTypes(types).includes(wallet == null ? void 0 : wallet.type) || isOwned && !types.some((type) => {
-        var _a2, _b;
-        return (_b = (_a2 = this.currentWalletIds) == null ? void 0 : _a2[type]) == null ? void 0 : _b.includes(walletId);
-      }))) {
-        error = `wallet with id ${wallet == null ? void 0 : wallet.id} and type ${wallet == null ? void 0 : wallet.type} cannot be selected`;
-      } else if (schemes && !schemes.includes(wallet == null ? void 0 : wallet.scheme)) {
-        error = `wallet with id ${wallet == null ? void 0 : wallet.id} and scheme ${wallet == null ? void 0 : wallet.scheme} cannot be selected`;
-      }
-    }
-    if (error) {
-      if (throwError) {
-        throw new Error(error);
-      }
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Returns the formatted address for the desired wallet ID, depending on your app settings.
-   * @param {string} walletId the ID of the wallet address to display.
-   * @param {object} options additional options for formatting the address.
-   * @param {boolean} options.truncate whether to truncate the address.
-   * @param {WalletType} options.addressType the type of address to display.
-   * @returns the formatted address
-   */
-  getDisplayAddress(walletId, options = {}) {
-    var _a;
-    if (this.externalWallets[walletId]) {
-      const wallet2 = this.externalWallets[walletId];
-      return options.truncate ? truncateAddress(wallet2.address, wallet2.type, { prefix: this.cosmosPrefix }) : wallet2.address;
-    }
-    const wallet = this.findWallet(walletId, options.addressType);
-    if (!wallet) {
-      return void 0;
-    }
-    let str;
-    switch (wallet.type) {
-      case import_user_management_client5.WalletType.COSMOS:
-        str = getCosmosAddress(wallet.publicKey, (_a = this.cosmosPrefix) != null ? _a : "cosmos");
-        break;
-      default:
-        str = wallet.address;
-        break;
-    }
-    return options.truncate ? truncateAddress(str, wallet.type, { prefix: this.cosmosPrefix }) : str;
-  }
-  /**
-   * Returns a unique hash for a wallet suitable for use as an identicon seed.
-   * @param {string} walletId the ID of the wallet.
-   * @param {boolean} options.addressType used to format the hash for another wallet type.
-   * @returns the identicon hash string
-   */
-  getIdenticonHash(walletId, overrideType) {
-    if (this.externalWallets[walletId]) {
-      const wallet2 = this.externalWallets[walletId];
-      return `${wallet2.id}-${wallet2.address}-${wallet2.type}`;
-    }
-    const wallet = this.findWallet(walletId, overrideType);
-    return wallet ? `${wallet.id}-${wallet.address}-${wallet.type}` : void 0;
-  }
-  getWallets() {
-    return this.wallets;
-  }
-  getAddress(walletId) {
-    var _a, _b, _c;
-    return walletId ? (_a = this.wallets[walletId]) == null ? void 0 : _a.address : (_c = (_b = Object.values(this.wallets)) == null ? void 0 : _b[0]) == null ? void 0 : _c.address;
-  }
-  constructPortalUrl(_0) {
-    return __async(this, arguments, function* (type, opts = {}) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-      const base = type === "onRamp" ? getPortalBaseURL(this.ctx) : yield this.getPortalURL(opts.partnerId);
-      let path;
-      switch (type) {
-        case "createPassword": {
-          path = `/web/users/${this.userId}/passwords/${opts.pathId}`;
-          break;
-        }
-        case "createAuth": {
-          path = `/web/users/${this.userId}/biometrics/${opts.pathId}`;
-          break;
-        }
-        case "loginPassword": {
-          path = "/web/passwords/login";
-          break;
-        }
-        case "loginAuth": {
-          path = "/web/biometrics/login";
-          break;
-        }
-        case "txReview": {
-          path = `/web/users/${this.userId}/transaction-review/${opts.pathId}`;
-          break;
-        }
-        case "onRamp": {
-          path = `/web/users/${this.userId}/on-ramp-transaction/${opts.pathId}`;
-          break;
-        }
-        default: {
-          throw new Error(`invalid URL type ${type}`);
-        }
-      }
-      const [isCreate, isLogin, isOnRamp] = [
-        ["createAuth", "createPassword"].includes(type),
-        ["loginAuth", "loginPassword"].includes(type),
-        type === "onRamp"
-      ];
-      const partner = opts.partnerId ? (_a = (yield this.ctx.client.getPartner(opts.partnerId)).data) == null ? void 0 : _a.partner : void 0;
-      const params = __spreadValues(__spreadValues(__spreadValues(__spreadValues({
-        apiKey: this.ctx.apiKey,
-        partnerId: opts.partnerId,
-        portalFont: ((_b = opts.theme) == null ? void 0 : _b.font) || (partner == null ? void 0 : partner.font) || ((_c = this.portalTheme) == null ? void 0 : _c.font),
-        portalBorderRadius: ((_d = opts.theme) == null ? void 0 : _d.borderRadius) || ((_e = this.portalTheme) == null ? void 0 : _e.borderRadius),
-        portalThemeMode: ((_f = opts.theme) == null ? void 0 : _f.mode) || (partner == null ? void 0 : partner.themeMode) || ((_g = this.portalTheme) == null ? void 0 : _g.mode),
-        portalAccentColor: ((_h = opts.theme) == null ? void 0 : _h.accentColor) || (partner == null ? void 0 : partner.accentColor) || ((_i = this.portalTheme) == null ? void 0 : _i.accentColor),
-        portalForegroundColor: ((_j = opts.theme) == null ? void 0 : _j.foregroundColor) || (partner == null ? void 0 : partner.foregroundColor) || ((_k = this.portalTheme) == null ? void 0 : _k.foregroundColor),
-        portalBackgroundColor: ((_l = opts.theme) == null ? void 0 : _l.backgroundColor) || (partner == null ? void 0 : partner.backgroundColor) || this.portalBackgroundColor || ((_m = this.portalTheme) == null ? void 0 : _m.backgroundColor),
-        portalPrimaryButtonColor: this.portalPrimaryButtonColor,
-        portalTextColor: this.portalTextColor,
-        portalPrimaryButtonTextColor: this.portalPrimaryButtonTextColor,
-        isForNewDevice: opts.isForNewDevice ? opts.isForNewDevice.toString() : void 0,
-        supportedWalletTypes: __privateGet(this, _supportedWalletTypesOpt) ? JSON.stringify(__privateGet(this, _supportedWalletTypesOpt)) : void 0
-      }, isCreate || isLogin ? __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, opts.authType === "email" ? { email: this.email } : {}), opts.authType === "phone" ? { phone: this.phone, countryCode: this.countryCode } : {}), opts.authType === "farcaster" ? { farcasterUsername: this.farcasterUsername } : {}), opts.authType === "telegram" ? { telegramUserId: this.telegramUserId } : {}), opts.authType === "externalWallet" ? {
-        // Using id here since we store the bech32 address for cosmos in the address field of the wallet
-        externalWalletAddress: (_n = this.externalWalletWithParaAuth) == null ? void 0 : _n.id
-      } : {}) : {}), isLogin || isOnRamp ? { sessionId: opts.sessionId } : {}), isLogin ? {
-        encryptionKey: opts.loginEncryptionPublicKey,
-        newDeviceSessionLookupId: opts.newDeviceSessionId,
-        newDeviceEncryptionKey: opts.newDeviceEncryptionKey,
-        pregenIds: JSON.stringify(this.pregenIds),
-        displayName: opts.displayName,
-        pfpUrl: opts.pfpUrl
-      } : {}), opts.params || {});
-      return constructUrl({ base, path, params });
-    });
-  }
-  touchSession(regenerate = false) {
-    return __async(this, null, function* () {
-      const res = yield this.ctx.client.touchSession(regenerate);
-      this.setSupportedWalletTypes(res.data.supportedWalletTypes, res.data.cosmosPrefix);
-      return res;
-    });
-  }
-  setSupportedWalletTypes(supportedWalletTypes, cosmosPrefix) {
-    if (supportedWalletTypes && !__privateGet(this, _supportedWalletTypes)) {
-      __privateSet(this, _supportedWalletTypes, supportedWalletTypes);
-      Object.keys(this.currentWalletIds).forEach((type) => {
-        var _a;
-        if (!((_a = __privateGet(this, _supportedWalletTypes)) == null ? void 0 : _a.some(({ type: supportedType }) => supportedType === type))) {
-          delete this.currentWalletIds[type];
-        }
-      });
-    }
-    if (cosmosPrefix && !this.cosmosPrefix) {
-      this.cosmosPrefix = cosmosPrefix;
-    }
-  }
-  getVerificationEmailProps() {
-    return {
-      brandColor: this.emailPrimaryColor,
-      theme: this.emailTheme,
-      supportUrl: this.supportUrl,
-      homepageUrl: this.homepageUrl,
-      xUrl: this.xUrl,
-      githubUrl: this.githubUrl,
-      linkedinUrl: this.linkedinUrl
-    };
-  }
-  getBackupKitEmailProps() {
-    return {
-      brandColor: this.emailPrimaryColor,
-      theme: this.emailTheme,
-      homepageUrl: this.homepageUrl,
-      xUrl: this.xUrl,
-      linkedinUrl: this.linkedinUrl,
-      githubUrl: this.githubUrl,
-      supportUrl: this.supportUrl
-    };
-  }
-  /**
-   * Initialize storage relating to a `ParaCore` instance.
-   *
-   * Init only needs to be called for storage that is async.
-   */
-  init() {
-    return __async(this, null, function* () {
-      var _a;
-      this.email = (yield this.localStorageGetItem(LOCAL_STORAGE_EMAIL)) || void 0;
-      this.countryCode = (yield this.localStorageGetItem(LOCAL_STORAGE_COUNTRY_CODE)) || void 0;
-      this.phone = (yield this.localStorageGetItem(LOCAL_STORAGE_PHONE)) || void 0;
-      this.userId = (yield this.localStorageGetItem(LOCAL_STORAGE_USER_ID)) || void 0;
-      this.telegramUserId = (yield this.localStorageGetItem(LOCAL_STORAGE_TELEGRAM_USER_ID)) || void 0;
-      const stringWallets = this.platformUtils.secureStorage ? yield this.platformUtils.secureStorage.get(LOCAL_STORAGE_WALLETS) : yield this.localStorageGetItem(LOCAL_STORAGE_WALLETS);
-      const _wallets = JSON.parse(stringWallets || "{}");
-      const stringEd25519Wallets = this.platformUtils.secureStorage ? yield this.platformUtils.secureStorage.get(LOCAL_STORAGE_ED25519_WALLETS) : yield this.localStorageGetItem(LOCAL_STORAGE_ED25519_WALLETS);
-      const _ed25519Wallets = JSON.parse(stringEd25519Wallets || "{}");
-      const wallets = __spreadValues(__spreadValues({}, Object.keys(_wallets).reduce((res, key) => {
-        return __spreadProps(__spreadValues({}, res), {
-          [key]: migrateWallet(_wallets[key])
-        });
-      }, {})), Object.keys(_ed25519Wallets).reduce((res, key) => {
-        return __spreadValues(__spreadValues({}, res), !res[key] ? { [key]: migrateWallet(_ed25519Wallets[key]) } : {});
-      }, {}));
-      yield this.setWallets(wallets);
-      const _currentWalletIds = (_a = yield this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS)) != null ? _a : void 0;
-      const currentWalletIds = [void 0, null, "undefined", "null"].includes(_currentWalletIds) ? {} : (() => {
-        const fromJson = JSON.parse(_currentWalletIds);
-        return Array.isArray(fromJson) ? Object.keys(import_user_management_client5.WalletType).reduce((acc, type) => {
-          const wallet = Object.values(this.wallets).find(
-            (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
-          );
-          return __spreadValues(__spreadValues({}, acc), wallet && !acc[type] ? { [type]: [wallet.id] } : {});
-        }, {}) : fromJson;
-      })();
-      yield this.setCurrentWalletIds(currentWalletIds);
-      this.sessionCookie = (yield this.localStorageGetItem(LOCAL_STORAGE_SESSION_COOKIE)) || (yield this.sessionStorageGetItem(LOCAL_STORAGE_SESSION_COOKIE)) || void 0;
-      if (Object.values(this.wallets).filter((w) => this.isWalletOwned(w)).length > 0 && this.currentWalletIdsArray.length === 0) {
-        this.findWalletId(void 0, { forbidPregen: true });
-      }
-      const loginEncryptionKey = yield this.sessionStorageGetItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR);
-      if (loginEncryptionKey && loginEncryptionKey !== "undefined") {
-        this.loginEncryptionKeyPair = this.convertEncryptionKeyPair(JSON.parse(loginEncryptionKey));
-      }
-      const stringExternalWallets = yield this.localStorageGetItem(LOCAL_STORAGE_EXTERNAL_WALLETS);
-      const _externalWallets = JSON.parse(stringExternalWallets || "{}");
-      yield this.setExternalWallets(_externalWallets);
-      setupListeners.bind(this)();
-      yield this.touchSession();
-    });
-  }
-  /**
-   * Sets the email associated with the `ParaCore` instance.
-   * @param email - Email to set.
-   */
-  setEmail(email) {
-    return __async(this, null, function* () {
-      this.email = email;
-      yield this.localStorageSetItem(LOCAL_STORAGE_EMAIL, email);
-    });
-  }
-  /**
-   * Sets the Telegram user ID associated with the `ParaCore` instance.
-   * @param telegramUserId - Telegram user ID to set.
-   */
-  setTelegramUserId(telegramUserId) {
-    return __async(this, null, function* () {
-      this.telegramUserId = telegramUserId;
-      yield this.localStorageSetItem(LOCAL_STORAGE_TELEGRAM_USER_ID, telegramUserId);
-    });
-  }
-  /**
-   * Sets the phone number associated with the `ParaCore` instance.
-   * @param phone - Phone number to set.
-   * @param countryCode - Country Code to set.
-   */
-  setPhoneNumber(phone, countryCode) {
-    return __async(this, null, function* () {
-      this.phone = phone;
-      this.countryCode = countryCode;
-      yield this.localStorageSetItem(LOCAL_STORAGE_PHONE, phone);
-      yield this.localStorageSetItem(LOCAL_STORAGE_COUNTRY_CODE, countryCode);
-    });
-  }
-  /**
-   * Sets the farcaster username associated with the `ParaCore` instance.
-   * @param farcasterUsername - Farcaster Username to set.
-   */
-  setFarcasterUsername(farcasterUsername) {
-    return __async(this, null, function* () {
-      this.farcasterUsername = farcasterUsername;
-      yield this.localStorageSetItem(LOCAL_STORAGE_FARCASTER_USERNAME, farcasterUsername);
-    });
-  }
-  /**
-   * Sets the external wallet address and type associated with the `ParaCore` instance.
-   * @param externalAddress - External wallet address to set.
-   * @param externalType - Type of external wallet to set.
-   */
-  setExternalWallet(_0) {
-    return __async(this, arguments, function* ({ address, type, provider, addressBech32, withFullParaAuth }) {
-      this.externalWallets = {
-        [address]: {
-          id: address,
-          address: addressBech32 != null ? addressBech32 : address,
-          type,
-          name: provider,
-          isExternal: true,
-          isExternalWithParaAuth: withFullParaAuth,
-          signer: ""
-        }
-      };
-      this.setExternalWallets(this.externalWallets);
-      dispatchEvent(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
-    });
-  }
-  /**
-   * Sets the user id associated with the `ParaCore` instance.
-   * @param userId - User id to set.
-   */
-  setUserId(userId) {
-    return __async(this, null, function* () {
-      this.userId = userId;
-      yield this.localStorageSetItem(LOCAL_STORAGE_USER_ID, userId);
-    });
-  }
-  /**
-   * Sets the wallets associated with the `ParaCore` instance.
-   * @param wallets - Wallets to set.
-   */
-  setWallets(wallets) {
-    return __async(this, null, function* () {
-      this.wallets = wallets;
-      if (this.platformUtils.secureStorage) {
-        yield this.platformUtils.secureStorage.set(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
-        return;
-      }
-      yield this.localStorageSetItem(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
-    });
-  }
-  /**
-   * Sets the external wallets associated with the `ParaCore` instance.
-   * @param externalWallets - External wallets to set.
-   */
-  setExternalWallets(externalWallets) {
-    return __async(this, null, function* () {
-      this.externalWallets = externalWallets;
-      yield this.localStorageSetItem(LOCAL_STORAGE_EXTERNAL_WALLETS, JSON.stringify(externalWallets));
-    });
-  }
-  /**
-   * Sets the login encryption key pair associated with the `ParaCore` instance.
-   * @param keyPair - Encryption key pair generated from loginEncryptionKey.
-   */
-  setLoginEncryptionKeyPair(keyPair) {
-    return __async(this, null, function* () {
-      if (!keyPair) {
-        keyPair = yield getAsymmetricKeyPair(this.ctx);
-      }
-      this.loginEncryptionKeyPair = keyPair;
-      yield this.sessionStorageSetItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR, JSON.stringify(keyPair));
-    });
-  }
-  deleteLoginEncryptionKeyPair() {
-    return __async(this, null, function* () {
-      this.loginEncryptionKeyPair = void 0;
-      yield this.sessionStorageRemoveItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR);
-    });
-  }
-  /**
-   * Gets the userId associated with the `ParaCore` instance.
-   * @returns - userId associated with the `ParaCore` instance.
-   */
-  getUserId() {
-    return this.userId;
-  }
-  /**
-   * Gets the email associated with the `ParaCore` instance.
-   * @returns - email associated with the `ParaCore` instance.
-   */
-  getEmail() {
-    return this.email;
-  }
-  /**
-   * Gets the phone object associated with the `ParaCore` instance.
-   * @returns - phone object with phone number and country code associated with the `ParaCore` instance.
-   */
-  getPhone() {
-    return { phone: this.phone, countryCode: this.countryCode };
-  }
-  /**
-   * Gets the formatted phone number associated with the `ParaCore` instance.
-   * @returns - formatted phone number associated with the `ParaCore` instance.
-   */
-  getPhoneNumber() {
-    if (!this.phone || !this.countryCode) {
-      return void 0;
-    }
-    return normalizePhoneNumber(this.countryCode, this.phone);
-  }
-  /**
-   * Gets the farcaster username associated with the `ParaCore` instance.
-   * @returns - farcaster username associated with the `ParaCore` instance.
-   */
-  getFarcasterUsername() {
-    return this.farcasterUsername;
-  }
-  setCurrentWalletIds(_0) {
-    return __async(this, arguments, function* (currentWalletIds, {
-      needsWallet = false,
-      sessionLookupId,
-      newDeviceSessionLookupId
-    } = {}) {
-      this.currentWalletIds = currentWalletIds;
-      yield this.localStorageSetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS, JSON.stringify(this.currentWalletIds));
-      if (sessionLookupId) {
-        yield this.ctx.client.setCurrentWalletIds(
-          this.getUserId(),
-          this.currentWalletIds,
-          needsWallet,
-          sessionLookupId,
-          newDeviceSessionLookupId
-        );
-      }
-      dispatchEvent(ParaEvent.WALLETS_CHANGE_EVENT, null);
-    });
-  }
-  /**
-   * Fetches the most recent OAuth account metadata for the signed-in user.
-   * If applicable, this will include the user's most recent metadata from their Google, Apple, Facebook, X, Discord, Farcaster, or Telegram account, the last time they signed in to your app.
-   * @returns {Promise<AccountMetadata>} the user's account metadata.
-   */
-  getAccountMetadata() {
-    return __async(this, null, function* () {
-      if (!(yield this.isSessionActive()) || !this.userId) {
-        throw new Error("no signed-in user");
-      }
-      const {
-        data: { partnerId }
-      } = yield this.touchSession();
-      const { accountMetadata } = yield this.ctx.client.getAccountMetadata(this.userId, partnerId);
-      return accountMetadata;
-    });
-  }
-  /**
-   * Validates that a wallet ID is present on the instance, usable, and matches the desired filters.
-   * If no ID is passed, this will instead return the first valid, usable wallet ID that matches the filters.
-   * @param {string} [walletId] the wallet ID to validate.
-   * @param {WalletFilters} [filter={}] a `WalletFilters` object specifying allowed types, schemes, and whether to forbid unclaimed pregen wallets.
-   * @returns {string} the wallet ID originally passed, or the one found.
-   */
-  findWalletId(walletId, filter = {}) {
-    if (walletId) {
-      this.assertIsValidWalletId(walletId, filter);
-    } else {
-      for (const id of [...this.currentWalletIdsUnique, ...Object.keys(this.wallets)]) {
-        if (this.isWalletUsable(id, filter)) {
-          walletId = id;
-          break;
-        }
-      }
-      if (!walletId) {
-        throw new Error(`no valid wallet id found`);
-      }
-    }
-    return walletId;
-  }
-  /**
-   * Retrieves a wallet with the given address, if present.
-   * If no ID is passed, this will instead return the first valid, usable wallet ID that matches the filters.
-   * @param {string} [walletId] the wallet ID to validate.
-   * @param {WalletFilters} [filter={}] a `WalletFilters` object specifying allowed types, schemes, and whether to forbid unclaimed pregen wallets.
-   * @returns {string} the wallet ID originally passed, or the one found.
-   */
-  findWalletByAddress(address, filter) {
-    if (this.externalWallets[address]) {
-      return this.externalWallets[address];
-    }
-    let wallet;
-    Object.entries(this.currentWalletIds).forEach(([type, walletIds]) => {
-      const pregenWalletIds = Object.keys(this.wallets).filter(
-        (id) => this.wallets[id].type === type && this.isPregenWalletClaimable(this.wallets[id])
-      );
-      [...walletIds, ...pregenWalletIds].forEach((id) => {
-        if (address.toLowerCase() === this.getDisplayAddress(id, { addressType: type }).toLowerCase()) {
-          wallet = this.wallets[id];
-        }
-      });
-    });
-    if (!wallet) {
-      throw new Error(`wallet with address ${address} not found`);
-    }
-    this.assertIsValidWalletId(wallet.id, filter);
-    return wallet;
-  }
-  findWallet(idOrAddress, overrideType, filter = {}) {
-    var _a, _c, _d;
-    if (!this.isExternalWalletAuth && !idOrAddress && Object.keys(this.externalWallets).length > 0) {
-      return Object.values(this.externalWallets)[0];
-    }
-    if ((_a = this.externalWallets) == null ? void 0 : _a[idOrAddress]) {
-      return this.externalWallets[idOrAddress];
-    }
-    try {
-      const walletId = this.findWalletId(idOrAddress, filter);
-      if (walletId && !!this.wallets[walletId]) {
-        const _b = this.wallets[walletId], { signer: _signer } = _b, wallet = __objRest(_b, ["signer"]);
-        const type = (_d = overrideType != null ? overrideType : (_c = this.currentWalletIdsArray.find(([id]) => id === walletId)) == null ? void 0 : _c[1]) != null ? _d : wallet.type;
-        return __spreadProps(__spreadValues({}, wallet), {
-          type: import_user_management_client5.WalletType[type]
-        });
-      }
-    } catch (e) {
-      return void 0;
-    }
-  }
-  get availableWallets() {
-    var _a;
-    return [
-      ...this.currentWalletIdsArray.map(([address, type]) => [address, type, false]).map(([id, type]) => {
-        const wallet = this.findWallet(id, type);
-        if (!wallet) return null;
-        return {
-          id: wallet.id,
-          type,
-          address: this.getDisplayAddress(id, { addressType: type }),
-          name: wallet.name
-        };
-      }).filter((obj) => obj !== null),
-      ...Object.values((_a = this.externalWallets) != null ? _a : {})
-    ];
-  }
-  /**
-   * Retrieves all usable wallets with the provided type (`'EVM' | 'COSMOS' | 'SOLANA'`)
-   * @param {string} type the wallet type to filter by.
-   * @returns {Wallet[]} an array of matching wallets.
-   */
-  getWalletsByType(type) {
-    return Object.values(this.wallets).filter((w) => this.isWalletUsable(w.id, { type: [type] }));
-  }
-  assertIsValidWalletId(walletId, condition = {}) {
-    this.isWalletUsable(walletId, condition, true);
-  }
-  assertIsValidWalletType(type, walletTypes) {
-    return __async(this, null, function* () {
-      if (!__privateGet(this, _supportedWalletTypes)) {
-        yield this.touchSession();
-      }
-      if (!type || !Object.values(import_user_management_client5.WalletType).includes(type) || !(walletTypes != null ? walletTypes : this.supportedWalletTypes.map(({ type: type2 }) => type2)).includes(type)) {
-        throw new Error(`wallet type ${type} is not supported`);
-      }
-      return type;
-    });
-  }
-  getMissingTypes() {
-    return __async(this, null, function* () {
-      if (!__privateGet(this, _supportedWalletTypes)) {
-        yield this.touchSession();
-      }
-      return this.supportedWalletTypes.filter(
-        ({ type: t, optional }) => !optional && Object.values(this.wallets).every((w) => !this.isWalletOwned(w) || !WalletSchemeTypeMap[w.scheme][t])
-      ).map(({ type }) => type);
-    });
-  }
-  getTypesToCreate(types) {
-    return __async(this, null, function* () {
-      if (!__privateGet(this, _supportedWalletTypes)) {
-        yield this.touchSession();
-      }
-      return getSchemes(types != null ? types : yield this.getMissingTypes()).map((scheme) => {
-        switch (scheme) {
-          case import_user_management_client5.WalletScheme.ED25519:
-            return import_user_management_client5.WalletType.SOLANA;
-          default:
-            return this.supportedWalletTypes.some(({ type, optional }) => type === import_user_management_client5.WalletType.COSMOS && !optional) ? import_user_management_client5.WalletType.COSMOS : import_user_management_client5.WalletType.EVM;
-        }
-      });
-    });
-  }
-  getPartnerURL(partnerId) {
-    return __async(this, null, function* () {
-      const res = yield this.ctx.client.getPartner(partnerId);
-      return res.data.partner.portalUrl;
-    });
-  }
-  /**
-   * URL of the portal, which can be associated with a partner id
-   * @param partnerId: string - id of the partner to get the portal URL for
-   * @returns - portal URL
-   */
-  getPortalURL(partnerId) {
-    return __async(this, null, function* () {
-      return partnerId && (yield this.getPartnerURL(partnerId)) || getPortalBaseURL(this.ctx);
-    });
-  }
-  getWebAuthURLForCreate(_a) {
-    return __async(this, null, function* () {
-      var _b = _a, {
-        webAuthId
-      } = _b, options = __objRest(_b, [
-        "webAuthId"
-      ]);
-      return this.constructPortalUrl("createAuth", __spreadProps(__spreadValues({}, options), { pathId: webAuthId }));
-    });
-  }
-  getPasswordURLForCreate(_c) {
-    return __async(this, null, function* () {
-      var _d = _c, {
-        passwordId
-      } = _d, options = __objRest(_d, [
-        "passwordId"
-      ]);
-      return this.constructPortalUrl("createPassword", __spreadProps(__spreadValues({}, options), {
-        pathId: passwordId
-      }));
-    });
-  }
-  getShortUrl(compressedUrl) {
-    return constructUrl({
-      base: getPortalBaseURL(this.ctx),
-      path: `/short/${compressedUrl}`
-    });
-  }
-  shortenLoginLink(link) {
-    return __async(this, null, function* () {
-      const url = yield upload(link, this.ctx.client);
-      return this.getShortUrl(url);
-    });
-  }
-  /**
-   * Generates a URL for registering a new WebAuth passkey.
-   * @param {GetWebAuthUrlForLoginParams} opts the options object
-   * @returns - the URL for creating a new passkey
-   */
-  getWebAuthURLForLogin(opts) {
-    return __async(this, null, function* () {
-      return this.constructPortalUrl("loginAuth", opts);
-    });
-  }
-  /**
-   * Generates a URL for registering a new user password.
-   * @param {GetWebAuthUrlForLoginParams} opts the options object
-   * @returns - the URL for creating a new password
-   */
-  getPasswordURLForLogin(opts) {
-    return __async(this, null, function* () {
-      return this.constructPortalUrl("loginPassword", opts);
-    });
-  }
-  /**
-   * Generates a URL for registering a new WebAuth passkey for a phone number.
-   * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
-   * @returns - web auth url
-   */
-  getWebAuthURLForLoginForPhone(opts) {
-    return __async(this, null, function* () {
-      return this.constructPortalUrl("loginAuth", __spreadValues({
-        authType: "phone"
-      }, opts));
-    });
-  }
-  /**
-   * Gets the private key for the given wallet.
-   * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
-   * @returns - the private key string.
-   */
-  getPrivateKey(walletId) {
-    return __async(this, null, function* () {
-      const wallets = Object.values(this.wallets);
-      const wallet = walletId ? this.wallets[walletId] : wallets == null ? void 0 : wallets[0];
-      if (!wallet) {
-        throw new Error("wallet not found");
-      }
-      if (wallet.scheme !== import_user_management_client5.WalletScheme.DKLS) {
-        throw new Error("invalid wallet scheme");
-      }
-      return yield this.platformUtils.getPrivateKey(
-        this.ctx,
-        this.userId,
-        wallet.id,
-        wallet.signer,
-        this.retrieveSessionCookie()
-      );
-    });
-  }
-  /**
-   * Fetches the wallets associated with the user.
-   * @returns {WalletEntity[]} wallets that were fetched.
-   */
-  fetchWallets() {
-    return __async(this, null, function* () {
-      const res = yield this.isPortal() || this.isParaConnect() ? this.ctx.client.getAllWallets(this.userId) : this.ctx.client.getWallets(this.userId, true);
-      return res.data.wallets.filter(
-        (wallet) => !!wallet.address && (this.isParaConnect() || !this.isParaConnect() && this.isWalletSupported(entityToWallet(wallet)))
-      );
-    });
-  }
-  populateWalletAddresses() {
-    return __async(this, null, function* () {
-      const res = yield this.ctx.client.getWallets(this.userId, true);
-      const wallets = res.data.wallets;
-      wallets.forEach((entity) => {
-        if (this.wallets[entity.id]) {
-          this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
-        }
-      });
-      yield this.setWallets(this.wallets);
-    });
-  }
-  populatePregenWalletAddresses() {
-    return __async(this, null, function* () {
-      const res = yield this.getPregenWallets();
-      res.forEach((entity) => {
-        if (this.wallets[entity.id]) {
-          this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
-        }
-      });
-      yield this.setWallets(this.wallets);
-    });
-  }
-  /**
-   * Checks if a user exists for an email address.
-   * @param {Object} opts the options object
-   * @param {string} opts.email the email to check.
-   * @returns true if user exists, false otherwise.
-   */
-  checkIfUserExists(_0) {
-    return __async(this, arguments, function* ({ email }) {
-      const res = yield this.ctx.client.checkUserExists({ email });
-      return res.data.exists;
-    });
-  }
-  /**
-   * Checks if a user exists for a phone number.
-   * @param {Object} opts the options object
-   * @param {string} opts.phone - phone number to check.
-   * @param {string} opts.countryCode - the country code.
-   * @returns true if user exists, false otherwise.
-   */
-  checkIfUserExistsByPhone(_0) {
-    return __async(this, arguments, function* ({ phone, countryCode }) {
-      const res = yield this.ctx.client.checkUserExists({ phone, countryCode });
-      return res.data.exists;
-    });
-  }
-  /**
-   * Creates a new user.
-   * @param {Object} opts the options object
-   * @param {string} opts.email the email to use.
-   */
-  createUser(_0) {
-    return __async(this, arguments, function* ({ email }) {
-      this.requireApiKey();
-      yield this.setEmail(email);
-      const { userId } = yield this.ctx.client.createUser(__spreadValues({
-        email: this.email
-      }, this.getVerificationEmailProps()));
-      yield this.setUserId(userId);
-    });
-  }
-  /**
-   * Creates a new user with a phone number.
-   * @param {Object} opts the options object
-   * @param {string} opts.phone - the phone number to use for creating the user.
-   * @param {string} opts.countryCode - the country code to use for creating the user.
-   */
-  createUserByPhone(_0) {
-    return __async(this, arguments, function* ({ phone, countryCode }) {
-      this.requireApiKey();
-      yield this.setPhoneNumber(phone, countryCode);
-      const { userId } = yield this.ctx.client.createUser({
-        phone: this.phone,
-        countryCode: this.countryCode
-      });
-      yield this.setUserId(userId);
-    });
-  }
-  /**
-   * Logs in or creates a new user using an external wallet address.
-   * @param {Object} opts the options object
-   * @param {string} opts.address the external wallet address to use for identification.
-   * @param {WalletType} opts.type type of external wallet to use for identification.
-   * @param {string} opts.provider the name of the provider for the external wallet.
-   */
-  externalWalletLogin(wallet) {
-    return __async(this, null, function* () {
-      this.requireApiKey();
-      const res = yield this.ctx.client.externalWalletLogin({
-        externalAddress: wallet.address,
-        type: wallet.type,
-        externalWalletProvider: wallet.provider,
-        // If the wallet isn't using full Para auth we want to track the login here
-        shouldTrackUser: !wallet.withFullParaAuth
-      });
-      yield this.setExternalWallet(wallet);
-      yield this.setUserId(res.userId);
-      return res;
-    });
-  }
-  /**
-   * Returns whether or not the user is connected with only an external wallet, not an external wallet with Para auth.
-   */
-  isUsingExternalWallet() {
-    return !this.isExternalWalletAuth && !!Object.keys(this.externalWallets).length;
-  }
-  /**
-   * Passes the email code obtained from the user for verification.
-   * @param {Object} opts the options object
-   * @param {string} verificationCode the six-digit code to check
-   * @returns {string} the web auth url for creating a new credential
-   */
-  verifyEmail(_0) {
-    return __async(this, arguments, function* ({ verificationCode }) {
-      yield this.ctx.client.verifyEmail(this.userId, { verificationCode });
-      return this.getSetUpBiometricsURL();
-    });
-  }
-  verifyExternalWallet(_0) {
-    return __async(this, arguments, function* ({
-      address,
-      signedMessage,
-      cosmosPublicKeyHex,
-      cosmosSigner
-    }) {
-      yield this.ctx.client.verifyExternalWallet(this.userId, { address, signedMessage, cosmosPublicKeyHex, cosmosSigner });
-      return this.getSetUpBiometricsURL({ authType: "externalWallet" });
-    });
-  }
-  /**
-   * Passes the phone code obtained from the user for verification.
-   * @param {Object} opts the options object
-   * @param {string} verificationCode the six-digit code to check
-   * @returns {string} the web auth url for creating a new credential
-   */
-  verifyPhone(_0) {
-    return __async(this, arguments, function* ({ verificationCode }) {
-      yield this.ctx.client.verifyPhone(this.userId, { verificationCode });
-      return this.getSetUpBiometricsURLForPhone();
-    });
-  }
-  /**
-   * Validates the response received from an attempted Telegram login for authenticity, then
-   * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
-   * @param authResponse - the response JSON object received from the Telegram widget.
-   * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
-   */
-  verifyTelegram(authObject) {
-    return __async(this, null, function* () {
-      const res = yield this.ctx.client.verifyTelegram(authObject);
-      if (res.isValid) {
-        yield this.setUserId(res.userId);
-        yield this.setTelegramUserId(res.telegramUserId);
-        yield this.touchSession(true);
-        if (!this.loginEncryptionKeyPair) {
-          yield this.setLoginEncryptionKeyPair();
-        }
-      }
-      return res;
-    });
-  }
-  /**
-   * Performs 2FA verification.
-   * @param {Object} opts the options object
-   * @param {string} opts.email the email to use for performing a 2FA verification.
-   * @param {string} opts.verificationCode the verification code to received via 2FA.
-   * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
-   */
-  verify2FA(_0) {
-    return __async(this, arguments, function* ({ email, verificationCode }) {
-      const res = yield this.ctx.client.verify2FA(email, verificationCode);
-      return {
-        initiatedAt: res.data.initiatedAt,
-        status: res.data.status,
-        userId: res.data.userId,
-        wallets: res.data.wallets
-      };
-    });
-  }
-  /**
-   * Performs 2FA verification.
-   * @param {Object} opts the options object
-   * @param {string} opts.phone the phone number
-   * @param {string} opts.countryCode - the country code
-   * @param {string} opts.verificationCode - verification code to received via 2FA.
-   * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
-   */
-  verify2FAForPhone(_0) {
-    return __async(this, arguments, function* ({
-      phone,
-      countryCode,
-      verificationCode
-    }) {
-      const res = yield this.ctx.client.verify2FAForPhone(phone, countryCode, verificationCode);
-      return {
-        initiatedAt: res.data.initiatedAt,
-        status: res.data.status,
-        userId: res.data.userId,
-        wallets: res.data.wallets
-      };
-    });
-  }
-  /**
-   * Sets up two-factor authentication for the current user.
-   * @returns {string} uri - uri to use for setting up 2FA
-   * */
-  setup2FA() {
-    return __async(this, null, function* () {
-      const res = yield this.ctx.client.setup2FA(this.userId);
-      return {
-        uri: res.data.uri
-      };
-    });
-  }
-  /**
-   * Enables 2FA.
-   * @param {Object} opts the options object
-   * @param {string} opts.verificationCode - the verification code received via 2FA.
-   */
-  enable2FA(_0) {
-    return __async(this, arguments, function* ({ verificationCode }) {
-      yield this.ctx.client.enable2FA(this.userId, verificationCode);
-    });
-  }
-  /**
-   * Determines if 2FA has been set up.
-   * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
-   */
-  check2FAStatus() {
-    return __async(this, null, function* () {
-      if (!this.userId) {
-        return { isSetup: false };
-      }
-      const res = yield this.ctx.client.check2FAStatus(this.userId);
-      return {
-        isSetup: res.data.isSetup
-      };
-    });
-  }
-  /**
-   * Resend a verification email for the current user.
-   */
-  resendVerificationCode() {
-    return __async(this, null, function* () {
-      yield this.ctx.client.resendVerificationCode(__spreadValues({
-        userId: this.userId
-      }, this.getVerificationEmailProps()));
-    });
-  }
-  /**
-   * Resend a verification SMS for the current user.
-   */
-  resendVerificationCodeByPhone() {
-    return __async(this, null, function* () {
-      yield this.ctx.client.resendVerificationCodeByPhone({
-        userId: this.userId
-      });
-    });
-  }
-  /**
-   * Returns a URL for setting up a new WebAuth passkey.
-   * @param {Object} opts the options object
-   * @param {string} opts.authType - the auth type to use
-   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
-   * @returns {string} the URL
-   */
-  getSetUpBiometricsURL() {
-    return __async(this, arguments, function* ({
-      authType = "email",
-      isForNewDevice = false
-    } = {}) {
-      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
-        status: import_user_management_client5.PublicKeyStatus.PENDING,
-        type: import_user_management_client5.PublicKeyType.WEB
-      });
-      return this.getWebAuthURLForCreate({
-        authType,
-        isForNewDevice,
-        webAuthId: res.data.id,
-        partnerId: res.data.partnerId
-      });
-    });
-  }
-  /**
-   * Returns a URL for setting up a new WebAuth passkey for a phone number.
-   * @param {Object} opts the options object
-   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
-   * @returns {string} the URL
-   */
-  getSetUpBiometricsURLForPhone() {
-    return __async(this, arguments, function* ({
-      isForNewDevice = false
-    } = {}) {
-      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
-        status: import_user_management_client5.PublicKeyStatus.PENDING,
-        type: import_user_management_client5.PublicKeyType.WEB
-      });
-      return this.getWebAuthURLForCreate({
-        authType: "phone",
-        isForNewDevice,
-        webAuthId: res.data.id,
-        partnerId: res.data.partnerId
-      });
-    });
-  }
-  /**
-   * Returns a URL for setting up a new password.
-   * @param {Object} opts the options object
-   * @param {string} opts.authType - the auth type to use
-   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
-   * @param {Theme} [opts.theme] the portal theme to use in place of the partner's default
-   * @returns {string} the URL
-   */
-  getSetupPasswordURL() {
-    return __async(this, arguments, function* ({
-      authType = "email",
-      isForNewDevice = false,
-      theme
-    } = {}) {
-      const res = yield this.ctx.client.addSessionPasswordPublicKey(this.userId, {
-        status: import_user_management_client5.PasswordStatus.PENDING
-      });
-      return this.getPasswordURLForCreate({
-        authType,
-        isForNewDevice,
-        passwordId: res.data.id,
-        partnerId: res.data.partnerId,
-        theme
-      });
-    });
-  }
-  /**
-   * Checks if the current session is active.
-   * @returns `true` if active, `false` otherwise
-   */
-  isSessionActive() {
-    return __async(this, null, function* () {
-      if (this.isUsingExternalWallet()) {
-        return true;
-      }
-      const res = yield this.touchSession();
-      return !!res.data.isAuthenticated;
-    });
-  }
-  /**
-   * Checks if a session is active and a wallet exists.
-   * @returns `true` if active, `false` otherwise
-   **/
-  isFullyLoggedIn() {
-    return __async(this, null, function* () {
-      if (this.isUsingExternalWallet()) {
-        return true;
-      }
-      const isSessionActive = yield this.isSessionActive();
-      return isSessionActive && this.currentWalletIdsArray.length > 0 && this.currentWalletIdsArray.reduce((acc, [id]) => acc && !!this.wallets[id], true);
-    });
-  }
-  supportedAuthMethods(auth) {
-    return __async(this, null, function* () {
-      const { supportedAuthMethods } = yield this.ctx.client.getSupportedAuthMethods(auth);
-      const authMethods = /* @__PURE__ */ new Set();
-      for (const type of supportedAuthMethods) {
-        switch (type) {
-          case "PASSWORD":
-            authMethods.add(import_user_management_client5.AuthMethod.PASSWORD);
-            break;
-          case "BIOMETRIC":
-            authMethods.add(import_user_management_client5.AuthMethod.PASSKEY);
-            break;
-        }
-      }
-      return authMethods;
-    });
-  }
-  /**
-   * Get hints associated with the users stored biometrics.
-   * @returns Array containing useragents and AAGuids for stored biometrics
-   */
-  getUserBiometricLocationHints() {
-    return __async(this, null, function* () {
-      var _a;
-      if (!this.email && !this.phone && !this.farcasterUsername && !this.telegramUserId && !this.isExternalWalletAuth) {
-        throw new Error(
-          "one of email, phone, farcaster username, telegram user id or external wallet with Para auth are required to get biometric location hints"
-        );
-      }
-      return yield this.ctx.client.getBiometricLocationHints({
-        email: this.email,
-        phone: this.phone,
-        countryCode: this.countryCode,
-        farcasterUsername: this.farcasterUsername,
-        telegramUserId: this.telegramUserId,
-        // Using id here since we store the bech32 address for cosmos in the address field of the wallet
-        externalWalletAddress: (_a = this.externalWalletWithParaAuth) == null ? void 0 : _a.id
-      });
-    });
-  }
-  setAuth(auth) {
-    return __async(this, null, function* () {
-      const authInfo = (0, import_user_management_client5.extractAuthInfo)(auth);
-      if (!authInfo) {
-        return void 0;
-      }
-      switch (authInfo.authType) {
-        case "email":
-          yield this.setEmail(authInfo.identifier);
-          break;
-        case "phone":
-          yield this.setPhoneNumber(authInfo.auth.phone, authInfo.auth.countryCode);
-          break;
-        case "farcaster":
-          yield this.setFarcasterUsername(authInfo.identifier);
-          break;
-        case "telegram":
-          yield this.setTelegramUserId(authInfo.identifier);
-          break;
-      }
-      return authInfo;
-    });
-  }
-  /**
-   * Initiates a login.
-   * @param {Object} opts the options object
-   * @param {String} opts.email - the email to login with
-   * @param {boolean} opts.useShortURL - whether to shorten the link
-   * @returns - the WebAuth URL for logging in
-   **/
-  initiateUserLogin(_e) {
-    return __async(this, null, function* () {
-      var _f = _e, { useShortUrl = false } = _f, auth = __objRest(_f, ["useShortUrl"]);
-      const authInfo = yield this.setAuth(auth);
-      if (!authInfo) {
-        return;
-      }
-      const res = yield this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        yield this.setLoginEncryptionKeyPair();
-      }
-      const webAuthLoginURL = yield this.getWebAuthURLForLogin({
-        authType: authInfo.authType,
-        sessionId: res.data.sessionId,
-        partnerId: res.data.partnerId,
-        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair)
-      });
-      if (!useShortUrl) {
-        return webAuthLoginURL;
-      }
-      return this.shortenLoginLink(webAuthLoginURL);
-    });
-  }
-  /**
-   * Initiates a login.
-   * @param email - the email to login with
-   * @returns - a set of supported auth methods for the user
-   **/
-  initiateUserLoginV2(auth) {
-    return __async(this, null, function* () {
-      const authInfo = yield this.setAuth(auth);
-      if (!authInfo) {
-        return;
-      }
-      yield this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        yield this.setLoginEncryptionKeyPair();
-      }
-      return yield this.supportedAuthMethods(authInfo.auth);
-    });
-  }
-  /**
-   * Initiates a login.
-   * @param opts the options object
-   * @param opts.phone the phone number
-   * @param opts.countryCode the country code
-   * @param opts.useShortURL - whether to shorten the link
-   * @returns - the WebAuth URL for logging in
-   **/
-  initiateUserLoginForPhone(_g) {
-    return __async(this, null, function* () {
-      var _h = _g, {
-        useShortUrl = false
-      } = _h, auth = __objRest(_h, [
-        "useShortUrl"
-      ]);
-      yield this.setAuth(auth);
-      const res = yield this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        yield this.setLoginEncryptionKeyPair();
-      }
-      const webAuthLoginURL = yield this.getWebAuthURLForLoginForPhone({
-        sessionId: res.data.sessionId,
-        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair),
-        partnerId: res.data.partnerId
-      });
-      if (!useShortUrl) {
-        return webAuthLoginURL;
-      }
-      return this.shortenLoginLink(webAuthLoginURL);
-    });
-  }
-  /**
-   * Waits for the session to be active.
-   **/
-  waitForAccountCreation() {
-    return __async(this, arguments, function* ({ popupWindow } = {}) {
-      yield this.touchSession();
-      if (!this.isExternalWalletAuth) {
-        this.externalWallets = {};
-      }
-      this.isAwaitingAccountCreation = true;
-      while (this.isAwaitingAccountCreation) {
-        try {
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-          if (yield this.isSessionActive()) {
-            this.isAwaitingAccountCreation = false;
-            dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
-            return true;
-          } else {
-            if (popupWindow == null ? void 0 : popupWindow.closed) {
-              this.isAwaitingAccountCreation = false;
-              return false;
-            }
-          }
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      return false;
-    });
-  }
-  waitForPasskeyAndCreateWallet() {
-    return __async(this, arguments, function* ({
-      popupWindow
-    } = {}) {
-      yield this.waitForAccountCreation({ popupWindow });
-      const pregenWallets = yield this.getPregenWallets();
-      let recoverySecret, walletIds = {};
-      if (pregenWallets.length > 0) {
-        recoverySecret = yield this.claimPregenWallets();
-        walletIds = this.supportedWalletTypes.reduce((acc, { type }) => {
-          var _a;
-          return __spreadProps(__spreadValues({}, acc), {
-            [type]: [(_a = pregenWallets.find((w) => !!WalletSchemeTypeMap[w.scheme][type])) == null ? void 0 : _a.id]
-          });
-        }, {});
-      }
-      const created = yield this.createWalletPerType();
-      recoverySecret = recoverySecret != null ? recoverySecret : created.recoverySecret;
-      walletIds = __spreadValues(__spreadValues({}, walletIds), created.walletIds);
-      const resp = { walletIds, recoverySecret };
-      dispatchEvent(ParaEvent.ACCOUNT_SETUP_EVENT, resp);
-      return resp;
-    });
-  }
-  /**
-   * Initiates a Farcaster login attempt and return the URI for the user to connect.
-   * You can create a QR code with this URI that works with Farcaster's mobile app.
-   * @return {string} the Farcaster connect URI
-   */
-  getFarcasterConnectURL() {
-    return __async(this, null, function* () {
-      yield this.logout();
-      yield this.touchSession(true);
-      const {
-        data: { connect_uri }
-      } = yield this.ctx.client.initializeFarcasterLogin();
-      return connect_uri;
-    });
-  }
-  /**
-   * Awaits the response from a user's attempt to log in with Farcaster.
-   * If successful, this returns the user's Farcaster username and profile picture and indicates whether the user already exists.
-   * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
-   */
-  waitForFarcasterStatus() {
-    return __async(this, null, function* () {
-      this.isAwaitingFarcaster = true;
-      while (this.isAwaitingFarcaster) {
-        try {
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-          const res = yield this.ctx.client.getFarcasterAuthStatus();
-          if (res.data.state === "completed") {
-            const { userId, userExists, username, pfpUrl } = res.data;
-            yield this.setUserId(userId);
-            yield this.setFarcasterUsername(username);
-            return {
-              userExists,
-              username,
-              pfpUrl
-            };
-          }
-        } catch (err) {
-          console.error(err);
-          this.isAwaitingFarcaster = false;
-        }
-      }
-    });
-  }
-  /**
-   * Generates a URL for the user to log in with OAuth using a desire method.
-   *
-   * @param {Object} opts the options object
-   * @param {OAuthMethod} opts.method the third-party service to use for OAuth.
-   * @param {string} [opts.deeplinkUrl] the deeplink to redirect to after the OAuth flow. This is for mobile only.
-   * @returns {string} the URL for the user to log in with OAuth.
-   */
-  getOAuthURL(_0) {
-    return __async(this, arguments, function* ({ method, deeplinkUrl }) {
-      yield this.logout();
-      const res = yield this.touchSession(true);
-      return constructUrl({
-        base: method === import_user_management_client5.OAuthMethod.TELEGRAM ? getPortalBaseURL(this.ctx, true) : getBaseOAuthUrl(this.ctx.env),
-        path: `/auth/${method.toLowerCase()}`,
-        params: {
-          apiKey: this.ctx.apiKey,
-          sessionLookupId: res.data.sessionLookupId,
-          deeplinkUrl
-        }
-      });
-    });
-  }
-  /**
-   * Awaits the response from a user's attempt to log in with OAuth.
-   * If successful, this returns the user's email address and indicates whether the user already exists.
-   *
-   * @param {Object} opts the options object.
-   * @param {Window} [opts.popupWindow] the popup window being used for login.
-   * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
-   */
-  waitForOAuth() {
-    return __async(this, arguments, function* ({ popupWindow } = {}) {
-      this.isAwaitingOAuth = true;
-      while (this.isAwaitingOAuth) {
-        try {
-          if (popupWindow == null ? void 0 : popupWindow.closed) {
-            return { isError: true, userExists: false };
-          }
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-          if (this.isAwaitingOAuth) {
-            const res = yield this.touchSession();
-            if (res.data.userId) {
-              const { userId, email } = res.data;
-              if (!this.loginEncryptionKeyPair) {
-                yield this.setLoginEncryptionKeyPair();
-              }
-              yield this.setUserId(userId);
-              yield this.setEmail(email);
-              const userExists = yield this.checkIfUserExists({ email });
-              this.isAwaitingOAuth = false;
-              return {
-                userExists,
-                email
-              };
-            }
-          }
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      return { userExists: false };
-    });
-  }
-  /**
-   * Waits for the session to be active and sets up the user.
-   *
-   * @param {Object} opts the options object
-   * @param {Window} [opts.popupWindow] the popup window being used for login.
-   * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
-   * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
-   **/
-  waitForLoginAndSetup() {
-    return __async(this, arguments, function* ({
-      popupWindow,
-      skipSessionRefresh = false
-    } = {}) {
-      var _a;
-      if (!this.isExternalWalletAuth) {
-        this.externalWallets = {};
-      }
-      this.isAwaitingLogin = true;
-      while (this.isAwaitingLogin) {
-        try {
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-          if (!(yield this.isSessionActive())) {
-            if (popupWindow == null ? void 0 : popupWindow.closed) {
-              const resp2 = { isComplete: false, isError: true };
-              dispatchEvent(ParaEvent.LOGIN_EVENT, resp2, "failed to setup user");
-              return resp2;
-            }
-            continue;
-          }
-          const postLoginData = yield this.userSetupAfterLogin();
-          const needsWallet = (_a = postLoginData.data.needsWallet) != null ? _a : false;
-          if (!needsWallet) {
-            if (this.currentWalletIdsArray.length === 0) {
-              if (popupWindow == null ? void 0 : popupWindow.closed) {
-                const resp2 = { isComplete: false, isError: true };
-                dispatchEvent(ParaEvent.LOGIN_EVENT, resp2, "failed to setup user");
-                return resp2;
-              } else {
-                continue;
-              }
-            }
-          }
-          const fetchedWallets = yield this.fetchWallets();
-          const tempSharesRes = yield this.getTransmissionKeyShares();
-          if (tempSharesRes.data.temporaryShares.length === fetchedWallets.length) {
-            yield this.setupAfterLogin({ temporaryShares: tempSharesRes.data.temporaryShares, skipSessionRefresh });
-            yield this.claimPregenWallets();
-            const resp2 = {
-              isComplete: true,
-              needsWallet: needsWallet || Object.values(this.wallets).length === 0,
-              partnerId: postLoginData.data.partnerId
-            };
-            dispatchEvent(ParaEvent.LOGIN_EVENT, resp2);
-            return resp2;
-          }
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      const resp = { isComplete: false };
-      dispatchEvent(ParaEvent.LOGIN_EVENT, resp, "exitted login without setting up user");
-      return resp;
-    });
-  }
-  /**
-   * Updates the session with the user management server, possibly
-   * opening a popup to refresh the session.
-   *
-   * @param {Object} opts the options object.
-   * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
-   * @returns a URL for the user to reauthenticate.
-   **/
-  refreshSession() {
-    return __async(this, arguments, function* ({ shouldOpenPopup = false } = {}) {
-      const res = yield this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        yield this.setLoginEncryptionKeyPair();
-      }
-      const link = yield this.getWebAuthURLForLogin({
-        sessionId: res.data.sessionId,
-        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair)
-      });
-      if (shouldOpenPopup) {
-        this.platformUtils.openPopup(link);
-      }
-      return link;
-    });
-  }
-  /**
-   * Call this method after login to ensure that the user ID is set
-   * internally.
-   **/
-  userSetupAfterLogin() {
-    return __async(this, null, function* () {
-      const res = yield this.touchSession();
-      yield this.setUserId(res.data.userId);
-      if (res.data.currentWalletIds && res.data.currentWalletIds !== this.currentWalletIds)
-        yield this.setCurrentWalletIds(res.data.currentWalletIds, {
-          sessionLookupId: this.isPortal() ? res.data.sessionLookupId : void 0
-        });
-      return res;
-    });
-  }
-  /**
-   * Get transmission shares associated with session.
-   * @param {Object} opts the options object.
-   * @param {boolean} opts.isForNewDevice - true if this device is registering.
-   * @returns - transmission keyshares.
-   **/
-  getTransmissionKeyShares() {
-    return __async(this, arguments, function* ({ isForNewDevice = false } = {}) {
-      const res = yield this.touchSession();
-      const sessionLookupId = isForNewDevice ? `${res.data.sessionLookupId}-new-device` : res.data.sessionLookupId;
-      return this.ctx.client.getTransmissionKeyshares(this.userId, sessionLookupId);
-    });
-  }
-  /**
-   * Call this method after login to perform setup.
-   * @param {Object} opts the options object.
-   * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
-   * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
-   **/
-  setupAfterLogin() {
-    return __async(this, arguments, function* ({
-      temporaryShares,
-      skipSessionRefresh = false
-    } = {}) {
-      if (!temporaryShares) {
-        temporaryShares = (yield this.getTransmissionKeyShares()).data.temporaryShares;
-      }
-      temporaryShares.forEach((share) => {
-        const signer = decryptWithPrivateKey(this.loginEncryptionKeyPair.privateKey, share.encryptedShare, share.encryptedKey);
-        this.wallets[share.walletId] = {
-          id: share.walletId,
-          signer
-        };
-      });
-      yield this.deleteLoginEncryptionKeyPair();
-      yield this.populateWalletAddresses();
-      yield this.touchSession(!skipSessionRefresh);
-    });
-  }
-  /**
-   * Distributes a new wallet recovery share.
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the wallet to distribute the recovery share for.
-   * @param {string} opts.userShare optional user share generate the recovery share from. Defaults to the signer from the passed in walletId
-   * @param {boolean} opts.skipBiometricShareCreation whether or not to skip biometric share creation. Used when regenerating recovery shares.
-   * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
-   * @returns {string} the recovery share.
-   **/
-  distributeNewWalletShare(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      userShare,
-      skipBiometricShareCreation = false,
-      forceRefresh = false
-    }) {
-      let userSigner = userShare;
-      if (!userSigner) {
-        userSigner = this.wallets[walletId].signer;
-      }
-      const recoveryShare = skipBiometricShareCreation ? yield sendRecoveryForShare({
-        ctx: this.ctx,
-        userId: this.userId,
-        walletId,
-        userSigner,
-        emailProps: this.getBackupKitEmailProps(),
-        forceRefresh
-      }) : yield distributeNewShare({
-        ctx: this.ctx,
-        userId: this.userId,
-        walletId,
-        userShare: userSigner,
-        emailProps: this.getBackupKitEmailProps()
-      });
-      return recoveryShare;
-    });
-  }
-  waitForWalletAddress(walletId) {
-    return __async(this, null, function* () {
-      let maxPolls = 0;
-      while (true) {
-        try {
-          if (maxPolls === 10) {
-            break;
-          }
-          ++maxPolls;
-          const res = yield this.ctx.client.getWallets(this.userId);
-          const wallet = res.data.wallets.find((w) => w.id === walletId);
-          if (wallet && wallet.address) {
-            return;
-          }
-          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      throw new Error("timed out waiting for wallet address");
-    });
-  }
-  /**
-   * Waits for a pregen wallet address to be created.
-   *
-   * @param pregenIdentifier - the identifier of the user the pregen wallet is associated with.
-   * @param walletId - the wallet id
-   * @param pregenIdentifierType - the identifier type of the user the pregen wallet is associated with.
-   * @returns - recovery share.
-   **/
-  waitForPregenWalletAddress(walletId) {
-    return __async(this, null, function* () {
-      let maxPolls = 0;
-      while (true) {
-        try {
-          if (maxPolls === 10) {
-            break;
-          }
-          ++maxPolls;
-          const res = yield this.getPregenWallets();
-          const wallet = res.find((w) => w.id === walletId);
-          if (wallet && wallet.address) {
-            return;
-          }
-          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      throw new Error("timed out waiting for wallet address");
-    });
-  }
-  /**
-   * Creates several new wallets with the desired types. If no types are provided, this method
-   * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
-   * object that are not already present. This is automatically called upon account creation to ensure that
-   * the user has a wallet of each required type.
-   *
-   * @param {Object} [opts] the options object.
-   * @param {boolean} [opts.skipDistribute] if `true`, the wallets' recovery share will not be distributed.
-   * @param {WalletType[]} [opts.types] the types of wallets to create.
-   * @returns {Object} the wallets created, their ids, and the recovery secret.
-   **/
-  createWalletPerType() {
-    return __async(this, arguments, function* ({
-      skipDistribute = false,
-      types
-    } = {}) {
-      const wallets = [];
-      const walletIds = {};
-      let recoverySecret;
-      for (const type of yield this.getTypesToCreate(types)) {
-        const [wallet, recoveryShare] = yield this.createWallet({ type, skipDistribute });
-        wallets.push(wallet);
-        getEquivalentTypes(type).filter((t) => !!this.isWalletTypeEnabled[t]).forEach((t) => {
-          walletIds[t] = [wallet.id];
-        });
-        if (recoveryShare) {
-          recoverySecret = recoveryShare;
-        }
-      }
-      return { wallets, walletIds, recoverySecret };
-    });
-  }
-  /**
-   * Refresh the current user share for a wallet.
-   *
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the wallet id to refresh.
-   * @param {string} opts.share the current user share.
-   * @param {string} [opts.oldPartnerId] the current partner id.
-   * @param {string} [opts.newPartnerId] the new partner id to set, if any.
-   * @param {string} [opts.keyShareProtocolId]
-   * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
-   * @returns {Object} the new user share and recovery secret.
-   **/
-  refreshShare(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      share,
-      oldPartnerId,
-      newPartnerId,
-      keyShareProtocolId,
-      redistributeBackupEncryptedShares
-    }) {
-      const { signer, protocolId } = yield this.platformUtils.refresh(
-        this.ctx,
-        this.retrieveSessionCookie(),
-        this.userId,
-        walletId,
-        share,
-        oldPartnerId,
-        newPartnerId,
-        keyShareProtocolId
-      );
-      const recoverySecret = yield distributeNewShare({
-        ctx: this.ctx,
-        userId: this.userId,
-        walletId,
-        userShare: signer,
-        ignoreRedistributingBackupEncryptedShare: !redistributeBackupEncryptedShares,
-        emailProps: this.getBackupKitEmailProps(),
-        partnerId: newPartnerId,
-        protocolId
-      });
-      return { signer, recoverySecret, protocolId };
-    });
-  }
-  /**
-   * Creates a new wallet.
-   * @param {Object} opts the options object.
-   * @param {WalletType} opts.type the type of wallet to create.
-   * @param {boolean} opts.skipDistribute - if true, recovery share will not be distributed.
-   * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
-   **/
-  createWallet() {
-    return __async(this, arguments, function* ({
-      type: _type,
-      skipDistribute = false
-    } = {}) {
-      var _a, _b;
-      this.requireApiKey();
-      const walletType = yield this.assertIsValidWalletType(
-        _type != null ? _type : (_a = this.supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type
-      );
-      let signer;
-      let wallet;
-      let keygenRes;
-      switch (walletType) {
-        case import_user_management_client5.WalletType.SOLANA: {
-          keygenRes = yield this.platformUtils.ed25519Keygen(
-            this.ctx,
-            this.userId,
-            this.retrieveSessionCookie(),
-            this.getBackupKitEmailProps()
-          );
-          break;
-        }
-        default: {
-          keygenRes = yield this.platformUtils.keygen(
-            this.ctx,
-            this.userId,
-            walletType,
-            null,
-            this.retrieveSessionCookie(),
-            this.getBackupKitEmailProps()
-          );
-          break;
-        }
-      }
-      const walletId = keygenRes.walletId;
-      signer = keygenRes.signer;
-      this.wallets[walletId] = {
-        id: walletId,
-        signer,
-        scheme: walletType === import_user_management_client5.WalletType.SOLANA ? import_user_management_client5.WalletScheme.ED25519 : import_user_management_client5.WalletScheme.DKLS,
-        type: walletType
-      };
-      wallet = this.wallets[walletId];
-      yield this.waitForWalletAddress(wallet.id);
-      yield this.populateWalletAddresses();
-      let recoveryShare = null;
-      if (!skipDistribute) {
-        recoveryShare = yield distributeNewShare({
-          ctx: this.ctx,
-          userId: this.userId,
-          walletId: wallet.id,
-          userShare: signer,
-          emailProps: this.getBackupKitEmailProps()
-        });
-      }
-      yield this.setCurrentWalletIds(__spreadProps(__spreadValues({}, this.currentWalletIds), {
-        [walletType]: [...(_b = this.currentWalletIds[walletType]) != null ? _b : [], walletId]
-      }));
-      const walletNoSigner = __spreadValues({}, wallet);
-      delete walletNoSigner.signer;
-      dispatchEvent(ParaEvent.WALLET_CREATED, {
-        wallet: walletNoSigner,
-        recoverySecret: recoveryShare
-      });
-      return [wallet, recoveryShare];
-    });
-  }
-  /**
-   * Creates a new pregenerated wallet.
-   *
-   * @param {Object} opts the options object.
-   * @param {string} opts.pregenIdentifier the identifier associated with the new wallet.
-   * @param {TPregenIdentifierType} [opts.pregenIdentifierType] the identifier type. Defaults to `EMAIL`.
-   * @param {WalletType} [opts.type] the type of wallet to create. Defaults to the first non-optional type in the instance's `supportedWalletTypes` array.
-   * @returns {Wallet} the created wallet.
-   **/
-  createPregenWallet(opts) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const {
-        type: _type = (_a = this.supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type,
-        pregenIdentifier,
-        pregenIdentifierType = "EMAIL"
-      } = opts;
-      this.requireApiKey();
-      const walletType = yield this.assertIsValidWalletType(
-        _type != null ? _type : (_b = this.supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _b.type
-      );
-      let keygenRes;
-      switch (walletType) {
-        case import_user_management_client5.WalletType.SOLANA:
-          keygenRes = yield this.platformUtils.ed25519PreKeygen(
-            this.ctx,
-            pregenIdentifier,
-            pregenIdentifierType,
-            this.retrieveSessionCookie()
-          );
-          break;
-        default:
-          keygenRes = yield this.platformUtils.preKeygen(
-            this.ctx,
-            void 0,
-            pregenIdentifier,
-            pregenIdentifierType,
-            walletType,
-            null,
-            this.retrieveSessionCookie()
-          );
-          break;
-      }
-      const { signer, walletId } = keygenRes;
-      this.wallets[walletId] = {
-        id: walletId,
-        signer,
-        scheme: walletType === import_user_management_client5.WalletType.SOLANA ? import_user_management_client5.WalletScheme.ED25519 : import_user_management_client5.WalletScheme.DKLS,
-        type: walletType,
-        isPregen: true,
-        pregenIdentifier,
-        pregenIdentifierType
-      };
-      yield this.waitForPregenWalletAddress(walletId);
-      yield this.populatePregenWalletAddresses();
-      return this.wallets[walletId];
-    });
-  }
-  /**
-   * Creates new pregenerated wallets for each desired type.
-   * If no types are provided, this method will create one for each of the non-optional types
-   * specified in the instance's `supportedWalletTypes` array that are not already present.
-   * @param {Object} opts the options object.
-   * @param {string} opts.pregenIdentifier the identifier to associate each wallet with.
-   * @param {TPregenIdentifierType} opts.pregenIdentifierType - either `'EMAIL'` or `'PHONE'`.
-   * @param {WalletType[]} [opts.types] the wallet types to create. Defaults to any types the instance supports that are not already present.
-   * @returns {Wallet[]} an array containing the created wallets.
-   **/
-  createPregenWalletPerType(_0) {
-    return __async(this, arguments, function* ({
-      types,
-      pregenIdentifier,
-      pregenIdentifierType = "EMAIL"
-    }) {
-      const wallets = [];
-      for (const type of yield this.getTypesToCreate(types)) {
-        const wallet = yield this.createPregenWallet({ type, pregenIdentifier, pregenIdentifierType });
-        wallets.push(wallet);
-      }
-      return wallets;
-    });
-  }
-  /**
-   * Claims a pregenerated wallet.
-   *
-   * @param {Object} opts the options object.
-   * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
-   * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the identifier of the user claiming the wallet
-   * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
-   **/
-  claimPregenWallets() {
-    return __async(this, arguments, function* ({
-      pregenIdentifier,
-      pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
-    } = {}) {
-      var _a;
-      this.requireApiKey();
-      const pregenWallets = pregenIdentifier && pregenIdentifierType ? yield this.getPregenWallets({ pregenIdentifier, pregenIdentifierType }) : yield this.getPregenWallets();
-      if (pregenWallets.length === 0) {
-        return void 0;
-      }
-      const missingWallets = pregenWallets.filter((wallet) => !this.wallets[wallet.id]);
-      if (missingWallets.length > 0) {
-        throw new Error(
-          `Cannot claim pregen wallets because wallet data is missing. Please call setUserShare first to load the wallet data for the following wallet IDs: ${missingWallets.map((w) => w.id).join(", ")}`
-        );
-      }
-      let newRecoverySecret;
-      const { walletIds } = yield this.ctx.client.claimPregenWallets({
-        userId: this.userId,
-        walletIds: pregenWallets.map((w) => w.id)
-      });
-      for (const walletId of walletIds) {
-        const wallet = this.wallets[walletId];
-        let refreshedShare;
-        if (wallet.scheme === import_user_management_client5.WalletScheme.ED25519) {
-          const distributeRes = yield distributeNewShare({
-            ctx: this.ctx,
-            userId: this.userId,
-            walletId: wallet.id,
-            userShare: this.wallets[wallet.id].signer,
-            emailProps: this.getBackupKitEmailProps(),
-            partnerId: wallet.partnerId
-          });
-          if (distributeRes.length > 0) {
-            newRecoverySecret = distributeRes;
-          }
-        } else {
-          refreshedShare = yield this.refreshShare({
-            walletId: wallet.id,
-            share: this.wallets[wallet.id].signer,
-            oldPartnerId: wallet.partnerId,
-            newPartnerId: wallet.partnerId,
-            redistributeBackupEncryptedShares: true
-          });
-          if (refreshedShare.recoverySecret) {
-            newRecoverySecret = refreshedShare.recoverySecret;
-          }
-        }
-        this.wallets[wallet.id] = __spreadProps(__spreadValues({}, this.wallets[wallet.id]), {
-          signer: (_a = refreshedShare == null ? void 0 : refreshedShare.signer) != null ? _a : wallet.signer,
-          userId: this.userId,
-          pregenIdentifier: void 0,
-          pregenIdentifierType: void 0
-        });
-        const walletNoSigner = __spreadValues({}, this.wallets[wallet.id]);
-        delete walletNoSigner.signer;
-        dispatchEvent(ParaEvent.PREGEN_WALLET_CLAIMED, {
-          wallet: walletNoSigner,
-          recoverySecret: newRecoverySecret
-        });
-      }
-      yield this.setWallets(this.wallets);
-      return newRecoverySecret;
-    });
-  }
-  /**
-   * Updates the identifier for a pregen wallet.
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the pregen wallet ID
-   * @param {string} opts.newPregenIdentifier the new identtifier
-   * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
-   **/
-  updatePregenWalletIdentifier(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      newPregenIdentifier,
-      newPregenIdentifierType
-    }) {
-      this.requireApiKey();
-      yield this.ctx.client.updatePregenWallet(walletId, {
-        pregenIdentifier: newPregenIdentifier,
-        pregenIdentifierType: newPregenIdentifierType
-      });
-      if (!!this.wallets[walletId]) {
-        this.wallets[walletId] = __spreadProps(__spreadValues({}, this.wallets[walletId]), {
-          pregenIdentifier: newPregenIdentifier,
-          pregenIdentifierType: newPregenIdentifierType
-        });
-        yield this.setWallets(this.wallets);
-      }
-    });
-  }
-  /**
-   * Checks if a pregen Wallet exists for the given identifier with the current partner.
-   * @param {Object} opts the options object.
-   * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
-   * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
-   * @returns {boolean} whether the pregen wallet exists
-   **/
-  hasPregenWallet(_0) {
-    return __async(this, arguments, function* ({
-      pregenIdentifier,
-      pregenIdentifierType
-    }) {
-      this.requireApiKey();
-      const res = yield this.getPregenWallets({ pregenIdentifier, pregenIdentifierType });
-      const wallet = res.find((w) => w.pregenIdentifier === pregenIdentifier && w.pregenIdentifierType === pregenIdentifierType);
-      if (!wallet) {
-        return false;
-      }
-      return true;
-    });
-  }
-  /**
-   * Get pregen wallets for the given identifier.
-   * @param {Object} opts the options object.
-   * @param {string} opts.pregenIdentifier - the identifier of the user claiming the wallet
-   * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
-   * @returns {Promise<WalletEntity[]>} the array of found wallets
-   **/
-  getPregenWallets() {
-    return __async(this, arguments, function* ({
-      pregenIdentifier,
-      pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
-    } = {}) {
-      this.requireApiKey();
-      const res = yield this.ctx.client.getPregenWallets(
-        pregenIdentifier && pregenIdentifierType ? { [pregenIdentifierType]: [pregenIdentifier] } : this.pregenIds,
-        this.isPortal(),
-        this.userId
-      );
-      return res.wallets.filter((w) => this.isWalletSupported(entityToWallet(w)));
-    });
-  }
-  encodeWalletBase64(wallet) {
-    const walletJson = JSON.stringify(wallet);
-    const base64Wallet = Buffer.from(walletJson).toString("base64");
-    return base64Wallet;
-  }
-  /**
-   * Encodes the current wallets encoded in Base 64.
-   * @returns {string} the encoded wallet string
-   **/
-  getUserShare() {
-    if (Object.values(this.wallets).length === 0) {
-      return null;
-    }
-    return Object.values(this.wallets).map((wallet) => this.encodeWalletBase64(wallet)).join("-");
-  }
-  /**
-   * Sets the current wallets from a Base 64 string.
-   * @param {string} base64Wallet the encoded wallet string
-   **/
-  setUserShare(base64Wallets) {
-    return __async(this, null, function* () {
-      if (!base64Wallets) {
-        return;
-      }
-      const base64WalletsSplit = base64Wallets.split("-");
-      for (const base64Wallet of base64WalletsSplit) {
-        const walletJson = Buffer.from(base64Wallet, "base64").toString();
-        const wallet = migrateWallet(JSON.parse(walletJson));
-        this.wallets[wallet.id] = wallet;
-        yield this.setWallets(this.wallets);
-      }
-    });
-  }
-  getTransactionReviewUrl(transactionId, timeoutMs) {
-    return __async(this, null, function* () {
-      const res = yield this.touchSession();
-      return this.constructPortalUrl("txReview", {
-        partnerId: res.data.partnerId,
-        pathId: transactionId,
-        params: {
-          email: this.email,
-          timeoutMs: timeoutMs == null ? void 0 : timeoutMs.toString()
-        }
-      });
-    });
-  }
-  getOnRampTransactionUrl(_i) {
-    return __async(this, null, function* () {
-      var _j = _i, {
-        purchaseId,
-        providerKey
-      } = _j, walletParams = __objRest(_j, [
-        "purchaseId",
-        "providerKey"
-      ]);
-      const res = yield this.touchSession();
-      const [key, identifier] = (0, import_user_management_client5.extractWalletRef)(walletParams);
-      return this.constructPortalUrl("onRamp", {
-        partnerId: res.data.partnerId,
-        pathId: purchaseId,
-        sessionId: res.data.sessionId,
-        params: {
-          [key]: identifier,
-          providerKey,
-          currentWalletIds: JSON.stringify(this.currentWalletIds)
-        }
-      });
-    });
-  }
-  /**
-   * Signs a message using one of the current wallets.
-   *
-   * If you want to sign the keccak256 hash of a message, hash the
-   * message first and then pass in the base64 encoded hash.
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the id of the wallet to sign with.
-   * @param {string} opts.messageBase64 the base64 encoding of exact message that should be signed
-   * @param {number} [opts.timeout] optional timeout in milliseconds. If not present, defaults to 30 seconds.
-   * @param {string} [opts.cosmosSignDocBase64] the Cosmos `SignDoc` in base64, if applicable
-   **/
-  signMessage(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      messageBase64,
-      timeoutMs = 3e4,
-      cosmosSignDocBase64
-    }) {
-      this.assertIsValidWalletId(walletId);
-      const wallet = this.wallets[walletId];
-      let signerId = this.userId;
-      if (wallet.partnerId && !wallet.userId) {
-        signerId = wallet.partnerId;
-      }
-      let signRes = yield this.signMessageInner({ wallet, signerId, messageBase64, cosmosSignDocBase64 });
-      let timeStart = Date.now();
-      if (signRes.pendingTransactionId) {
-        this.platformUtils.openPopup(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId, timeoutMs),
-          { type: cosmosSignDocBase64 ? "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ : "SIGN_MESSAGE_REVIEW" /* SIGN_MESSAGE_REVIEW */ }
-        );
-      } else {
-        dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes);
-        return signRes;
-      }
-      yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-      while (true) {
-        if (Date.now() - timeStart > timeoutMs) {
-          break;
-        }
-        try {
-          yield this.ctx.client.getPendingTransaction(this.userId, signRes.pendingTransactionId);
-        } catch (err) {
-          const error = new TransactionReviewDenied();
-          dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes, error.message);
-          throw error;
-        }
-        signRes = yield this.signMessageInner({ wallet, signerId, messageBase64, cosmosSignDocBase64 });
-        if (signRes.pendingTransactionId) {
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        } else {
-          break;
-        }
-      }
-      if (signRes.pendingTransactionId) {
-        const error = new TransactionReviewTimeout(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId),
-          signRes.pendingTransactionId
-        );
-        dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes, error.message);
-        throw error;
-      }
-      dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes);
-      return signRes;
-    });
-  }
-  signMessageInner(_0) {
-    return __async(this, arguments, function* ({
-      wallet,
-      signerId,
-      messageBase64,
-      cosmosSignDocBase64
-    }) {
-      let signRes;
-      switch (wallet.scheme) {
-        case import_user_management_client5.WalletScheme.ED25519:
-          signRes = yield this.platformUtils.ed25519Sign(
-            this.ctx,
-            signerId,
-            wallet.id,
-            wallet.signer,
-            messageBase64,
-            this.retrieveSessionCookie()
-          );
-          break;
-        default:
-          signRes = yield this.platformUtils.signMessage(
-            this.ctx,
-            signerId,
-            wallet.id,
-            wallet.signer,
-            messageBase64,
-            this.retrieveSessionCookie(),
-            wallet.scheme === import_user_management_client5.WalletScheme.DKLS,
-            cosmosSignDocBase64
-          );
-          break;
-      }
-      return signRes;
-    });
-  }
-  /**
-   * Signs a transaction.
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the id of the wallet to sign with.
-   * @param {string} opts.rlpEncodedTxBase64 the transaction to sign, in RLP base64 encoding
-   * @param {string} [opts.chainId] the EVM chain id of the chain the transaction is being sent on, if applicable
-   * @param {number} [opts.timeoutMs] the amount of time to wait for the user to sign the transaction, in milliseconds
-   **/
-  signTransaction(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      rlpEncodedTxBase64,
-      chainId,
-      timeoutMs = 3e4
-    }) {
-      this.assertIsValidWalletId(walletId);
-      const wallet = this.wallets[walletId];
-      let signerId = this.userId;
-      if (wallet.partnerId && !wallet.userId) {
-        signerId = wallet.partnerId;
-      }
-      let signRes = yield this.platformUtils.signTransaction(
-        this.ctx,
-        signerId,
-        walletId,
-        this.wallets[walletId].signer,
-        rlpEncodedTxBase64,
-        chainId,
-        this.retrieveSessionCookie(),
-        wallet.scheme === import_user_management_client5.WalletScheme.DKLS
-      );
-      let timeStart = Date.now();
-      if (signRes.pendingTransactionId) {
-        this.platformUtils.openPopup(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId, timeoutMs),
-          { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
-        );
-      } else {
-        dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes);
-        return signRes;
-      }
-      yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-      while (true) {
-        if (Date.now() - timeStart > timeoutMs) {
-          break;
-        }
-        try {
-          yield this.ctx.client.getPendingTransaction(this.userId, signRes.pendingTransactionId);
-        } catch (err) {
-          const error = new TransactionReviewDenied();
-          dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes, error.message);
-          throw error;
-        }
-        signRes = yield this.platformUtils.signTransaction(
-          this.ctx,
-          signerId,
-          walletId,
-          this.wallets[walletId].signer,
-          rlpEncodedTxBase64,
-          chainId,
-          this.retrieveSessionCookie(),
-          wallet.scheme === import_user_management_client5.WalletScheme.DKLS
-        );
-        if (signRes.pendingTransactionId) {
-          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        } else {
-          break;
-        }
-      }
-      if (signRes.pendingTransactionId) {
-        const error = new TransactionReviewTimeout(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId),
-          signRes.pendingTransactionId
-        );
-        dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes, error.message);
-        throw error;
-      }
-      dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes);
-      return signRes;
-    });
-  }
-  /**
-   * @deprecated
-   * Sends a transaction.
-   * @param walletId - id of the wallet to send the transaction from.
-   * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
-   * @param chainId - chain id of the chain the transaction is being sent on.
-   **/
-  sendTransaction(_0) {
-    return __async(this, arguments, function* ({
-      walletId,
-      rlpEncodedTxBase64,
-      chainId
-    }) {
-      this.assertIsValidWalletId(walletId);
-      const wallet = this.wallets[walletId];
-      const signRes = yield this.platformUtils.sendTransaction(
-        this.ctx,
-        this.userId,
-        walletId,
-        this.wallets[walletId].signer,
-        rlpEncodedTxBase64,
-        chainId,
-        this.retrieveSessionCookie(),
-        wallet.scheme === import_user_management_client5.WalletScheme.DKLS
-      );
-      if (signRes.pendingTransactionId) {
-        this.platformUtils.openPopup(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId),
-          { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
-        );
-        const error = new TransactionReviewError(
-          yield this.getTransactionReviewUrl(signRes.pendingTransactionId)
-        );
-        throw error;
-      }
-      return signRes;
-    });
-  }
-  isProviderModalDisabled() {
-    return !!this.disableProviderModal;
-  }
-  /**
-   * Starts a on-ramp or off-ramp transaction and returns the Para Portal link for the user to finalize and complete it.
-   * @param {Object} opts the options object
-   * @param {OnRampPurchaseCreateParams} opts.params the transaction settings.
-   * @param {boolean} opts.shouldOpenPopup if `true`, a popup window with the link will be opened.
-   * @param {string} opts.walletId the wallet ID to use for the transaction, where funds will be sent or withdrawn.
-   * @param {string} opts.externalWalletAddress the external wallet address to send funds to or withdraw funds from, if using an external wallet.
-   **/
-  initiateOnRampTransaction(options) {
-    return __async(this, null, function* () {
-      var _b;
-      const _a = options, { params, shouldOpenPopup } = _a, walletParams = __objRest(_a, ["params", "shouldOpenPopup"]);
-      const onRampPurchase = yield this.ctx.client.createOnRampPurchase(__spreadValues({
-        userId: this.userId,
-        params: __spreadProps(__spreadValues({}, params), {
-          address: (_b = walletParams.externalWalletAddress) != null ? _b : this.getDisplayAddress(walletParams.walletId, { addressType: params.walletType })
-        })
-      }, walletParams));
-      const portalUrl = yield this.getOnRampTransactionUrl(__spreadValues({
-        purchaseId: onRampPurchase.id,
-        providerKey: onRampPurchase.providerKey
-      }, walletParams));
-      if (shouldOpenPopup) {
-        this.platformUtils.openPopup(portalUrl, { type: "ON_RAMP_TRANSACTION" /* ON_RAMP_TRANSACTION */ });
-      }
-      return { onRampPurchase, portalUrl };
-    });
-  }
-  /**
-   * Returns `true` if session was successfully kept alive, `false` otherwise.
-   **/
-  keepSessionAlive() {
-    return __async(this, null, function* () {
-      try {
-        yield this.ctx.client.keepSessionAlive(this.userId);
-        return true;
-      } catch (err) {
-        return false;
-      }
-    });
-  }
-  /**
-   * Serialize the current session for import by another Para instance.
-   * @param {boolean} excludeSigners - whether or not to exclude the signer from the exported wallets.
-   * @returns {string} the serialized session
-   */
-  exportSession({ excludeSigners } = {}) {
-    const sessionInfo = {
-      email: this.email,
-      userId: this.userId,
-      wallets: structuredClone(this.wallets),
-      currentWalletIds: this.currentWalletIds,
-      sessionCookie: this.sessionCookie,
-      phone: this.phone,
-      countryCode: this.countryCode,
-      telegramUserId: this.telegramUserId,
-      farcasterUsername: this.farcasterUsername,
-      externalWallets: this.externalWallets
-    };
-    if (excludeSigners) {
-      for (const wallet of Object.values(sessionInfo.wallets)) {
-        delete wallet.signer;
-      }
-    }
-    return Buffer.from(JSON.stringify(sessionInfo)).toString("base64");
-  }
-  /**
-   * Imports a session serialized by another Para instance.
-   * @param {string} serializedInstanceBase64 the serialized session
-   */
-  importSession(serializedInstanceBase64) {
-    return __async(this, null, function* () {
-      var _a;
-      const serializedInstance = Buffer.from(serializedInstanceBase64, "base64").toString("utf8");
-      const sessionInfo = JSON.parse(serializedInstance);
-      yield this.setEmail(sessionInfo.email);
-      yield this.setTelegramUserId(sessionInfo.telegramUserId);
-      yield this.setFarcasterUsername(sessionInfo.farcasterUsername);
-      yield this.setUserId(sessionInfo.userId);
-      yield this.setWallets(sessionInfo.wallets);
-      yield this.setExternalWallets(sessionInfo.externalWallets || {});
-      for (const walletId of Object.keys(this.wallets)) {
-        if (!this.wallets[walletId].userId) {
-          this.wallets[walletId].userId = this.userId;
-        }
-      }
-      if (Object.keys(sessionInfo.currentWalletIds).length !== 0) {
-        yield this.setCurrentWalletIds(sessionInfo.currentWalletIds);
-      } else {
-        const currentWalletIds = {};
-        for (const walletId of Object.keys(sessionInfo.wallets)) {
-          currentWalletIds[sessionInfo.wallets[walletId].type] = [
-            ...(_a = currentWalletIds[sessionInfo.wallets[walletId].type]) != null ? _a : [],
-            walletId
-          ];
-        }
-        yield this.setCurrentWalletIds(currentWalletIds);
-      }
-      this.persistSessionCookie(sessionInfo.sessionCookie);
-      yield this.setPhoneNumber(sessionInfo.phone, sessionInfo.countryCode);
-    });
-  }
-  exitAccountCreation() {
-    this.isAwaitingAccountCreation = false;
-  }
-  exitLogin() {
-    this.isAwaitingLogin = false;
-  }
-  exitFarcaster() {
-    this.isAwaitingFarcaster = false;
-  }
-  exitOAuth() {
-    this.isAwaitingOAuth = false;
-  }
-  exitLoops() {
-    this.exitAccountCreation();
-    this.exitLogin();
-    this.exitFarcaster();
-    this.exitOAuth();
-  }
-  /**
-   * Retrieves a token to verify the current session.
-   * @returns {Promise<string>} the ID
-   **/
-  getVerificationToken() {
-    return __async(this, null, function* () {
-      const { data } = yield this.touchSession();
-      return data.sessionLookupId;
-    });
-  }
-  /**
-   * Logs the user out.
-   * @param {Object} opts the options object.
-   * @param {boolean} opts.clearPregenWallets if `true`, will remove all pregen wallets from storage
-   **/
-  logout() {
-    return __async(this, arguments, function* ({ clearPregenWallets = false } = {}) {
-      yield this.ctx.client.logout();
-      yield this.clearStorage();
-      if (!clearPregenWallets) {
-        Object.entries(this.wallets).forEach(([id, wallet]) => {
-          if (!wallet.pregenIdentifier) {
-            delete this.wallets[id];
-          }
-        });
-        yield this.setWallets(this.wallets);
-      } else {
-        this.wallets = {};
-      }
-      this.currentWalletIds = {};
-      this.externalWallets = {};
-      this.loginEncryptionKeyPair = void 0;
-      this.email = void 0;
-      this.telegramUserId = void 0;
-      this.phone = void 0;
-      this.countryCode = void 0;
-      this.userId = void 0;
-      this.sessionCookie = void 0;
-      dispatchEvent(ParaEvent.LOGOUT_EVENT, null);
-    });
-  }
-  getSupportedCreateAuthMethods() {
-    return __async(this, null, function* () {
-      const res = yield this.touchSession();
-      const partnerId = res.data.partnerId;
-      const partnerRes = yield this.ctx.client.getPartner(partnerId);
-      let supportedAuthMethods = /* @__PURE__ */ new Set();
-      for (const authMethod of partnerRes.data.partner.supportedAuthMethods) {
-        supportedAuthMethods.add(import_user_management_client5.AuthMethod[authMethod]);
-      }
-      return supportedAuthMethods;
-    });
-  }
-  /**
-   * Converts to a string, removing sensitive data when logging this class.
-   *
-   * Doesn't work for all types of logging.
-   **/
-  toString() {
-    const redactedWallets = Object.keys(this.wallets).reduce(
-      (acc, walletId) => __spreadProps(__spreadValues({}, acc), {
-        [walletId]: __spreadProps(__spreadValues({}, this.wallets[walletId]), {
-          signer: this.wallets[walletId].signer ? "[REDACTED]" : void 0
-        })
-      }),
-      {}
-    );
-    const redactedExternalWallets = Object.keys(this.externalWallets).reduce(
-      (acc, walletId) => __spreadProps(__spreadValues({}, acc), {
-        [walletId]: __spreadProps(__spreadValues({}, this.externalWallets[walletId]), {
-          signer: this.externalWallets[walletId].signer ? "[REDACTED]" : void 0
-        })
-      }),
-      {}
-    );
-    const obj = {
-      supportedWalletTypes: this.supportedWalletTypes,
-      cosmosPrefix: this.cosmosPrefix,
-      email: this.email,
-      phone: this.phone,
-      countryCode: this.countryCode,
-      telegramUserId: this.telegramUserId,
-      farcasterUsername: this.farcasterUsername,
-      userId: this.userId,
-      pregenIds: this.pregenIds,
-      currentWalletIds: this.currentWalletIds,
-      wallets: redactedWallets,
-      externalWallets: redactedExternalWallets,
-      loginEncryptionKeyPair: this.loginEncryptionKeyPair ? "[REDACTED]" : void 0,
-      ctx: {
-        apiKey: this.ctx.apiKey,
-        disableWorkers: this.ctx.disableWorkers,
-        disableWebSockets: this.ctx.disableWebSockets,
-        env: this.ctx.env,
-        offloadMPCComputationURL: this.ctx.offloadMPCComputationURL,
-        useLocalFiles: this.ctx.useLocalFiles,
-        useDKLS: this.ctx.useDKLS,
-        cosmosPrefix: this.ctx.cosmosPrefix
-      }
-    };
-    return `Para ${JSON.stringify(obj, null, 2)}`;
-  }
-};
-_supportedWalletTypes = new WeakMap();
-_supportedWalletTypesOpt = new WeakMap();
-_ParaCore.version = PARA_CORE_VERSION;
-var ParaCore = _ParaCore;
-
-// src/index.ts
-var import_user_management_client6 = require("@getpara/user-management-client");
-var paraVersion = ParaCore.version;
-var src_default = ParaCore;
+var import_types = require("./types/index.js");
+__reExport(src_exports, require("./types/events.js"), module.exports);
+__reExport(src_exports, require("./types/config.js"), module.exports);
+var import_utils = require("./utils/index.js");
+var import_constants = require("./constants.js");
+var import_shareDistribution = require("./shares/shareDistribution.js");
+var import_KeyContainer = require("./shares/KeyContainer.js");
+var import_userManagementClient = require("./external/userManagementClient.js");
+var mpcComputationClient = __toESM(require("./external/mpcComputationClient.js"));
+var import_utils2 = require("./cryptography/utils.js");
+__reExport(src_exports, require("./external/userManagementClient.js"), module.exports);
+__reExport(src_exports, require("./errors.js"), module.exports);
+__reExport(src_exports, require("./utils/formatting.js"), module.exports);
+__reExport(src_exports, require("./utils/polling.js"), module.exports);
+var import_wallet = require("./utils/wallet.js");
+var import_onRamps = require("./utils/onRamps.js");
+var import_url = require("./utils/url.js");
+var import_transmissionUtils = require("./transmission/transmissionUtils.js");
+const paraVersion = import_ParaCore.ParaCore.version;
+var src_default = import_ParaCore.ParaCore;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthMethod,
   EmailTheme,
-  EnabledFlow,
-  Environment,
   KeyContainer,
   NON_ED25519,
   Network,
@@ -4039,17 +115,12 @@ var src_default = ParaCore;
   OnRampPurchaseStatus,
   OnRampPurchaseType,
   PREGEN_IDENTIFIER_TYPES,
-  ParaEvent,
   PopupType,
   PregenIdentifierType,
   RecoveryStatus,
   STORAGE_PREFIX,
-  TransactionReviewDenied,
-  TransactionReviewError,
-  TransactionReviewTimeout,
   WalletScheme,
   WalletType,
-  decimalToHex,
   decryptPrivateKey,
   decryptPrivateKeyAndDecryptShare,
   decryptPrivateKeyWithPassword,
@@ -4062,10 +133,7 @@ var src_default = ParaCore;
   encryptWithDerivedPublicKey,
   entityToWallet,
   getAsymmetricKeyPair,
-  getBaseMPCNetworkUrl,
-  getBaseOAuthUrl,
   getBaseUrl,
-  getCosmosAddress,
   getDerivedPrivateKeyAndDecrypt,
   getOnRampAssets,
   getOnRampNetworks,
@@ -4075,19 +143,18 @@ var src_default = ParaCore;
   getPublicKeyHex,
   getSHA256HashHex,
   hashPasswordWithSalt,
-  hexStringToBase64,
-  hexToDecimal,
-  hexToSignature,
-  hexToUint8Array,
   initClient,
   isWalletSupported,
   mpcComputationClient,
-  normalizePhoneNumber,
   paraVersion,
   publicKeyFromHex,
   stringToPhoneNumber,
   toAssetInfoArray,
   transmissionUtilsRetrieve,
-  truncateAddress,
-  waitUntilTrue
+  ...require("./types/events.js"),
+  ...require("./types/config.js"),
+  ...require("./external/userManagementClient.js"),
+  ...require("./errors.js"),
+  ...require("./utils/formatting.js"),
+  ...require("./utils/polling.js")
 });