@getpara/core-sdk 1.5.0 → 1.5.1

package/dist/esm/index.js

@@ -1,8 +1,65 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+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/ParaCore.ts
 import { Buffer as NodeBuffer } from "buffer";
@@ -26,7 +83,7 @@ import forge from "node-forge";
 // src/utils/events.ts
 function dispatchEvent(type, data, error) {
   typeof window !== "undefined" && !!window.dispatchEvent && window.dispatchEvent(
-    new CustomEvent(type, { detail: { data, ...error && { error: new Error(error) } } })
+    new CustomEvent(type, { detail: __spreadValues({ data }, error && { error: new Error(error) }) })
   );
 }
 
@@ -93,7 +150,8 @@ function truncateAddress(str, addressType, { prefix = addressType === "COSMOS" ?
   return `${str.slice(0, headLength)}...${str.slice(-4)}`;
 }
 function stringToPhoneNumber(str) {
-  return parsePhoneNumberFromString(str)?.formatInternational().replace(/[^\d+]/g, "");
+  var _a;
+  return (_a = parsePhoneNumberFromString(str)) == null ? void 0 : _a.formatInternational().replace(/[^\d+]/g, "");
 }
 function normalizePhoneNumber(countryCode, number) {
   return stringToPhoneNumber(`${countryCode[0] !== "+" ? "+" : ""}${countryCode}${number}`);
@@ -136,26 +194,28 @@ function getOnRampAssets(data, {
 }
 
 // src/utils/polling.ts
-async function waitUntilTrue(condition, timeoutMs, intervalMs) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (await condition()) {
-      return true;
+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));
     }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
-  }
-  return false;
+    return false;
+  });
 }
 
 // src/types/config.ts
-var Environment = /* @__PURE__ */ ((Environment3) => {
-  Environment3["DEV"] = "DEV";
-  Environment3["SANDBOX"] = "SANDBOX";
-  Environment3["BETA"] = "BETA";
-  Environment3["PROD"] = "PROD";
-  Environment3["DEVELOPMENT"] = "BETA";
-  Environment3["PRODUCTION"] = "PROD";
-  return Environment3;
+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";
@@ -318,7 +378,10 @@ function isPregenIdentifierMatch(a, b, type) {
   }
 }
 function isWalletSupported(types, wallet) {
-  return types.some((walletType) => !!WalletSchemeTypeMap[wallet?.scheme]?.[walletType]);
+  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) => {
@@ -341,12 +404,11 @@ function getEquivalentTypes(types) {
   return getWalletTypes(getSchemes((Array.isArray(types) ? types : [types]).map((t) => WalletType[t])));
 }
 function entityToWallet(w) {
-  return {
-    ...w,
+  return __spreadProps(__spreadValues({}, w), {
     scheme: w.scheme,
     type: w.type,
     pregenIdentifierType: w.pregenIdentifierType
-  };
+  });
 }
 function migrateWallet(obj) {
   if (["USER", "PREGEN"].includes(obj.type)) {
@@ -388,79 +450,87 @@ function decodePrivateKeyPemHex(privateKeyPemHex) {
   const pem = Buffer.from(privateKeyPemHex, "hex").toString("utf-8");
   return forge.pki.privateKeyFromPem(pem);
 }
-async function encryptPrivateKey(keyPair, key) {
-  const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
-  const cryptoKey = await 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 = await window.crypto.subtle.encrypt(
-    { name: "AES-GCM", iv: CONSTANT_IV_AES },
-    cryptoKey,
-    encodedPlaintext
-  );
-  return Buffer.from(ciphertext).toString("base64");
+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");
+  });
 }
-async function decryptPrivateKey(encryptedPrivateKeyPemHex, key) {
-  const secretKey = await crypto.subtle.importKey(
-    "raw",
-    Buffer.from(key, "base64"),
-    {
-      name: "AES-GCM",
-      length: 256
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-  const cleartext = await 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 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;
+  });
 }
-async function getAsymmetricKeyPair(ctx, seedValue) {
-  const prng = forge.random.createInstance();
-  if (seedValue) {
-    prng.seedFileSync = (_n) => seedValue;
-    prng.seedFile = (_n, cb) => {
-      cb(null, seedValue);
+function getAsymmetricKeyPair(ctx, seedValue) {
+  return __async(this, null, function* () {
+    const prng = forge.random.createInstance();
+    if (seedValue) {
+      prng.seedFileSync = (_n) => seedValue;
+      prng.seedFile = (_n, cb) => {
+        cb(null, seedValue);
+      };
+    }
+    const options = {
+      bits: 2048,
+      e: 65537,
+      prng
     };
-  }
-  const options = {
-    bits: 2048,
-    e: 65537,
-    prng
-  };
-  if (!ctx.disableWorkers) {
-    options.workLoad = 100;
-    options.workers = seedValue ? 1 : -1;
-    const workerRes = await fetch(`${getPortalBaseURL(ctx)}/static/js/prime.worker.min.js`);
-    const workerBlob = new Blob([await 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);
-    })
-  );
+    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);
+      })
+    );
+  });
 }
-async function getPublicKeyFromSignature(ctx, userHandle) {
-  const encodedUserHandle = base64url.encode(userHandle);
-  const keyPair = await getAsymmetricKeyPair(ctx, encodedUserHandle);
-  return getPublicKeyHex(keyPair);
+function getPublicKeyFromSignature(ctx, userHandle) {
+  return __async(this, null, function* () {
+    const encodedUserHandle = base64url.encode(userHandle);
+    const keyPair = yield getAsymmetricKeyPair(ctx, encodedUserHandle);
+    return getPublicKeyHex(keyPair);
+  });
 }
 function symmetricKeyEncryptMessage(message) {
   const key = forge.random.getBytesSync(16);
@@ -488,49 +558,57 @@ function decryptWithPrivateKey(privateKey, encryptedMessageHex, encryptedKeyHex)
   const key = privateKey.decrypt(encryptedKey, RSA_ENCRYPTION_SCHEME);
   return decipherEncryptedMessageHex(key, encryptedMessageHex);
 }
-async function decryptWithDerivedPrivateKey(ctx, {
-  seedValue,
-  encryptedMessageHex,
-  encryptedKeyHex
-}) {
-  const keyPair = await getAsymmetricKeyPair(ctx, seedValue);
-  return decryptWithPrivateKey(keyPair.privateKey, encryptedMessageHex, encryptedKeyHex);
+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
+        };
+      }))
+    );
+  });
 }
-async function getDerivedPrivateKeyAndDecrypt(ctx, seedValue, encryptedShares) {
-  return Promise.all(
-    encryptedShares.map(async (share) => ({
+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: await decryptWithDerivedPrivateKey(ctx, {
-        seedValue,
-        encryptedMessageHex: share.encryptedShare,
-        encryptedKeyHex: share.encryptedKey
-      }),
+      signer: decryptWithPrivateKey(privateKey, share.encryptedShare, share.encryptedKey),
       protocolId: share.protocolId
-    }))
-  );
-}
-async function decryptPrivateKeyAndDecryptShare(encryptionKey, encryptedShares, encryptedPrivateKey) {
-  let privateKey;
-  try {
-    privateKey = await decryptPrivateKey(encryptedPrivateKey, encryptionKey);
-  } catch (e) {
-  }
-  try {
-    privateKey = await 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);
@@ -549,49 +627,55 @@ function hashPasswordWithSalt(password) {
 function generateSalt(length = 16) {
   return forge.util.bytesToHex(forge.random.getBytesSync(length));
 }
-async function deriveCryptoKeyFromPassword(hashedPassword) {
-  const keyBuffer = Buffer.from(hashedPassword, "hex");
-  return await window.crypto.subtle.importKey(
-    "raw",
-    keyBuffer,
-    {
-      name: "AES-GCM",
-      length: 256
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
+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"]
+    );
+  });
 }
-async function encryptPrivateKeyWithPassword(keyPair, hashedPassword) {
-  const cryptoKey = await deriveCryptoKeyFromPassword(hashedPassword);
-  const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
-  const encodedPlaintext = new TextEncoder().encode(privateKeyPemHex);
-  const ciphertext = await window.crypto.subtle.encrypt(
-    { name: "AES-GCM", iv: CONSTANT_IV_AES },
-    cryptoKey,
-    encodedPlaintext
-  );
-  return Buffer.from(ciphertext).toString("base64");
+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");
+  });
 }
-async function decryptPrivateKeyWithPassword(encryptedPrivateKeyPemHex, hashedPassword) {
-  const secretKey = await crypto.subtle.importKey(
-    "raw",
-    Buffer.from(hashedPassword, "hex"),
-    {
-      name: "AES-GCM",
-      length: 256
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-  const cleartext = await 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 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
@@ -753,125 +837,126 @@ var KeyContainer = class _KeyContainer {
 };
 
 // src/shares/recovery.ts
-async function sendRecoveryForShare({
-  ctx,
-  userId,
-  walletId,
-  otherEncryptedShares = [],
-  userSigner,
-  ignoreRedistributingBackupEncryptedShare = false,
-  emailProps = {},
-  forceRefresh = false
-}) {
-  if (ignoreRedistributingBackupEncryptedShare) {
-    await ctx.client.uploadUserKeyShares(
-      userId,
-      otherEncryptedShares.map((share) => ({
-        walletId,
-        ...share
-      }))
-    );
-    return "";
-  }
-  let userBackupKeyShareOptsArr;
-  let recoveryPrivateKeyContainer;
-  const { recoveryPublicKeys } = await ctx.client.getRecoveryPublicKeys(userId);
-  if (forceRefresh || !recoveryPublicKeys?.length) {
-    recoveryPrivateKeyContainer = new KeyContainer(walletId, "", "");
-    const { recoveryPublicKeys: recoveryPublicKeys2 } = await ctx.client.persistRecoveryPublicKeys(userId, [
-      recoveryPrivateKeyContainer.getPublicEncryptionKeyHex()
-    ]);
-    const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
-    userBackupKeyShareOptsArr = [
-      {
-        walletId,
-        encryptedShare: encryptedUserBackup,
-        type: KeyShareType.USER,
-        encryptor: EncryptorType.RECOVERY,
-        recoveryPublicKeyId: recoveryPublicKeys2[0].id
-      }
-    ];
-  } else {
-    userBackupKeyShareOptsArr = recoveryPublicKeys.map((recoveryPublicKey) => {
-      const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
-      const encryptedUserBackup = KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, "hex"), userSigner);
-      return {
-        walletId,
-        encryptedShare: encryptedUserBackup,
-        type: KeyShareType.USER,
-        encryptor: EncryptorType.RECOVERY,
-        recoveryPublicKeyId
-      };
-    });
-  }
-  await ctx.client.uploadUserKeyShares(userId, [
-    ...otherEncryptedShares.map((share) => ({
-      walletId,
-      ...share
-    })),
-    ...ignoreRedistributingBackupEncryptedShare ? [] : userBackupKeyShareOptsArr
-  ]);
-  await ctx.client.distributeParaShare({
+function sendRecoveryForShare(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
     userId,
     walletId,
-    useDKLS: ctx.useDKLS,
-    ...emailProps
+    otherEncryptedShares = [],
+    userSigner,
+    ignoreRedistributingBackupEncryptedShare = false,
+    emailProps = {},
+    forceRefresh = false
+  }) {
+    if (ignoreRedistributingBackupEncryptedShare) {
+      yield ctx.client.uploadUserKeyShares(
+        userId,
+        otherEncryptedShares.map((share) => __spreadValues({
+          walletId
+        }, share))
+      );
+      return "";
+    }
+    let userBackupKeyShareOptsArr;
+    let recoveryPrivateKeyContainer;
+    const { recoveryPublicKeys } = yield ctx.client.getRecoveryPublicKeys(userId);
+    if (forceRefresh || !(recoveryPublicKeys == null ? void 0 : recoveryPublicKeys.length)) {
+      recoveryPrivateKeyContainer = new KeyContainer(walletId, "", "");
+      const { recoveryPublicKeys: recoveryPublicKeys2 } = yield ctx.client.persistRecoveryPublicKeys(userId, [
+        recoveryPrivateKeyContainer.getPublicEncryptionKeyHex()
+      ]);
+      const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
+      userBackupKeyShareOptsArr = [
+        {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId: recoveryPublicKeys2[0].id
+        }
+      ];
+    } else {
+      userBackupKeyShareOptsArr = recoveryPublicKeys.map((recoveryPublicKey) => {
+        const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
+        const encryptedUserBackup = KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, "hex"), userSigner);
+        return {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId
+        };
+      });
+    }
+    yield ctx.client.uploadUserKeyShares(userId, [
+      ...otherEncryptedShares.map((share) => __spreadValues({
+        walletId
+      }, share)),
+      ...ignoreRedistributingBackupEncryptedShare ? [] : userBackupKeyShareOptsArr
+    ]);
+    yield ctx.client.distributeParaShare(__spreadValues({
+      userId,
+      walletId,
+      useDKLS: ctx.useDKLS
+    }, emailProps));
+    return recoveryPrivateKeyContainer ? JSON.stringify(recoveryPrivateKeyContainer) : "";
   });
-  return recoveryPrivateKeyContainer ? JSON.stringify(recoveryPrivateKeyContainer) : "";
 }
 
 // src/shares/shareDistribution.ts
-async function distributeNewShare({
-  ctx,
-  userId,
-  walletId,
-  userShare,
-  ignoreRedistributingBackupEncryptedShare = false,
-  emailProps = {},
-  partnerId,
-  protocolId
-}) {
-  const publicKeysRes = await 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: KeyShareType2.USER,
-      encryptor: EncryptorType2.BIOMETRICS,
-      biometricPublicKey: key.sigDerivedPublicKey,
-      partnerId,
-      protocolId
-    };
-  }).filter(Boolean);
-  const passwords = await 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: KeyShareType2.USER,
-      encryptor: EncryptorType2.PASSWORD,
-      passwordId: password.id,
-      partnerId,
-      protocolId
-    };
-  }).filter(Boolean);
-  const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
-  return await sendRecoveryForShare({
+function distributeNewShare(_0) {
+  return __async(this, arguments, function* ({
     ctx,
     userId,
     walletId,
-    otherEncryptedShares: allEncryptedShares,
-    userSigner: userShare,
-    ignoreRedistributingBackupEncryptedShare,
-    emailProps
+    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: KeyShareType2.USER,
+        encryptor: EncryptorType2.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: KeyShareType2.USER,
+        encryptor: EncryptorType2.PASSWORD,
+        passwordId: password.id,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
+    return yield sendRecoveryForShare({
+      ctx,
+      userId,
+      walletId,
+      otherEncryptedShares: allEncryptedShares,
+      userSigner: userShare,
+      ignoreRedistributingBackupEncryptedShare,
+      emailProps
+    });
   });
 }
 
@@ -880,32 +965,36 @@ import { Encrypt as ECIESEncrypt2, Decrypt as ECIESDecrypt2 } from "@celo/utils/
 import { Buffer as Buffer2 } from "buffer";
 import * as eutil2 from "ethereumjs-util";
 import { randomBytes } from "crypto";
-async function upload(message, userManagementClient) {
-  let secret;
-  let publicKeyUint8Array;
-  while (true) {
-    try {
-      secret = randomBytes(32).toString("hex");
-      publicKeyUint8Array = eutil2.privateToPublic(Buffer2.from(secret, "hex"));
-      break;
-    } catch (e) {
-      continue;
+function upload(message, userManagementClient) {
+  return __async(this, null, function* () {
+    let secret;
+    let publicKeyUint8Array;
+    while (true) {
+      try {
+        secret = randomBytes(32).toString("hex");
+        publicKeyUint8Array = eutil2.privateToPublic(Buffer2.from(secret, "hex"));
+        break;
+      } catch (e) {
+        continue;
+      }
     }
-  }
-  const pubkey = Buffer2.from(publicKeyUint8Array);
-  const data = ECIESEncrypt2(pubkey, Buffer2.from(message, "ucs2")).toString("base64");
-  const {
-    data: { id }
-  } = await userManagementClient.tempTrasmissionInit(data);
-  return encodeURIComponent(id + "|" + secret);
+    const pubkey = Buffer2.from(publicKeyUint8Array);
+    const data = ECIESEncrypt2(pubkey, Buffer2.from(message, "ucs2")).toString("base64");
+    const {
+      data: { id }
+    } = yield userManagementClient.tempTrasmissionInit(data);
+    return encodeURIComponent(id + "|" + secret);
+  });
 }
-async function retrieve(uriEncodedMessage, userManagementClient) {
-  const [id, secret] = decodeURIComponent(uriEncodedMessage).split("|");
-  const response = await userManagementClient.tempTrasmission(id);
-  const data = response.data.message;
-  const buf = Buffer2.from(data, "base64");
-  const res = Buffer2.from(ECIESDecrypt2(Buffer2.from(secret, "hex"), buf).buffer).toString("ucs2");
-  return res;
+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 = Buffer2.from(data, "base64");
+    const res = Buffer2.from(ECIESDecrypt2(Buffer2.from(secret, "hex"), buf).buffer).toString("ucs2");
+    return res;
+  });
 }
 
 // src/errors.ts
@@ -932,7 +1021,7 @@ var TransactionReviewTimeout = class extends Error {
 };
 
 // src/constants.ts
-var PARA_CORE_VERSION = '1.5.0';
+var PARA_CORE_VERSION = '1.5.1';
 var PREFIX = "@CAPSULE/";
 var LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
 var LOCAL_STORAGE_PHONE = `${PREFIX}phone`;
@@ -1003,7 +1092,8 @@ if (typeof global !== "undefined") {
   self.global = self.global || self;
 }
 var { pki, jsbn } = forge3;
-var ParaCore = class _ParaCore {
+var _supportedWalletTypes, _supportedWalletTypesOpt;
+var _ParaCore = class _ParaCore {
   /**
    * Constructs a new `ParaCore` instance.
    * @param env - `Environment` to use.
@@ -1020,8 +1110,8 @@ var ParaCore = class _ParaCore {
      * 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 = {};
-    this.#supportedWalletTypes = void 0;
-    this.#supportedWalletTypesOpt = void 0;
+    __privateAdd(this, _supportedWalletTypes);
+    __privateAdd(this, _supportedWalletTypesOpt);
     this.localStorageGetItem = (key) => {
       return this.platformUtils.localStorage.get(key);
     };
@@ -1044,14 +1134,14 @@ var ParaCore = class _ParaCore {
      * Remove all local storage and prefixed session storage.
      * @param {'local' | 'session' | 'secure' | 'all'} type - Type of storage to clear. Defaults to 'all'.
      */
-    this.clearStorage = async (type = "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();
@@ -1079,18 +1169,16 @@ var ParaCore = class _ParaCore {
     this.updateEmailFromStorage = () => {
       this.email = this.localStorageGetItem(LOCAL_STORAGE_EMAIL) || void 0;
     };
-    this.updateWalletsFromStorage = async () => {
-      const _currentWalletIds = this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS) ?? 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(WalletType2).reduce((acc, type) => {
           const wallet = Object.values(this.wallets).find(
             (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
           );
-          return {
-            ...acc,
-            ...wallet && !acc[type] ? { [type]: [wallet.id] } : {}
-          };
+          return __spreadValues(__spreadValues({}, acc), wallet && !acc[type] ? { [type]: [wallet.id] } : {});
         }, {}) : fromJson;
       })();
       this.setCurrentWalletIds(currentWalletIds);
@@ -1098,34 +1186,25 @@ var ParaCore = class _ParaCore {
       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 = {
-        ...Object.keys(_wallets).reduce((res, key) => {
-          return {
-            ...res,
-            [key]: migrateWallet(_wallets[key])
-          };
-        }, {}),
-        ...Object.keys(_ed25519Wallets).reduce((res, key) => {
-          return {
-            ...res,
-            ...!res[key] ? { [key]: migrateWallet(_ed25519Wallets[key]) } : {}
-          };
-        }, {})
-      };
+      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 = () => {
-      const _currentWalletIds = this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS) ?? void 0;
+      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(WalletType2).reduce((acc, type) => {
           const wallet = Object.values(this.wallets).find(
             (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
           );
-          return {
-            ...acc,
-            ...wallet && !acc[type] ? { [type]: [wallet.id] } : {}
-          };
+          return __spreadValues(__spreadValues({}, acc), wallet && !acc[type] ? { [type]: [wallet.id] } : {});
         }, {}) : fromJson;
       })();
       this.setCurrentWalletIds(currentWalletIds);
@@ -1157,6 +1236,11 @@ var ParaCore = class _ParaCore {
      **/
     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;
@@ -1208,13 +1292,14 @@ var ParaCore = class _ParaCore {
       useDKLS: opts.useDKLSForCreation || !opts.offloadMPCComputationURL,
       disableWebSockets: !!opts.disableWebSockets,
       wasmOverride: opts.wasmOverride,
-      cosmosPrefix: this.cosmosPrefix
+      cosmosPrefix: this.cosmosPrefix,
+      isE2E
     };
     if (opts.offloadMPCComputationURL) {
       this.ctx.mpcComputationClient = initClient2(opts.offloadMPCComputationURL, opts.disableWorkers);
     }
     try {
-      this.#supportedWalletTypes = opts.supportedWalletTypes ? (() => {
+      __privateSet(this, _supportedWalletTypes, opts.supportedWalletTypes ? (() => {
         if (Object.values(opts.supportedWalletTypes).every(
           (config) => !!config && typeof config === "object" && config.optional
         )) {
@@ -1223,19 +1308,20 @@ var ParaCore = class _ParaCore {
         if (!Object.keys(opts.supportedWalletTypes).every((type) => Object.values(WalletType2).includes(type))) {
           throw new Error("unsupported wallet type");
         }
-        this.#supportedWalletTypesOpt = opts.supportedWalletTypes;
+        __privateSet(this, _supportedWalletTypesOpt, opts.supportedWalletTypes);
         return Object.entries(opts.supportedWalletTypes).reduce((acc, [key, value]) => {
+          var _a;
           if (!value) {
             return acc;
           }
           if (key === WalletType2.COSMOS && typeof value === "object" && !!value.prefix) {
             this.cosmosPrefix = value.prefix;
           }
-          return [...acc, { type: key, optional: value === true ? false : value.optional ?? false }];
+          return [...acc, { type: key, optional: value === true ? false : (_a = value.optional) != null ? _a : false }];
         }, []);
-      })() : void 0;
+      })() : void 0);
     } catch (e) {
-      this.#supportedWalletTypes = void 0;
+      __privateSet(this, _supportedWalletTypes, void 0);
     }
     if (!this.platformUtils.isSyncStorage || opts.useStorageOverrides) {
       return;
@@ -1243,9 +1329,6 @@ var ParaCore = class _ParaCore {
     this.initializeFromStorage();
     setupListeners.bind(this)();
   }
-  static {
-    this.version = PARA_CORE_VERSION;
-  }
   get isEmail() {
     return !!this.email && !this.phone && !this.countryCode && !this.farcasterUsername && !this.telegramUserId;
   }
@@ -1260,9 +1343,10 @@ var ParaCore = class _ParaCore {
   }
   get currentWalletIdsArray() {
     return this.supportedWalletTypes.reduce((acc, { type }) => {
+      var _a;
       return [
         ...acc,
-        ...(this.currentWalletIds[type] ?? []).map((id) => {
+        ...((_a = this.currentWalletIds[type]) != null ? _a : []).map((id) => {
           return [id, type];
         })
       ];
@@ -1275,19 +1359,17 @@ var ParaCore = class _ParaCore {
    * A map of pre-generated wallet identifiers that can be claimed in the current instance.
    */
   get pregenIds() {
-    return {
-      ...Object.values(this.wallets).filter((wallet) => !this.userId || this.isPregenWalletClaimable(wallet)).reduce((acc, wallet) => {
-        if ((acc[wallet.pregenIdentifierType] ?? []).includes(wallet.pregenIdentifier)) {
-          return acc;
-        }
-        return {
-          ...acc,
-          [wallet.pregenIdentifierType]: [
-            .../* @__PURE__ */ new Set([...acc[wallet.pregenIdentifierType] ?? [], wallet.pregenIdentifier])
-          ]
-        };
-      }, {})
-    };
+    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.
@@ -1295,14 +1377,13 @@ var ParaCore = class _ParaCore {
   get isMultiWallet() {
     return this.currentWalletIdsArray.length > 1;
   }
-  #supportedWalletTypes;
-  #supportedWalletTypesOpt;
   get supportedWalletTypes() {
-    return this.#supportedWalletTypes ?? [];
+    var _a;
+    return (_a = __privateGet(this, _supportedWalletTypes)) != null ? _a : [];
   }
   get isWalletTypeEnabled() {
     return this.supportedWalletTypes.reduce((acc, { type }) => {
-      return { ...acc, [type]: true };
+      return __spreadProps(__spreadValues({}, acc), { [type]: true });
     }, {});
   }
   convertBigInt(bigInt) {
@@ -1331,12 +1412,14 @@ var ParaCore = class _ParaCore {
     };
   }
   isPortal(envOverride) {
+    var _a;
     if (typeof window === "undefined") return false;
-    return !!window.location?.host && getPortalBaseURL(envOverride ? { env: envOverride } : this.ctx).includes(window.location.host);
+    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 !!window.location?.host && getParaConnectBaseUrl(this.ctx).includes(window.location.host);
+    return !!((_a = window.location) == null ? void 0 : _a.host) && getParaConnectBaseUrl(this.ctx).includes(window.location.host);
   }
   requireApiKey() {
     if (!this.ctx.apiKey) {
@@ -1347,19 +1430,20 @@ var ParaCore = class _ParaCore {
     }
   }
   isWalletSupported(wallet) {
-    return !this.#supportedWalletTypes || isWalletSupported(this.supportedWalletTypes?.map(({ type }) => type) ?? [], 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?.pregenIdentifier && !wallet?.pregenIdentifierType && !!this.userId && wallet?.userId === this.userId;
+    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?.userId || wallet?.isPregen && !!wallet?.pregenIdentifier && !!wallet?.pregenIdentifierType);
+    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?.pregenIdentifierType) || isPregenIdentifierMatch(
-      wallet?.pregenIdentifierType === "EMAIL" ? this.email : wallet?.pregenIdentifierType === "TELEGRAM" ? this.telegramUserId : this.getPhoneNumber(),
-      wallet?.pregenIdentifier,
-      wallet?.pregenIdentifierType
+    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) {
@@ -1370,15 +1454,18 @@ var ParaCore = class _ParaCore {
       const wallet = this.wallets[walletId];
       const [isUnclaimed, isOwned] = [this.isPregenWalletUnclaimed(wallet), this.isWalletOwned(wallet)];
       if (forbidPregen && isUnclaimed) {
-        error = `pre-generated wallet with id ${wallet?.id} cannot be selected`;
+        error = `pre-generated wallet with id ${wallet == null ? void 0 : wallet.id} cannot be selected`;
       } else if (!isOwned && !isUnclaimed) {
-        error = `wallet with id ${wallet?.id} is not owned by the current user`;
+        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?.id} and type ${wallet?.type} is not supported, supported types are: ${this.supportedWalletTypes.map(({ type }) => type).join(", ")}`;
-      } else if (types && (!getEquivalentTypes(types).includes(wallet?.type) || isOwned && !types.some((type) => this.currentWalletIds?.[type]?.includes(walletId)))) {
-        error = `wallet with id ${wallet?.id} and type ${wallet?.type} cannot be selected`;
-      } else if (schemes && !schemes.includes(wallet?.scheme)) {
-        error = `wallet with id ${wallet?.id} and scheme ${wallet?.scheme} cannot be selected`;
+        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 _a, _b;
+        return (_b = (_a = this.currentWalletIds) == null ? void 0 : _a[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) {
@@ -1398,6 +1485,7 @@ var ParaCore = class _ParaCore {
    * @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;
@@ -1409,7 +1497,7 @@ var ParaCore = class _ParaCore {
     let str;
     switch (wallet.type) {
       case WalletType2.COSMOS:
-        str = getCosmosAddress(wallet.publicKey, this.cosmosPrefix ?? "cosmos");
+        str = getCosmosAddress(wallet.publicKey, (_a = this.cosmosPrefix) != null ? _a : "cosmos");
         break;
       default:
         str = wallet.address;
@@ -1435,89 +1523,87 @@ var ParaCore = class _ParaCore {
     return this.wallets;
   }
   getAddress(walletId) {
-    return walletId ? this.wallets[walletId]?.address : Object.values(this.wallets)?.[0]?.address;
-  }
-  async constructPortalUrl(type, opts = {}) {
-    const base = type === "onRamp" ? getPortalBaseURL(this.ctx) : await 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}`);
+    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;
+      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 ? (await this.ctx.client.getPartner(opts.partnerId)).data?.partner : void 0;
-    const params = {
-      apiKey: this.ctx.apiKey,
-      partnerId: opts.partnerId,
-      portalFont: opts.theme?.font || partner?.font || this.portalTheme?.font,
-      portalBorderRadius: opts.theme?.borderRadius || this.portalTheme?.borderRadius,
-      portalThemeMode: opts.theme?.mode || partner?.themeMode || this.portalTheme?.mode,
-      portalAccentColor: opts.theme?.accentColor || partner?.accentColor || this.portalTheme?.accentColor,
-      portalForegroundColor: opts.theme?.foregroundColor || partner?.foregroundColor || this.portalTheme?.foregroundColor,
-      portalBackgroundColor: opts.theme?.backgroundColor || partner?.backgroundColor || this.portalBackgroundColor || this.portalTheme?.backgroundColor,
-      portalPrimaryButtonColor: this.portalPrimaryButtonColor,
-      portalTextColor: this.portalTextColor,
-      portalPrimaryButtonTextColor: this.portalPrimaryButtonTextColor,
-      isForNewDevice: opts.isForNewDevice ? opts.isForNewDevice.toString() : void 0,
-      supportedWalletTypes: this.#supportedWalletTypesOpt ? JSON.stringify(this.#supportedWalletTypesOpt) : void 0,
-      ...isCreate || isLogin ? {
-        ...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 } : {}
-      } : {},
-      ...isLogin || isOnRamp ? { sessionId: opts.sessionId } : {},
-      ...isLogin ? {
+      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({}, 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 } : {}) : {}), 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 });
+      } : {}), opts.params || {});
+      return constructUrl({ base, path, params });
+    });
   }
-  async touchSession(regenerate = false) {
-    const res = await this.ctx.client.touchSession(regenerate);
-    this.setSupportedWalletTypes(res.data.supportedWalletTypes, res.data.cosmosPrefix);
-    return res;
+  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 && !this.#supportedWalletTypes) {
-      this.#supportedWalletTypes = supportedWalletTypes;
+    if (supportedWalletTypes && !__privateGet(this, _supportedWalletTypes)) {
+      __privateSet(this, _supportedWalletTypes, supportedWalletTypes);
       Object.keys(this.currentWalletIds).forEach((type) => {
-        if (!this.#supportedWalletTypes?.some(({ type: supportedType }) => supportedType === type)) {
+        var _a;
+        if (!((_a = __privateGet(this, _supportedWalletTypes)) == null ? void 0 : _a.some(({ type: supportedType }) => supportedType === type))) {
           delete this.currentWalletIds[type];
         }
       });
@@ -1553,155 +1639,168 @@ var ParaCore = class _ParaCore {
    *
    * Init only needs to be called for storage that is async.
    */
-  async init() {
-    this.email = await this.localStorageGetItem(LOCAL_STORAGE_EMAIL) || void 0;
-    this.countryCode = await this.localStorageGetItem(LOCAL_STORAGE_COUNTRY_CODE) || void 0;
-    this.phone = await this.localStorageGetItem(LOCAL_STORAGE_PHONE) || void 0;
-    this.userId = await this.localStorageGetItem(LOCAL_STORAGE_USER_ID) || void 0;
-    this.telegramUserId = await this.localStorageGetItem(LOCAL_STORAGE_TELEGRAM_USER_ID) || void 0;
-    const stringWallets = this.platformUtils.secureStorage ? await this.platformUtils.secureStorage.get(LOCAL_STORAGE_WALLETS) : await this.localStorageGetItem(LOCAL_STORAGE_WALLETS);
-    const _wallets = JSON.parse(stringWallets || "{}");
-    const stringEd25519Wallets = this.platformUtils.secureStorage ? await this.platformUtils.secureStorage.get(LOCAL_STORAGE_ED25519_WALLETS) : await this.localStorageGetItem(LOCAL_STORAGE_ED25519_WALLETS);
-    const _ed25519Wallets = JSON.parse(stringEd25519Wallets || "{}");
-    const wallets = {
-      ...Object.keys(_wallets).reduce((res, key) => {
-        return {
-          ...res,
+  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 {
-          ...res,
-          ...!res[key] ? { [key]: migrateWallet(_ed25519Wallets[key]) } : {}
-        };
-      }, {})
-    };
-    await this.setWallets(wallets);
-    const _currentWalletIds = await this.localStorageGetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS) ?? void 0;
-    const currentWalletIds = [void 0, null, "undefined", "null"].includes(_currentWalletIds) ? {} : (() => {
-      const fromJson = JSON.parse(_currentWalletIds);
-      return Array.isArray(fromJson) ? Object.keys(WalletType2).reduce((acc, type) => {
-        const wallet = Object.values(this.wallets).find(
-          (w) => fromJson.includes(w.id) && WalletSchemeTypeMap[w.scheme][type]
-        );
-        return {
-          ...acc,
-          ...wallet && !acc[type] ? { [type]: [wallet.id] } : {}
-        };
-      }, {}) : fromJson;
-    })();
-    await this.setCurrentWalletIds(currentWalletIds);
-    this.sessionCookie = await this.localStorageGetItem(LOCAL_STORAGE_SESSION_COOKIE) || await 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 = await this.sessionStorageGetItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR);
-    if (loginEncryptionKey && loginEncryptionKey !== "undefined") {
-      this.loginEncryptionKeyPair = this.convertEncryptionKeyPair(JSON.parse(loginEncryptionKey));
-    }
-    const stringExternalWallets = await this.localStorageGetItem(LOCAL_STORAGE_EXTERNAL_WALLETS);
-    const _externalWallets = JSON.parse(stringExternalWallets || "{}");
-    await this.setExternalWallets(_externalWallets);
-    setupListeners.bind(this)();
-    await this.touchSession();
+        });
+      }, {})), 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(WalletType2).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.
    */
-  async setEmail(email) {
-    this.email = email;
-    await this.localStorageSetItem(LOCAL_STORAGE_EMAIL, email);
+  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.
    */
-  async setTelegramUserId(telegramUserId) {
-    this.telegramUserId = telegramUserId;
-    await this.localStorageSetItem(LOCAL_STORAGE_TELEGRAM_USER_ID, telegramUserId);
+  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.
    */
-  async setPhoneNumber(phone, countryCode) {
-    this.phone = phone;
-    this.countryCode = countryCode;
-    await this.localStorageSetItem(LOCAL_STORAGE_PHONE, phone);
-    await this.localStorageSetItem(LOCAL_STORAGE_COUNTRY_CODE, countryCode);
+  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.
    */
-  async setFarcasterUsername(farcasterUsername) {
-    this.farcasterUsername = farcasterUsername;
-    await this.localStorageSetItem(LOCAL_STORAGE_FARCASTER_USERNAME, farcasterUsername);
+  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.
    */
-  async setExternalWallet({ address, type, provider, addressBech32 }) {
-    this.externalWallets = {
-      [address]: {
-        id: address,
-        address: addressBech32 ?? address,
-        type,
-        name: provider,
-        isExternal: true,
-        signer: ""
-      }
-    };
-    this.setExternalWallets(this.externalWallets);
-    dispatchEvent(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
+  setExternalWallet(_0) {
+    return __async(this, arguments, function* ({ address, type, provider, addressBech32 }) {
+      this.externalWallets = {
+        [address]: {
+          id: address,
+          address: addressBech32 != null ? addressBech32 : address,
+          type,
+          name: provider,
+          isExternal: true,
+          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.
    */
-  async setUserId(userId) {
-    this.userId = userId;
-    await this.localStorageSetItem(LOCAL_STORAGE_USER_ID, userId);
+  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.
    */
-  async setWallets(wallets) {
-    this.wallets = wallets;
-    if (this.platformUtils.secureStorage) {
-      await this.platformUtils.secureStorage.set(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
-      return;
-    }
-    await this.localStorageSetItem(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
+  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.
    */
-  async setExternalWallets(externalWallets) {
-    this.externalWallets = externalWallets;
-    await this.localStorageSetItem(LOCAL_STORAGE_EXTERNAL_WALLETS, JSON.stringify(externalWallets));
+  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.
    */
-  async setLoginEncryptionKeyPair(keyPair) {
-    if (!keyPair) {
-      keyPair = await getAsymmetricKeyPair(this.ctx);
-    }
-    this.loginEncryptionKeyPair = keyPair;
-    await this.sessionStorageSetItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR, JSON.stringify(keyPair));
+  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));
+    });
   }
-  async deleteLoginEncryptionKeyPair() {
-    this.loginEncryptionKeyPair = void 0;
-    await this.sessionStorageRemoveItem(SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR);
+  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.
@@ -1741,23 +1840,25 @@ var ParaCore = class _ParaCore {
   getFarcasterUsername() {
     return this.farcasterUsername;
   }
-  async setCurrentWalletIds(currentWalletIds, {
-    needsWallet = false,
-    sessionLookupId,
-    newDeviceSessionLookupId
-  } = {}) {
-    this.currentWalletIds = currentWalletIds;
-    await this.localStorageSetItem(LOCAL_STORAGE_CURRENT_WALLET_IDS, JSON.stringify(this.currentWalletIds));
-    if (sessionLookupId) {
-      await this.ctx.client.setCurrentWalletIds(
-        this.getUserId(),
-        this.currentWalletIds,
-        needsWallet,
-        sessionLookupId,
-        newDeviceSessionLookupId
-      );
-    }
-    dispatchEvent(ParaEvent.WALLETS_CHANGE_EVENT, null);
+  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);
+    });
   }
   /**
    * Validates that a wallet ID is present on the instance, usable, and matches the desired filters.
@@ -1811,6 +1912,7 @@ var ParaCore = class _ParaCore {
     return wallet;
   }
   findWallet(idOrAddress, overrideType, filter = {}) {
+    var _b, _c;
     if (!idOrAddress && Object.keys(this.externalWallets).length > 0) {
       return Object.values(this.externalWallets)[0];
     }
@@ -1820,18 +1922,18 @@ var ParaCore = class _ParaCore {
     try {
       const walletId = this.findWalletId(idOrAddress, filter);
       if (walletId && !!this.wallets[walletId]) {
-        const { signer: _signer, ...wallet } = this.wallets[walletId];
-        const type = overrideType ?? this.currentWalletIdsArray.find(([id]) => id === walletId)?.[1] ?? wallet.type;
-        return {
-          ...wallet,
+        const _a = this.wallets[walletId], { signer: _signer } = _a, wallet = __objRest(_a, ["signer"]);
+        const type = (_c = overrideType != null ? overrideType : (_b = this.currentWalletIdsArray.find(([id]) => id === walletId)) == null ? void 0 : _b[1]) != null ? _c : wallet.type;
+        return __spreadProps(__spreadValues({}, wallet), {
           type: WalletType2[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);
@@ -1843,7 +1945,7 @@ var ParaCore = class _ParaCore {
           name: wallet.name
         };
       }).filter((obj) => obj !== null),
-      ...Object.values(this.externalWallets ?? {})
+      ...Object.values((_a = this.externalWallets) != null ? _a : {})
     ];
   }
   /**
@@ -1857,61 +1959,78 @@ var ParaCore = class _ParaCore {
   assertIsValidWalletId(walletId, condition = {}) {
     this.isWalletUsable(walletId, condition, true);
   }
-  async assertIsValidWalletType(type, walletTypes) {
-    if (!this.#supportedWalletTypes) {
-      await this.touchSession();
-    }
-    if (!type || !Object.values(WalletType2).includes(type) || !(walletTypes ?? this.supportedWalletTypes.map(({ type: type2 }) => type2)).includes(type)) {
-      throw new Error(`wallet type ${type} is not supported`);
-    }
-    return type;
+  assertIsValidWalletType(type, walletTypes) {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _supportedWalletTypes)) {
+        yield this.touchSession();
+      }
+      if (!type || !Object.values(WalletType2).includes(type) || !(walletTypes != null ? walletTypes : this.supportedWalletTypes.map(({ type: type2 }) => type2)).includes(type)) {
+        throw new Error(`wallet type ${type} is not supported`);
+      }
+      return type;
+    });
   }
-  async getMissingTypes() {
-    if (!this.#supportedWalletTypes) {
-      await 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);
+  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);
+    });
   }
-  async getTypesToCreate(types) {
-    if (!this.#supportedWalletTypes) {
-      await this.touchSession();
-    }
-    return getSchemes(types ?? await this.getMissingTypes()).map((scheme) => {
-      switch (scheme) {
-        case WalletScheme2.ED25519:
-          return WalletType2.SOLANA;
-        default:
-          return this.supportedWalletTypes.some(({ type, optional }) => type === WalletType2.COSMOS && !optional) ? WalletType2.COSMOS : WalletType2.EVM;
+  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 WalletScheme2.ED25519:
+            return WalletType2.SOLANA;
+          default:
+            return this.supportedWalletTypes.some(({ type, optional }) => type === WalletType2.COSMOS && !optional) ? WalletType2.COSMOS : WalletType2.EVM;
+        }
+      });
     });
   }
-  async getPartnerURL(partnerId) {
-    const res = await this.ctx.client.getPartner(partnerId);
-    return res.data.partner.portalUrl;
+  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
    */
-  async getPortalURL(partnerId) {
-    return partnerId && await this.getPartnerURL(partnerId) || getPortalBaseURL(this.ctx);
+  getPortalURL(partnerId) {
+    return __async(this, null, function* () {
+      return partnerId && (yield this.getPartnerURL(partnerId)) || getPortalBaseURL(this.ctx);
+    });
   }
-  async getWebAuthURLForCreate({
-    webAuthId,
-    ...options
-  }) {
-    return this.constructPortalUrl("createAuth", { ...options, pathId: webAuthId });
+  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 }));
+    });
   }
-  async getPasswordURLForCreate({
-    passwordId,
-    ...options
-  }) {
-    return this.constructPortalUrl("createPassword", {
-      ...options,
-      pathId: passwordId
+  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) {
@@ -1920,35 +2039,42 @@ var ParaCore = class _ParaCore {
       path: `/short/${compressedUrl}`
     });
   }
-  async shortenLoginLink(link) {
-    const url = await upload(link, this.ctx.client);
-    return this.getShortUrl(url);
+  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
    */
-  async getWebAuthURLForLogin(opts) {
-    return this.constructPortalUrl("loginAuth", opts);
+  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
    */
-  async getPasswordURLForLogin(opts) {
-    return this.constructPortalUrl("loginPassword", opts);
+  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
    */
-  async getWebAuthURLForLoginForPhone(opts) {
-    return this.constructPortalUrl("loginAuth", {
-      authType: "phone",
-      ...opts
+  getWebAuthURLForLoginForPhone(opts) {
+    return __async(this, null, function* () {
+      return this.constructPortalUrl("loginAuth", __spreadValues({
+        authType: "phone"
+      }, opts));
     });
   }
   /**
@@ -1956,57 +2082,59 @@ var ParaCore = class _ParaCore {
    * @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.
    */
-  async getPrivateKey(walletId) {
-    const wallets = Object.values(this.wallets);
-    const wallet = walletId ? this.wallets[walletId] : wallets?.[0];
-    if (!wallet) {
-      throw new Error("wallet not found");
-    }
-    if (wallet.scheme !== WalletScheme2.DKLS) {
-      throw new Error("invalid wallet scheme");
-    }
-    return await this.platformUtils.getPrivateKey(
-      this.ctx,
-      this.userId,
-      wallet.id,
-      wallet.signer,
-      this.retrieveSessionCookie()
-    );
+  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 !== WalletScheme2.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.
    */
-  async fetchWallets() {
-    const res = await (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)))
-    );
+  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)))
+      );
+    });
   }
-  async populateWalletAddresses() {
-    const res = await this.ctx.client.getWallets(this.userId, true);
-    const wallets = res.data.wallets;
-    wallets.forEach((entity) => {
-      if (this.wallets[entity.id]) {
-        this.wallets[entity.id] = {
-          ...entityToWallet(entity),
-          ...this.wallets[entity.id]
-        };
-      }
+  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);
     });
-    await this.setWallets(this.wallets);
   }
-  async populatePregenWalletAddresses() {
-    const res = await this.getPregenWallets();
-    res.forEach((entity) => {
-      if (this.wallets[entity.id]) {
-        this.wallets[entity.id] = {
-          ...entityToWallet(entity),
-          ...this.wallets[entity.id]
-        };
-      }
+  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);
     });
-    await this.setWallets(this.wallets);
   }
   /**
    * Checks if a user exists for an email address.
@@ -2014,9 +2142,11 @@ var ParaCore = class _ParaCore {
    * @param {string} opts.email the email to check.
    * @returns true if user exists, false otherwise.
    */
-  async checkIfUserExists({ email }) {
-    const res = await this.ctx.client.checkUserExists({ email });
-    return res.data.exists;
+  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.
@@ -2025,23 +2155,26 @@ var ParaCore = class _ParaCore {
    * @param {string} opts.countryCode - the country code.
    * @returns true if user exists, false otherwise.
    */
-  async checkIfUserExistsByPhone({ phone, countryCode }) {
-    const res = await this.ctx.client.checkUserExists({ phone, countryCode });
-    return res.data.exists;
+  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.
    */
-  async createUser({ email }) {
-    this.requireApiKey();
-    await this.setEmail(email);
-    const { userId } = await this.ctx.client.createUser({
-      email: this.email,
-      ...this.getVerificationEmailProps()
+  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);
     });
-    await this.setUserId(userId);
   }
   /**
    * Creates a new user with a phone number.
@@ -2049,14 +2182,16 @@ var ParaCore = class _ParaCore {
    * @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.
    */
-  async createUserByPhone({ phone, countryCode }) {
-    this.requireApiKey();
-    await this.setPhoneNumber(phone, countryCode);
-    const { userId } = await this.ctx.client.createUser({
-      phone: this.phone,
-      countryCode: this.countryCode
+  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);
     });
-    await this.setUserId(userId);
   }
   /**
    * Logs in or creates a new user using an external wallet address.
@@ -2065,17 +2200,19 @@ var ParaCore = class _ParaCore {
    * @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.
    */
-  async externalWalletLogin(wallet) {
-    this.requireApiKey();
-    const res = await this.ctx.client.externalWalletLogin({
-      externalAddress: wallet.address,
-      type: wallet.type,
-      externalWalletProvider: wallet.provider,
-      shouldTrackUser: wallet.shouldTrackUser
-    });
-    await this.setExternalWallet(wallet);
-    await this.setUserId(res.userId);
-    return res;
+  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,
+        shouldTrackUser: wallet.shouldTrackUser
+      });
+      yield this.setExternalWallet(wallet);
+      yield this.setUserId(res.userId);
+      return res;
+    });
   }
   /**
    * Returns whether or not the user is connected with an external wallet.
@@ -2089,18 +2226,22 @@ var ParaCore = class _ParaCore {
    * @param {string} verificationCode the six-digit code to check
    * @returns {string} the web auth url for creating a new credential
    */
-  async verifyEmail({ verificationCode }) {
-    await this.ctx.client.verifyEmail(this.userId, { verificationCode });
-    return this.getSetUpBiometricsURL();
-  }
-  async verifyExternalWallet({
-    address,
-    signedMessage,
-    cosmosPublicKeyHex,
-    cosmosSigner
-  }) {
-    await this.ctx.client.verifyExternalWallet(this.userId, { address, signedMessage, cosmosPublicKeyHex, cosmosSigner });
-    return this.getSetUpBiometricsURL();
+  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();
+    });
   }
   /**
    * Passes the phone code obtained from the user for verification.
@@ -2108,9 +2249,11 @@ var ParaCore = class _ParaCore {
    * @param {string} verificationCode the six-digit code to check
    * @returns {string} the web auth url for creating a new credential
    */
-  async verifyPhone({ verificationCode }) {
-    await this.ctx.client.verifyPhone(this.userId, { verificationCode });
-    return this.getSetUpBiometricsURLForPhone();
+  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
@@ -2118,17 +2261,19 @@ var ParaCore = class _ParaCore {
    * @param authResponse - the response JSON object received from the Telegram widget.
    * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
    */
-  async verifyTelegram(authObject) {
-    const res = await this.ctx.client.verifyTelegram(authObject);
-    if (res.isValid) {
-      await this.setUserId(res.userId);
-      await this.setTelegramUserId(res.telegramUserId);
-      await this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        await this.setLoginEncryptionKeyPair();
+  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;
+      return res;
+    });
   }
   /**
    * Performs 2FA verification.
@@ -2137,14 +2282,16 @@ var ParaCore = class _ParaCore {
    * @param {string} opts.verificationCode the verification code to received via 2FA.
    * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
    */
-  async verify2FA({ email, verificationCode }) {
-    const res = await this.ctx.client.verify2FA(email, verificationCode);
-    return {
-      initiatedAt: res.data.initiatedAt,
-      status: res.data.status,
-      userId: res.data.userId,
-      wallets: res.data.wallets
-    };
+  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.
@@ -2154,65 +2301,76 @@ var ParaCore = class _ParaCore {
    * @param {string} opts.verificationCode - verification code to received via 2FA.
    * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
    */
-  async verify2FAForPhone({
-    phone,
-    countryCode,
-    verificationCode
-  }) {
-    const res = await this.ctx.client.verify2FAForPhone(phone, countryCode, verificationCode);
-    return {
-      initiatedAt: res.data.initiatedAt,
-      status: res.data.status,
-      userId: res.data.userId,
-      wallets: res.data.wallets
-    };
+  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
    * */
-  async setup2FA() {
-    const res = await this.ctx.client.setup2FA(this.userId);
-    return {
-      uri: res.data.uri
-    };
+  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.
    */
-  async enable2FA({ verificationCode }) {
-    await this.ctx.client.enable2FA(this.userId, verificationCode);
+  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
    */
-  async check2FAStatus() {
-    if (!this.userId) {
-      return { isSetup: false };
-    }
-    const res = await this.ctx.client.check2FAStatus(this.userId);
-    return {
-      isSetup: res.data.isSetup
-    };
+  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.
    */
-  async resendVerificationCode() {
-    await this.ctx.client.resendVerificationCode({
-      userId: this.userId,
-      ...this.getVerificationEmailProps()
+  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.
    */
-  async resendVerificationCodeByPhone() {
-    await this.ctx.client.resendVerificationCodeByPhone({
-      userId: this.userId
+  resendVerificationCodeByPhone() {
+    return __async(this, null, function* () {
+      yield this.ctx.client.resendVerificationCodeByPhone({
+        userId: this.userId
+      });
     });
   }
   /**
@@ -2222,19 +2380,21 @@ var ParaCore = class _ParaCore {
    * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
    * @returns {string} the URL
    */
-  async getSetUpBiometricsURL({
-    authType = "email",
-    isForNewDevice = false
-  } = {}) {
-    const res = await this.ctx.client.addSessionPublicKey(this.userId, {
-      status: PublicKeyStatus.PENDING,
-      type: PublicKeyType.WEB
-    });
-    return this.getWebAuthURLForCreate({
-      authType,
-      isForNewDevice,
-      webAuthId: res.data.id,
-      partnerId: res.data.partnerId
+  getSetUpBiometricsURL() {
+    return __async(this, arguments, function* ({
+      authType = "email",
+      isForNewDevice = false
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
+        status: PublicKeyStatus.PENDING,
+        type: PublicKeyType.WEB
+      });
+      return this.getWebAuthURLForCreate({
+        authType,
+        isForNewDevice,
+        webAuthId: res.data.id,
+        partnerId: res.data.partnerId
+      });
     });
   }
   /**
@@ -2243,18 +2403,20 @@ var ParaCore = class _ParaCore {
    * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
    * @returns {string} the URL
    */
-  async getSetUpBiometricsURLForPhone({
-    isForNewDevice = false
-  } = {}) {
-    const res = await this.ctx.client.addSessionPublicKey(this.userId, {
-      status: PublicKeyStatus.PENDING,
-      type: PublicKeyType.WEB
-    });
-    return this.getWebAuthURLForCreate({
-      authType: "phone",
-      isForNewDevice,
-      webAuthId: res.data.id,
-      partnerId: res.data.partnerId
+  getSetUpBiometricsURLForPhone() {
+    return __async(this, arguments, function* ({
+      isForNewDevice = false
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
+        status: PublicKeyStatus.PENDING,
+        type: PublicKeyType.WEB
+      });
+      return this.getWebAuthURLForCreate({
+        authType: "phone",
+        isForNewDevice,
+        webAuthId: res.data.id,
+        partnerId: res.data.partnerId
+      });
     });
   }
   /**
@@ -2265,95 +2427,107 @@ var ParaCore = class _ParaCore {
    * @param {Theme} [opts.theme] the portal theme to use in place of the partner's default
    * @returns {string} the URL
    */
-  async getSetupPasswordURL({
-    authType = "email",
-    isForNewDevice = false,
-    theme
-  } = {}) {
-    const res = await this.ctx.client.addSessionPasswordPublicKey(this.userId, {
-      status: PasswordStatus.PENDING
-    });
-    return this.getPasswordURLForCreate({
-      authType,
-      isForNewDevice,
-      passwordId: res.data.id,
-      partnerId: res.data.partnerId,
+  getSetupPasswordURL() {
+    return __async(this, arguments, function* ({
+      authType = "email",
+      isForNewDevice = false,
       theme
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPasswordPublicKey(this.userId, {
+        status: 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
    */
-  async isSessionActive() {
-    if (this.isUsingExternalWallet()) {
-      return true;
-    }
-    const res = await this.touchSession();
-    return !!res.data.isAuthenticated;
+  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
    **/
-  async isFullyLoggedIn() {
-    if (this.isUsingExternalWallet()) {
-      return true;
-    }
-    const isSessionActive = await this.isSessionActive();
-    return isSessionActive && this.currentWalletIdsArray.length > 0 && this.currentWalletIdsArray.reduce((acc, [id]) => acc && !!this.wallets[id], true);
+  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);
+    });
   }
-  async supportedAuthMethods(auth) {
-    const { supportedAuthMethods } = await this.ctx.client.getSupportedAuthMethods(auth);
-    const authMethods = /* @__PURE__ */ new Set();
-    for (const type of supportedAuthMethods) {
-      switch (type) {
-        case "PASSWORD":
-          authMethods.add(AuthMethod.PASSWORD);
-          break;
-        case "BIOMETRIC":
-          authMethods.add(AuthMethod.PASSKEY);
-          break;
+  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(AuthMethod.PASSWORD);
+            break;
+          case "BIOMETRIC":
+            authMethods.add(AuthMethod.PASSKEY);
+            break;
+        }
       }
-    }
-    return authMethods;
+      return authMethods;
+    });
   }
   /**
    * Get hints associated with the users stored biometrics.
    * @returns Array containing useragents and AAGuids for stored biometrics
    */
-  async getUserBiometricLocationHints() {
-    if (!this.email && !this.phone && !this.farcasterUsername && !this.telegramUserId) {
-      throw new Error("one of email, phone or farcaster username are required to get biometric location hints");
-    }
-    return await this.ctx.client.getBiometricLocationHints({
-      email: this.email,
-      phone: this.phone,
-      countryCode: this.countryCode,
-      farcasterUsername: this.farcasterUsername,
-      telegramUserId: this.telegramUserId
+  getUserBiometricLocationHints() {
+    return __async(this, null, function* () {
+      if (!this.email && !this.phone && !this.farcasterUsername && !this.telegramUserId) {
+        throw new Error("one of email, phone or farcaster username 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
+      });
     });
   }
-  async setAuth(auth) {
-    const authInfo = extractAuthInfo(auth);
-    if (!authInfo) {
-      return void 0;
-    }
-    switch (authInfo.authType) {
-      case "email":
-        await this.setEmail(authInfo.identifier);
-        break;
-      case "phone":
-        await this.setPhoneNumber(authInfo.auth.phone, authInfo.auth.countryCode);
-        break;
-      case "farcaster":
-        await this.setFarcasterUsername(authInfo.identifier);
-        break;
-      case "telegram":
-        await this.setTelegramUserId(authInfo.identifier);
-        break;
-    }
-    return authInfo;
+  setAuth(auth) {
+    return __async(this, null, function* () {
+      const authInfo = 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.
@@ -2362,41 +2536,46 @@ var ParaCore = class _ParaCore {
    * @param {boolean} opts.useShortURL - whether to shorten the link
    * @returns - the WebAuth URL for logging in
    **/
-  async initiateUserLogin({ useShortUrl = false, ...auth }) {
-    const authInfo = await this.setAuth(auth);
-    if (!authInfo) {
-      return;
-    }
-    const res = await this.touchSession(true);
-    if (!this.loginEncryptionKeyPair) {
-      await this.setLoginEncryptionKeyPair();
-    }
-    const webAuthLoginURL = await 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);
+  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
    **/
-  async initiateUserLoginV2(auth) {
-    const authInfo = await this.setAuth(auth);
-    if (!authInfo) {
-      return;
-    }
-    await this.touchSession(true);
-    if (!this.loginEncryptionKeyPair) {
-      await this.setLoginEncryptionKeyPair();
-    }
-    return await this.supportedAuthMethods(authInfo.auth);
+  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.
@@ -2406,112 +2585,124 @@ var ParaCore = class _ParaCore {
    * @param opts.useShortURL - whether to shorten the link
    * @returns - the WebAuth URL for logging in
    **/
-  async initiateUserLoginForPhone({
-    useShortUrl = false,
-    ...auth
-  }) {
-    await this.setAuth(auth);
-    const res = await this.touchSession(true);
-    if (!this.loginEncryptionKeyPair) {
-      await this.setLoginEncryptionKeyPair();
-    }
-    const webAuthLoginURL = await this.getWebAuthURLForLoginForPhone({
-      sessionId: res.data.sessionId,
-      loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair),
-      partnerId: res.data.partnerId
+  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);
     });
-    if (!useShortUrl) {
-      return webAuthLoginURL;
-    }
-    return this.shortenLoginLink(webAuthLoginURL);
   }
   /**
    * Waits for the session to be active.
    **/
-  async waitForAccountCreation({ popupWindow } = {}) {
-    await this.touchSession();
-    this.externalWallets = {};
-    this.isAwaitingAccountCreation = true;
-    while (this.isAwaitingAccountCreation) {
-      try {
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        if (await this.isSessionActive()) {
-          this.isAwaitingAccountCreation = false;
-          dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
-          return true;
-        } else {
-          if (popupWindow?.closed) {
+  waitForAccountCreation() {
+    return __async(this, arguments, function* ({ popupWindow } = {}) {
+      yield this.touchSession();
+      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;
-            return 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);
         }
-      } catch (err) {
-        console.error(err);
       }
-    }
-    return false;
+      return false;
+    });
   }
-  async waitForPasskeyAndCreateWallet({
-    popupWindow
-  } = {}) {
-    await this.waitForAccountCreation({ popupWindow });
-    const pregenWallets = await this.getPregenWallets();
-    let recoverySecret, walletIds = {};
-    if (pregenWallets.length > 0) {
-      recoverySecret = await this.claimPregenWallets();
-      walletIds = this.supportedWalletTypes.reduce((acc, { type }) => {
-        return {
-          ...acc,
-          [type]: [pregenWallets.find((w) => !!WalletSchemeTypeMap[w.scheme][type])?.id]
-        };
-      }, {});
-    }
-    const created = await this.createWalletPerType();
-    recoverySecret = recoverySecret ?? created.recoverySecret;
-    walletIds = { ...walletIds, ...created.walletIds };
-    const resp = { walletIds, recoverySecret };
-    dispatchEvent(ParaEvent.ACCOUNT_SETUP_EVENT, resp);
-    return resp;
+  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
    */
-  async getFarcasterConnectURL() {
-    await this.logout();
-    await this.touchSession(true);
-    const {
-      data: { connect_uri }
-    } = await this.ctx.client.initializeFarcasterLogin();
-    return 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.
    */
-  async waitForFarcasterStatus() {
-    this.isAwaitingFarcaster = true;
-    while (this.isAwaitingFarcaster) {
-      try {
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        const res = await this.ctx.client.getFarcasterAuthStatus();
-        if (res.data.state === "completed") {
-          const { userId, userExists, username, pfpUrl } = res.data;
-          await this.setUserId(userId);
-          await this.setFarcasterUsername(username);
-          return {
-            userExists,
-            username,
-            pfpUrl
-          };
+  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;
         }
-      } catch (err) {
-        console.error(err);
-        this.isAwaitingFarcaster = false;
       }
-    }
+    });
   }
   /**
    * Generates a URL for the user to log in with OAuth using a desire method.
@@ -2521,17 +2712,19 @@ var ParaCore = class _ParaCore {
    * @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.
    */
-  async getOAuthURL({ method, deeplinkUrl }) {
-    await this.logout();
-    const res = await this.touchSession(true);
-    return constructUrl({
-      base: method === OAuthMethod.TELEGRAM ? getPortalBaseURL(this.ctx, true) : getBaseOAuthUrl(this.ctx.env),
-      path: `/auth/${method.toLowerCase()}`,
-      params: {
-        apiKey: this.ctx.apiKey,
-        sessionLookupId: res.data.sessionLookupId,
-        deeplinkUrl
-      }
+  getOAuthURL(_0) {
+    return __async(this, arguments, function* ({ method, deeplinkUrl }) {
+      yield this.logout();
+      const res = yield this.touchSession(true);
+      return constructUrl({
+        base: method === OAuthMethod.TELEGRAM ? getPortalBaseURL(this.ctx, true) : getBaseOAuthUrl(this.ctx.env),
+        path: `/auth/${method.toLowerCase()}`,
+        params: {
+          apiKey: this.ctx.apiKey,
+          sessionLookupId: res.data.sessionLookupId,
+          deeplinkUrl
+        }
+      });
     });
   }
   /**
@@ -2542,36 +2735,38 @@ var ParaCore = class _ParaCore {
    * @param {Window} [opts.popupWindow] the popup window being used for login.
    * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
    */
-  async waitForOAuth({ popupWindow } = {}) {
-    this.isAwaitingOAuth = true;
-    while (this.isAwaitingOAuth) {
-      try {
-        if (popupWindow?.closed) {
-          return { isError: true, userExists: false };
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        if (this.isAwaitingOAuth) {
-          const res = await this.touchSession();
-          if (res.data.userId) {
-            const { userId, email } = res.data;
-            if (!this.loginEncryptionKeyPair) {
-              await this.setLoginEncryptionKeyPair();
+  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
+              };
             }
-            await this.setUserId(userId);
-            await this.setEmail(email);
-            const userExists = await this.checkIfUserExists({ email });
-            this.isAwaitingOAuth = false;
-            return {
-              userExists,
-              email
-            };
           }
+        } catch (err) {
+          console.error(err);
         }
-      } catch (err) {
-        console.error(err);
       }
-    }
-    return { userExists: false };
+      return { userExists: false };
+    });
   }
   /**
    * Waits for the session to be active and sets up the user.
@@ -2581,56 +2776,59 @@ var ParaCore = class _ParaCore {
    * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
    * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
    **/
-  async waitForLoginAndSetup({
-    popupWindow,
-    skipSessionRefresh = false
-  } = {}) {
-    this.externalWallets = {};
-    this.isAwaitingLogin = true;
-    while (this.isAwaitingLogin) {
-      try {
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-        if (!await this.isSessionActive()) {
-          if (popupWindow?.closed) {
-            const resp2 = { isComplete: false, isError: true };
-            dispatchEvent(ParaEvent.LOGIN_EVENT, resp2, "failed to setup user");
-            return resp2;
-          }
-          continue;
-        }
-        const postLoginData = await this.userSetupAfterLogin();
-        const needsWallet = postLoginData.data.needsWallet ?? false;
-        if (!needsWallet) {
-          if (this.currentWalletIdsArray.length === 0) {
-            if (popupWindow?.closed) {
+  waitForLoginAndSetup() {
+    return __async(this, arguments, function* ({
+      popupWindow,
+      skipSessionRefresh = false
+    } = {}) {
+      var _a;
+      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;
-            } else {
-              continue;
             }
+            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 fetchedWallets = await this.fetchWallets();
-        const tempSharesRes = await this.getTransmissionKeyShares();
-        if (tempSharesRes.data.temporaryShares.length === fetchedWallets.length) {
-          await this.setupAfterLogin({ temporaryShares: tempSharesRes.data.temporaryShares, skipSessionRefresh });
-          await 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;
+      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
@@ -2640,32 +2838,36 @@ var ParaCore = class _ParaCore {
    * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
    * @returns a URL for the user to reauthenticate.
    **/
-  async refreshSession({ shouldOpenPopup = false } = {}) {
-    const res = await this.touchSession(true);
-    if (!this.loginEncryptionKeyPair) {
-      await this.setLoginEncryptionKeyPair();
-    }
-    const link = await this.getWebAuthURLForLogin({
-      sessionId: res.data.sessionId,
-      loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair)
+  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;
     });
-    if (shouldOpenPopup) {
-      this.platformUtils.openPopup(link);
-    }
-    return link;
   }
   /**
    * Call this method after login to ensure that the user ID is set
    * internally.
    **/
-  async userSetupAfterLogin() {
-    const res = await this.touchSession();
-    await this.setUserId(res.data.userId);
-    if (res.data.currentWalletIds && res.data.currentWalletIds !== this.currentWalletIds)
-      await this.setCurrentWalletIds(res.data.currentWalletIds, {
-        sessionLookupId: this.isPortal() ? res.data.sessionLookupId : void 0
-      });
-    return res;
+  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.
@@ -2673,10 +2875,12 @@ var ParaCore = class _ParaCore {
    * @param {boolean} opts.isForNewDevice - true if this device is registering.
    * @returns - transmission keyshares.
    **/
-  async getTransmissionKeyShares({ isForNewDevice = false } = {}) {
-    const res = await this.touchSession();
-    const sessionLookupId = isForNewDevice ? `${res.data.sessionLookupId}-new-device` : res.data.sessionLookupId;
-    return this.ctx.client.getTransmissionKeyshares(this.userId, sessionLookupId);
+  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.
@@ -2684,23 +2888,25 @@ var ParaCore = class _ParaCore {
    * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
    * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
    **/
-  async setupAfterLogin({
-    temporaryShares,
-    skipSessionRefresh = false
-  } = {}) {
-    if (!temporaryShares) {
-      temporaryShares = (await 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
-      };
+  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);
     });
-    await this.deleteLoginEncryptionKeyPair();
-    await this.populateWalletAddresses();
-    await this.touchSession(!skipSessionRefresh);
   }
   /**
    * Distributes a new wallet recovery share.
@@ -2711,51 +2917,55 @@ var ParaCore = class _ParaCore {
    * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
    * @returns {string} the recovery share.
    **/
-  async distributeNewWalletShare({
-    walletId,
-    userShare,
-    skipBiometricShareCreation = false,
-    forceRefresh = false
-  }) {
-    let userSigner = userShare;
-    if (!userSigner) {
-      userSigner = this.wallets[walletId].signer;
-    }
-    const recoveryShare = skipBiometricShareCreation ? await sendRecoveryForShare({
-      ctx: this.ctx,
-      userId: this.userId,
-      walletId,
-      userSigner,
-      emailProps: this.getBackupKitEmailProps(),
-      forceRefresh
-    }) : await distributeNewShare({
-      ctx: this.ctx,
-      userId: this.userId,
+  distributeNewWalletShare(_0) {
+    return __async(this, arguments, function* ({
       walletId,
-      userShare: userSigner,
-      emailProps: this.getBackupKitEmailProps()
+      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;
     });
-    return recoveryShare;
   }
-  async waitForWalletAddress(walletId) {
-    let maxPolls = 0;
-    while (true) {
-      try {
-        if (maxPolls === 10) {
-          break;
-        }
-        ++maxPolls;
-        const res = await this.ctx.client.getWallets(this.userId);
-        const wallet = res.data.wallets.find((w) => w.id === walletId);
-        if (wallet && wallet.address) {
-          return;
+  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);
         }
-        await new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
-      } catch (err) {
-        console.error(err);
       }
-    }
-    throw new Error("timed out waiting for wallet address");
+      throw new Error("timed out waiting for wallet address");
+    });
   }
   /**
    * Waits for a pregen wallet address to be created.
@@ -2765,25 +2975,27 @@ var ParaCore = class _ParaCore {
    * @param pregenIdentifierType - the identifier type of the user the pregen wallet is associated with.
    * @returns - recovery share.
    **/
-  async waitForPregenWalletAddress(walletId) {
-    let maxPolls = 0;
-    while (true) {
-      try {
-        if (maxPolls === 10) {
-          break;
-        }
-        ++maxPolls;
-        const res = await this.getPregenWallets();
-        const wallet = res.find((w) => w.id === walletId);
-        if (wallet && wallet.address) {
-          return;
+  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);
         }
-        await new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
-      } catch (err) {
-        console.error(err);
       }
-    }
-    throw new Error("timed out waiting for wallet address");
+      throw new Error("timed out waiting for wallet address");
+    });
   }
   /**
    * Creates several new wallets with the desired types. If no types are provided, this method
@@ -2796,24 +3008,26 @@ var ParaCore = class _ParaCore {
    * @param {WalletType[]} [opts.types] the types of wallets to create.
    * @returns {Object} the wallets created, their ids, and the recovery secret.
    **/
-  async createWalletPerType({
-    skipDistribute = false,
-    types
-  } = {}) {
-    const wallets = [];
-    const walletIds = {};
-    let recoverySecret;
-    for (const type of await this.getTypesToCreate(types)) {
-      const [wallet, recoveryShare] = await this.createWallet({ type, skipDistribute });
-      wallets.push(wallet);
-      getEquivalentTypes(type).filter((t) => !!this.isWalletTypeEnabled[t]).forEach((t) => {
-        walletIds[t] = [wallet.id];
-      });
-      if (recoveryShare) {
-        recoverySecret = recoveryShare;
+  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 };
+      return { wallets, walletIds, recoverySecret };
+    });
   }
   /**
    * Refresh the current user share for a wallet.
@@ -2827,35 +3041,37 @@ var ParaCore = class _ParaCore {
    * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
    * @returns {Object} the new user share and recovery secret.
    **/
-  async refreshShare({
-    walletId,
-    share,
-    oldPartnerId,
-    newPartnerId,
-    keyShareProtocolId,
-    redistributeBackupEncryptedShares
-  }) {
-    const { signer, protocolId } = await this.platformUtils.refresh(
-      this.ctx,
-      this.retrieveSessionCookie(),
-      this.userId,
+  refreshShare(_0) {
+    return __async(this, arguments, function* ({
       walletId,
       share,
       oldPartnerId,
       newPartnerId,
-      keyShareProtocolId
-    );
-    const recoverySecret = await distributeNewShare({
-      ctx: this.ctx,
-      userId: this.userId,
-      walletId,
-      userShare: signer,
-      ignoreRedistributingBackupEncryptedShare: !redistributeBackupEncryptedShares,
-      emailProps: this.getBackupKitEmailProps(),
-      partnerId: newPartnerId,
-      protocolId
+      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 };
     });
-    return { signer, recoverySecret, protocolId };
   }
   /**
    * Creates a new wallet.
@@ -2864,71 +3080,73 @@ var ParaCore = class _ParaCore {
    * @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.
    **/
-  async createWallet({
-    type: _type,
-    skipDistribute = false
-  } = {}) {
-    this.requireApiKey();
-    const walletType = await this.assertIsValidWalletType(
-      _type ?? this.supportedWalletTypes.find(({ optional }) => !optional)?.type
-    );
-    let signer;
-    let wallet;
-    let keygenRes;
-    switch (walletType) {
-      case WalletType2.SOLANA: {
-        keygenRes = await this.platformUtils.ed25519Keygen(
-          this.ctx,
-          this.userId,
-          this.retrieveSessionCookie(),
-          this.getBackupKitEmailProps()
-        );
-        break;
+  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 WalletType2.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;
+        }
       }
-      default: {
-        keygenRes = await 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 === WalletType2.SOLANA ? WalletScheme2.ED25519 : WalletScheme2.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()
+        });
       }
-    }
-    const walletId = keygenRes.walletId;
-    signer = keygenRes.signer;
-    this.wallets[walletId] = {
-      id: walletId,
-      signer,
-      scheme: walletType === WalletType2.SOLANA ? WalletScheme2.ED25519 : WalletScheme2.DKLS,
-      type: walletType
-    };
-    wallet = this.wallets[walletId];
-    await this.waitForWalletAddress(wallet.id);
-    await this.populateWalletAddresses();
-    let recoveryShare = null;
-    if (!skipDistribute) {
-      recoveryShare = await 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
       });
-    }
-    await this.setCurrentWalletIds({
-      ...this.currentWalletIds,
-      [walletType]: [...this.currentWalletIds[walletType] ?? [], walletId]
+      return [wallet, recoveryShare];
     });
-    const walletNoSigner = { ...wallet };
-    delete walletNoSigner.signer;
-    dispatchEvent(ParaEvent.WALLET_CREATED, {
-      wallet: walletNoSigner,
-      recoverySecret: recoveryShare
-    });
-    return [wallet, recoveryShare];
   }
   /**
    * Creates a new pregenerated wallet.
@@ -2939,51 +3157,54 @@ var ParaCore = class _ParaCore {
    * @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.
    **/
-  async createPregenWallet(opts) {
-    const {
-      type: _type = this.supportedWalletTypes.find(({ optional }) => !optional)?.type,
-      pregenIdentifier,
-      pregenIdentifierType = "EMAIL"
-    } = opts;
-    this.requireApiKey();
-    const walletType = await this.assertIsValidWalletType(
-      _type ?? this.supportedWalletTypes.find(({ optional }) => !optional)?.type
-    );
-    let keygenRes;
-    switch (walletType) {
-      case WalletType2.SOLANA:
-        keygenRes = await this.platformUtils.ed25519PreKeygen(
-          this.ctx,
-          pregenIdentifier,
-          pregenIdentifierType,
-          this.retrieveSessionCookie()
-        );
-        break;
-      default:
-        keygenRes = await 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 === WalletType2.SOLANA ? WalletScheme2.ED25519 : WalletScheme2.DKLS,
-      type: walletType,
-      isPregen: true,
-      pregenIdentifier,
-      pregenIdentifierType
-    };
-    await this.waitForPregenWalletAddress(walletId);
-    await this.populatePregenWalletAddresses();
-    return this.wallets[walletId];
+  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 WalletType2.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 === WalletType2.SOLANA ? WalletScheme2.ED25519 : WalletScheme2.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.
@@ -2995,17 +3216,19 @@ var ParaCore = class _ParaCore {
    * @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.
    **/
-  async createPregenWalletPerType({
-    types,
-    pregenIdentifier,
-    pregenIdentifierType = "EMAIL"
-  }) {
-    const wallets = [];
-    for (const type of await this.getTypesToCreate(types)) {
-      const wallet = await this.createPregenWallet({ type, pregenIdentifier, pregenIdentifierType });
-      wallets.push(wallet);
-    }
-    return 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.
@@ -3015,63 +3238,65 @@ var ParaCore = class _ParaCore {
    * @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.
    **/
-  async claimPregenWallets({
-    pregenIdentifier,
-    pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
-  } = {}) {
-    this.requireApiKey();
-    const pregenWallets = pregenIdentifier && pregenIdentifierType ? await this.getPregenWallets({ pregenIdentifier, pregenIdentifierType }) : await this.getPregenWallets();
-    if (pregenWallets.length === 0) {
-      return void 0;
-    }
-    let newRecoverySecret;
-    const { walletIds } = await 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 === WalletScheme2.ED25519) {
-        const distributeRes = await distributeNewShare({
-          ctx: this.ctx,
+  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;
+      }
+      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 === WalletScheme2.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,
-          walletId: wallet.id,
-          userShare: this.wallets[wallet.id].signer,
-          emailProps: this.getBackupKitEmailProps(),
-          partnerId: wallet.partnerId
+          pregenIdentifier: void 0,
+          pregenIdentifierType: void 0
         });
-        if (distributeRes.length > 0) {
-          newRecoverySecret = distributeRes;
-        }
-      } else {
-        refreshedShare = await this.refreshShare({
-          walletId: wallet.id,
-          share: this.wallets[wallet.id].signer,
-          oldPartnerId: wallet.partnerId,
-          newPartnerId: wallet.partnerId,
-          redistributeBackupEncryptedShares: true
+        const walletNoSigner = __spreadValues({}, this.wallets[wallet.id]);
+        delete walletNoSigner.signer;
+        dispatchEvent(ParaEvent.PREGEN_WALLET_CLAIMED, {
+          wallet: walletNoSigner,
+          recoverySecret: newRecoverySecret
         });
-        if (refreshedShare.recoverySecret) {
-          newRecoverySecret = refreshedShare.recoverySecret;
-        }
       }
-      this.wallets[wallet.id] = {
-        ...this.wallets[wallet.id],
-        signer: refreshedShare?.signer ?? wallet.signer,
-        userId: this.userId,
-        pregenIdentifier: void 0,
-        pregenIdentifierType: void 0
-      };
-      const walletNoSigner = { ...this.wallets[wallet.id] };
-      delete walletNoSigner.signer;
-      dispatchEvent(ParaEvent.PREGEN_WALLET_CLAIMED, {
-        wallet: walletNoSigner,
-        recoverySecret: newRecoverySecret
-      });
-    }
-    await this.setWallets(this.wallets);
-    return newRecoverySecret;
+      yield this.setWallets(this.wallets);
+      return newRecoverySecret;
+    });
   }
   /**
    * Updates the identifier for a pregen wallet.
@@ -3080,24 +3305,25 @@ var ParaCore = class _ParaCore {
    * @param {string} opts.newPregenIdentifier the new identtifier
    * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
    **/
-  async updatePregenWalletIdentifier({
-    walletId,
-    newPregenIdentifier,
-    newPregenIdentifierType
-  }) {
-    this.requireApiKey();
-    await this.ctx.client.updatePregenWallet(walletId, {
-      pregenIdentifier: newPregenIdentifier,
-      pregenIdentifierType: newPregenIdentifierType
-    });
-    if (!!this.wallets[walletId]) {
-      this.wallets[walletId] = {
-        ...this.wallets[walletId],
+  updatePregenWalletIdentifier(_0) {
+    return __async(this, arguments, function* ({
+      walletId,
+      newPregenIdentifier,
+      newPregenIdentifierType
+    }) {
+      this.requireApiKey();
+      yield this.ctx.client.updatePregenWallet(walletId, {
         pregenIdentifier: newPregenIdentifier,
         pregenIdentifierType: newPregenIdentifierType
-      };
-      await this.setWallets(this.wallets);
-    }
+      });
+      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.
@@ -3106,17 +3332,19 @@ var ParaCore = class _ParaCore {
    * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
    * @returns {boolean} whether the pregen wallet exists
    **/
-  async hasPregenWallet({
-    pregenIdentifier,
-    pregenIdentifierType
-  }) {
-    this.requireApiKey();
-    const res = await this.getPregenWallets({ pregenIdentifier, pregenIdentifierType });
-    const wallet = res.find((w) => w.pregenIdentifier === pregenIdentifier && w.pregenIdentifierType === pregenIdentifierType);
-    if (!wallet) {
-      return false;
-    }
-    return true;
+  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.
@@ -3125,17 +3353,19 @@ var ParaCore = class _ParaCore {
    * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
    * @returns {Promise<WalletEntity[]>} the array of found wallets
    **/
-  async getPregenWallets({
-    pregenIdentifier,
-    pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
-  } = {}) {
-    this.requireApiKey();
-    const res = await this.ctx.client.getPregenWallets(
-      pregenIdentifier && pregenIdentifierType ? { [pregenIdentifierType]: [pregenIdentifier] } : this.pregenIds,
-      this.isPortal(),
-      this.userId
-    );
-    return res.wallets.filter((w) => this.isWalletSupported(entityToWallet(w)));
+  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);
@@ -3156,45 +3386,54 @@ var ParaCore = class _ParaCore {
    * Sets the current wallets from a Base 64 string.
    * @param {string} base64Wallet the encoded wallet string
    **/
-  async setUserShare(base64Wallets) {
-    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;
-      await this.setWallets(this.wallets);
-    }
-  }
-  async getTransactionReviewUrl(transactionId, timeoutMs) {
-    const res = await this.touchSession();
-    return this.constructPortalUrl("txReview", {
-      partnerId: res.data.partnerId,
-      pathId: transactionId,
-      params: {
-        email: this.email,
-        timeoutMs: timeoutMs?.toString()
+  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);
       }
     });
   }
-  async getOnRampTransactionUrl({
-    purchaseId,
-    providerKey,
-    ...walletParams
-  }) {
-    const res = await this.touchSession();
-    const [key, identifier] = 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)
-      }
+  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] = 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)
+        }
+      });
     });
   }
   /**
@@ -3208,91 +3447,95 @@ var ParaCore = class _ParaCore {
    * @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
    **/
-  async signMessage({
-    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 = await this.signMessageInner({ wallet, signerId, messageBase64, cosmosSignDocBase64 });
-    let timeStart = Date.now();
-    if (signRes.pendingTransactionId) {
-      this.platformUtils.openPopup(
-        await 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;
-    }
-    await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-    while (true) {
-      if (Date.now() - timeStart > timeoutMs) {
-        break;
-      }
-      try {
-        await this.ctx.client.getPendingTransaction(this.userId, signRes.pendingTransactionId);
-      } catch (err) {
-        const error = new TransactionReviewDenied();
-        dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes, error.message);
-        throw error;
+  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;
       }
-      signRes = await this.signMessageInner({ wallet, signerId, messageBase64, cosmosSignDocBase64 });
+      let signRes = yield this.signMessageInner({ wallet, signerId, messageBase64, cosmosSignDocBase64 });
+      let timeStart = Date.now();
       if (signRes.pendingTransactionId) {
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+        this.platformUtils.openPopup(
+          yield this.getTransactionReviewUrl(signRes.pendingTransactionId, timeoutMs),
+          { type: cosmosSignDocBase64 ? "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ : "SIGN_MESSAGE_REVIEW" /* SIGN_MESSAGE_REVIEW */ }
+        );
       } else {
-        break;
+        dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes);
+        return signRes;
       }
-    }
-    if (signRes.pendingTransactionId) {
-      const error = new TransactionReviewTimeout(
-        await this.getTransactionReviewUrl(signRes.pendingTransactionId),
-        signRes.pendingTransactionId
-      );
-      dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes, error.message);
-      throw error;
-    }
-    dispatchEvent(ParaEvent.SIGN_MESSAGE_EVENT, signRes);
-    return signRes;
-  }
-  async signMessageInner({
-    wallet,
-    signerId,
-    messageBase64,
-    cosmosSignDocBase64
-  }) {
-    let signRes;
-    switch (wallet.scheme) {
-      case WalletScheme2.ED25519:
-        signRes = await this.platformUtils.ed25519Sign(
-          this.ctx,
-          signerId,
-          wallet.id,
-          wallet.signer,
-          messageBase64,
-          this.retrieveSessionCookie()
-        );
-        break;
-      default:
-        signRes = await this.platformUtils.signMessage(
-          this.ctx,
-          signerId,
-          wallet.id,
-          wallet.signer,
-          messageBase64,
-          this.retrieveSessionCookie(),
-          wallet.scheme === WalletScheme2.DKLS,
-          cosmosSignDocBase64
+      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
         );
-        break;
-    }
-    return signRes;
+        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 WalletScheme2.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 === WalletScheme2.DKLS,
+            cosmosSignDocBase64
+          );
+          break;
+      }
+      return signRes;
+    });
   }
   /**
    * Signs a transaction.
@@ -3302,51 +3545,20 @@ var ParaCore = class _ParaCore {
    * @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
    **/
-  async signTransaction({
-    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 = await this.platformUtils.signTransaction(
-      this.ctx,
-      signerId,
+  signTransaction(_0) {
+    return __async(this, arguments, function* ({
       walletId,
-      this.wallets[walletId].signer,
       rlpEncodedTxBase64,
       chainId,
-      this.retrieveSessionCookie(),
-      wallet.scheme === WalletScheme2.DKLS
-    );
-    let timeStart = Date.now();
-    if (signRes.pendingTransactionId) {
-      this.platformUtils.openPopup(
-        await this.getTransactionReviewUrl(signRes.pendingTransactionId, timeoutMs),
-        { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
-      );
-    } else {
-      dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes);
-      return signRes;
-    }
-    await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
-    while (true) {
-      if (Date.now() - timeStart > timeoutMs) {
-        break;
-      }
-      try {
-        await this.ctx.client.getPendingTransaction(this.userId, signRes.pendingTransactionId);
-      } catch (err) {
-        const error = new TransactionReviewDenied();
-        dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes, error.message);
-        throw error;
+      timeoutMs = 3e4
+    }) {
+      this.assertIsValidWalletId(walletId);
+      const wallet = this.wallets[walletId];
+      let signerId = this.userId;
+      if (wallet.partnerId && !wallet.userId) {
+        signerId = wallet.partnerId;
       }
-      signRes = await this.platformUtils.signTransaction(
+      let signRes = yield this.platformUtils.signTransaction(
         this.ctx,
         signerId,
         walletId,
@@ -3356,22 +3568,55 @@ var ParaCore = class _ParaCore {
         this.retrieveSessionCookie(),
         wallet.scheme === WalletScheme2.DKLS
       );
+      let timeStart = Date.now();
       if (signRes.pendingTransactionId) {
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+        this.platformUtils.openPopup(
+          yield this.getTransactionReviewUrl(signRes.pendingTransactionId, timeoutMs),
+          { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
+        );
       } else {
-        break;
+        dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes);
+        return signRes;
       }
-    }
-    if (signRes.pendingTransactionId) {
-      const error = new TransactionReviewTimeout(
-        await this.getTransactionReviewUrl(signRes.pendingTransactionId),
-        signRes.pendingTransactionId
-      );
-      dispatchEvent(ParaEvent.SIGN_TRANSACTION_EVENT, signRes, error.message);
-      throw error;
-    }
-    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 === WalletScheme2.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
@@ -3380,34 +3625,36 @@ var ParaCore = class _ParaCore {
    * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
    * @param chainId - chain id of the chain the transaction is being sent on.
    **/
-  async sendTransaction({
-    walletId,
-    rlpEncodedTxBase64,
-    chainId
-  }) {
-    this.assertIsValidWalletId(walletId);
-    const wallet = this.wallets[walletId];
-    const signRes = await this.platformUtils.sendTransaction(
-      this.ctx,
-      this.userId,
+  sendTransaction(_0) {
+    return __async(this, arguments, function* ({
       walletId,
-      this.wallets[walletId].signer,
       rlpEncodedTxBase64,
-      chainId,
-      this.retrieveSessionCookie(),
-      wallet.scheme === WalletScheme2.DKLS
-    );
-    if (signRes.pendingTransactionId) {
-      this.platformUtils.openPopup(
-        await this.getTransactionReviewUrl(signRes.pendingTransactionId),
-        { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
-      );
-      const error = new TransactionReviewError(
-        await this.getTransactionReviewUrl(signRes.pendingTransactionId)
+      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 === WalletScheme2.DKLS
       );
-      throw error;
-    }
-    return signRes;
+      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;
@@ -3420,36 +3667,38 @@ var ParaCore = class _ParaCore {
    * @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.
    **/
-  async initiateOnRampTransaction(options) {
-    const { params, shouldOpenPopup, ...walletParams } = options;
-    const onRampPurchase = await this.ctx.client.createOnRampPurchase({
-      userId: this.userId,
-      params: {
-        ...params,
-        address: walletParams.externalWalletAddress ?? this.getDisplayAddress(walletParams.walletId, { addressType: params.walletType })
-      },
-      ...walletParams
-    });
-    const portalUrl = await this.getOnRampTransactionUrl({
-      purchaseId: onRampPurchase.id,
-      providerKey: onRampPurchase.providerKey,
-      ...walletParams
+  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 };
     });
-    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.
    **/
-  async keepSessionAlive() {
-    try {
-      await this.ctx.client.keepSessionAlive(this.userId);
-      return true;
-    } catch (err) {
-      return false;
-    }
+  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.
@@ -3474,34 +3723,37 @@ var ParaCore = class _ParaCore {
    * Imports a session serialized by another Para instance.
    * @param {string} serializedInstanceBase64 the serialized session
    */
-  async importSession(serializedInstanceBase64) {
-    const serializedInstance = Buffer.from(serializedInstanceBase64, "base64").toString("utf8");
-    const sessionInfo = JSON.parse(serializedInstance);
-    await this.setEmail(sessionInfo.email);
-    await this.setTelegramUserId(sessionInfo.telegramUserId);
-    await this.setFarcasterUsername(sessionInfo.farcasterUsername);
-    await this.setUserId(sessionInfo.userId);
-    await this.setWallets(sessionInfo.wallets);
-    await this.setExternalWallets(sessionInfo.externalWallets || {});
-    for (const walletId of Object.keys(this.wallets)) {
-      if (!this.wallets[walletId].userId) {
-        this.wallets[walletId].userId = this.userId;
+  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) {
-      await this.setCurrentWalletIds(sessionInfo.currentWalletIds);
-    } else {
-      const currentWalletIds = {};
-      for (const walletId of Object.keys(sessionInfo.wallets)) {
-        currentWalletIds[sessionInfo.wallets[walletId].type] = [
-          ...currentWalletIds[sessionInfo.wallets[walletId].type] ?? [],
-          walletId
-        ];
+      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);
       }
-      await this.setCurrentWalletIds(currentWalletIds);
-    }
-    this.persistSessionCookie(sessionInfo.sessionCookie);
-    await this.setPhoneNumber(sessionInfo.phone, sessionInfo.countryCode);
+      this.persistSessionCookie(sessionInfo.sessionCookie);
+      yield this.setPhoneNumber(sessionInfo.phone, sessionInfo.countryCode);
+    });
   }
   exitAccountCreation() {
     this.isAwaitingAccountCreation = false;
@@ -3525,48 +3777,54 @@ var ParaCore = class _ParaCore {
    * Retrieves a token to verify the current session.
    * @returns {Promise<string>} the ID
    **/
-  async getVerificationToken() {
-    const { data } = await this.touchSession();
-    return data.sessionLookupId;
+  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
    **/
-  async logout({ clearPregenWallets = false } = {}) {
-    await this.ctx.client.logout();
-    await this.clearStorage();
-    if (!clearPregenWallets) {
-      Object.entries(this.wallets).forEach(([id, wallet]) => {
-        if (!wallet.pregenIdentifier) {
-          delete this.wallets[id];
-        }
-      });
-      await 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);
-  }
-  async getSupportedCreateAuthMethods() {
-    const res = await this.touchSession();
-    const partnerId = res.data.partnerId;
-    const partnerRes = await this.ctx.client.getPartner(partnerId);
-    let supportedAuthMethods = /* @__PURE__ */ new Set();
-    for (const authMethod of partnerRes.data.partner.supportedAuthMethods) {
-      supportedAuthMethods.add(AuthMethod[authMethod]);
-    }
-    return supportedAuthMethods;
+  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(AuthMethod[authMethod]);
+      }
+      return supportedAuthMethods;
+    });
   }
   /**
    * Converts to a string, removing sensitive data when logging this class.
@@ -3575,12 +3833,10 @@ var ParaCore = class _ParaCore {
    **/
   toString() {
     const redactedWallets = Object.keys(this.wallets).reduce(
-      (acc, walletId) => ({
-        ...acc,
-        [walletId]: {
-          ...this.wallets[walletId],
+      (acc, walletId) => __spreadProps(__spreadValues({}, acc), {
+        [walletId]: __spreadProps(__spreadValues({}, this.wallets[walletId]), {
           signer: this.wallets[walletId].signer ? "[REDACTED]" : void 0
-        }
+        })
       }),
       {}
     );
@@ -3611,6 +3867,10 @@ var ParaCore = class _ParaCore {
     return `Para ${JSON.stringify(obj, null, 2)}`;
   }
 };
+_supportedWalletTypes = new WeakMap();
+_supportedWalletTypesOpt = new WeakMap();
+_ParaCore.version = PARA_CORE_VERSION;
+var ParaCore = _ParaCore;
 
 // src/index.ts
 import {