@getpara/core-sdk 2.0.0-alpha.3 → 2.0.0-dev.1

package/dist/esm/index.js

@@ -70,6 +70,7 @@ import {
   PublicKeyType,
   WalletType as WalletType2,
   WalletScheme as WalletScheme2,
+  OAuthMethod,
   extractWalletRef,
   PasswordStatus,
   extractAuthInfo,
@@ -187,7 +188,7 @@ function jsonParse(data, validate) {
 }
 
 // src/constants.ts
-var PARA_CORE_VERSION = '2.0.0-alpha.0';
+var PARA_CORE_VERSION = '2.0.0-dev.1';
 var PREFIX = "@CAPSULE/";
 var LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;
 var LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
@@ -317,7 +318,7 @@ function waitUntilTrue(condition, timeoutMs, intervalMs) {
 
 // src/utils/types.ts
 function isServerAuthState(obj) {
-  return "stage" in obj && Object.keys(obj).length > 0;
+  return "stage" in obj;
 }
 
 // src/transmission/transmissionUtils.ts
@@ -376,20 +377,20 @@ var EnabledFlow = /* @__PURE__ */ ((EnabledFlow2) => {
 
 // src/types/coreApi.ts
 var PARA_CORE_METHODS = [
-  "signUpOrLogIn",
-  "verifyNewAccount",
-  "waitForLogin",
-  "waitForSignup",
-  "waitForWalletCreation",
-  "verifyOAuth",
-  "verifyFarcaster",
-  "verifyTelegram",
+  "signUpOrLogInV2",
+  "verifyNewAccountV2",
+  "waitForLoginV2",
+  "waitForSignupV2",
+  "waitForWalletCreationV2",
+  "verifyOAuthV2",
+  "verifyFarcasterV2",
+  "verifyTelegramV2",
   "resendVerificationCode",
-  "loginExternalWallet",
-  "verifyExternalWallet",
-  "setup2fa",
-  "enable2fa",
-  "verify2fa",
+  "loginExternalWalletV2",
+  "verifyExternalWalletV2",
+  "setup2faV2",
+  "enable2faV2",
+  "verify2faV2",
   "logout",
   "clearStorage",
   "isSessionActive",
@@ -402,12 +403,12 @@ var PARA_CORE_METHODS = [
   "fetchWallets",
   "createWallet",
   "createWalletPerType",
-  "getPregenWallets",
-  "hasPregenWallet",
-  "updatePregenWalletIdentifier",
-  "createPregenWallet",
-  "createPregenWalletPerType",
-  "claimPregenWallets",
+  "getPregenWalletsV2",
+  "hasPregenWalletV2",
+  "updatePregenWalletIdentifierV2",
+  "createPregenWalletV2",
+  "createPregenWalletPerTypeV2",
+  "claimPregenWalletsV2",
   "distributeNewWalletShare",
   "getUserShare",
   "setUserShare",
@@ -445,13 +446,13 @@ var PopupType = /* @__PURE__ */ ((PopupType2) => {
 })(PopupType || {});
 
 // src/types/recovery.ts
-var RecoveryStatus = /* @__PURE__ */ ((RecoveryStatus2) => {
-  RecoveryStatus2["INITIATED"] = "INITIATED";
-  RecoveryStatus2["READY"] = "READY";
-  RecoveryStatus2["EXPIRED"] = "EXPIRED";
-  RecoveryStatus2["FINISHED"] = "FINISHED";
-  RecoveryStatus2["CANCELLED"] = "CANCELLED";
-  return RecoveryStatus2;
+var RecoveryStatus = /* @__PURE__ */ ((RecoveryStatus3) => {
+  RecoveryStatus3["INITIATED"] = "INITIATED";
+  RecoveryStatus3["READY"] = "READY";
+  RecoveryStatus3["EXPIRED"] = "EXPIRED";
+  RecoveryStatus3["FINISHED"] = "FINISHED";
+  RecoveryStatus3["CANCELLED"] = "CANCELLED";
+  return RecoveryStatus3;
 })(RecoveryStatus || {});
 
 // src/types/events.ts
@@ -942,7 +943,7 @@ function initClient({
 }) {
   return new Client({
     userManagementHost: getBaseUrl(env),
-    version: ["DEV" /* DEV */, "SANDBOX" /* SANDBOX */].includes(env) ? "dev-v2" : version,
+    version: ["DEV" /* DEV */, "SANDBOX" /* SANDBOX */].includes(env) ? "dev" : version,
     apiKey,
     partnerId,
     opts: { useFetchAdapter },
@@ -1682,7 +1683,7 @@ var _ParaCore = class _ParaCore {
     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) {
+  constructPortalUrlV2(_0) {
     return __async(this, arguments, function* (type, opts = {}) {
       var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
       const [isCreate, isLogin, isOnRamp] = [
@@ -1767,6 +1768,77 @@ var _ParaCore = class _ParaCore {
       return url;
     });
   }
+  constructPortalUrl(_0) {
+    return __async(this, arguments, function* (type, opts = {}) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      const [isCreate, isLogin, isOnRamp] = [
+        ["createAuth", "createPassword"].includes(type),
+        ["loginAuth", "loginPassword"].includes(type),
+        type === "onRamp"
+      ];
+      let auth;
+      if (isCreate || isLogin) {
+        auth = this.assertIsAuthSet().auth;
+      }
+      if ((isLogin || isOnRamp) && !opts.sessionId) {
+        opts.sessionId = (yield this.touchSession()).sessionLookupId;
+      }
+      const base = isOnRamp ? getPortalBaseURL(this.ctx) : yield this.getPortalURL();
+      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 partner = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
+      const params = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+        apiKey: this.ctx.apiKey,
+        partnerId: partner.id,
+        portalFont: ((_a = opts.theme) == null ? void 0 : _a.font) || (partner == null ? void 0 : partner.font) || ((_b = this.portalTheme) == null ? void 0 : _b.font),
+        portalBorderRadius: ((_c = opts.theme) == null ? void 0 : _c.borderRadius) || ((_d = this.portalTheme) == null ? void 0 : _d.borderRadius),
+        portalThemeMode: ((_e = opts.theme) == null ? void 0 : _e.mode) || (partner == null ? void 0 : partner.themeMode) || ((_f = this.portalTheme) == null ? void 0 : _f.mode),
+        portalAccentColor: ((_g = opts.theme) == null ? void 0 : _g.accentColor) || (partner == null ? void 0 : partner.accentColor) || ((_h = this.portalTheme) == null ? void 0 : _h.accentColor),
+        portalForegroundColor: ((_i = opts.theme) == null ? void 0 : _i.foregroundColor) || (partner == null ? void 0 : partner.foregroundColor) || ((_j = this.portalTheme) == null ? void 0 : _j.foregroundColor),
+        portalBackgroundColor: ((_k = opts.theme) == null ? void 0 : _k.backgroundColor) || (partner == null ? void 0 : partner.backgroundColor) || this.portalBackgroundColor || ((_l = this.portalTheme) == null ? void 0 : _l.backgroundColor),
+        portalPrimaryButtonColor: this.portalPrimaryButtonColor,
+        portalTextColor: this.portalTextColor,
+        portalPrimaryButtonTextColor: this.portalPrimaryButtonTextColor,
+        isForNewDevice: opts.isForNewDevice ? opts.isForNewDevice.toString() : void 0
+      }, auth && (isCreate || isLogin) ? auth : {}), isCreate || isLogin ? { authInfo: JSON.stringify(this.authInfo) } : {}), isLogin || isOnRamp ? { sessionId: opts.sessionId } : {}), isLogin ? {
+        encryptionKey: opts.loginEncryptionPublicKey,
+        newDeviceSessionLookupId: opts.newDeviceSessionId,
+        newDeviceEncryptionKey: opts.newDeviceEncryptionKey,
+        pregenIds: JSON.stringify(this.pregenIds),
+        displayName: opts.displayName,
+        pfpUrl: opts.pfpUrl
+      } : {}), opts.params || {});
+      return constructUrl({ base, path, params });
+    });
+  }
   touchSession(regenerate = false) {
     return __async(this, null, function* () {
       var _a, _b, _c;
@@ -1909,7 +1981,7 @@ var _ParaCore = class _ParaCore {
    * @param phone - Phone number to set.
    * @param countryCode - Country Code to set.
    */
-  setPhone(phone, countryCode) {
+  setPhoneNumber(phone, countryCode) {
     return __async(this, null, function* () {
       yield this.setAuth({ phone: formatPhoneNumber(phone, countryCode) });
     });
@@ -2193,6 +2265,75 @@ var _ParaCore = class _ParaCore {
       return (yield this.getPartnerURL()) || getPortalBaseURL(this.ctx);
     });
   }
+  getWebAuthURLForCreate(_a) {
+    return __async(this, null, function* () {
+      var _b = _a, {
+        webAuthId
+      } = _b, options = __objRest(_b, [
+        "webAuthId"
+      ]);
+      return this.constructPortalUrl("createAuth", __spreadProps(__spreadValues({}, options), { pathId: webAuthId }));
+    });
+  }
+  getPasswordURLForCreate(_c) {
+    return __async(this, null, function* () {
+      var _d = _c, {
+        passwordId
+      } = _d, options = __objRest(_d, [
+        "passwordId"
+      ]);
+      return this.constructPortalUrl("createPassword", __spreadProps(__spreadValues({}, options), {
+        pathId: passwordId
+      }));
+    });
+  }
+  getShortUrl(compressedUrl) {
+    return constructUrl({
+      base: getPortalBaseURL(this.ctx),
+      path: `/short/${compressedUrl}`
+    });
+  }
+  shortenLoginLink(link) {
+    return __async(this, null, function* () {
+      const url = yield upload(link, this.ctx.client);
+      return this.getShortUrl(url);
+    });
+  }
+  /**
+   * Generates a URL for registering a new WebAuth passkey.
+   * @deprecated
+   * @param {GetWebAuthUrlForLoginParams} opts the options object
+   * @returns - the URL for creating a new passkey
+   */
+  getWebAuthURLForLogin(opts) {
+    return __async(this, null, function* () {
+      return this.constructPortalUrl("loginAuth", opts);
+    });
+  }
+  /**
+   * Generates a URL for registering a new user password.
+   * @deprecated
+   * @param {GetWebAuthUrlForLoginParams} opts the options object
+   * @returns - the URL for creating a new password
+   */
+  getPasswordURLForLogin(opts) {
+    return __async(this, null, function* () {
+      return this.constructPortalUrl("loginPassword", opts);
+    });
+  }
+  /**
+   * Generates a URL for registering a new WebAuth passkey for a phone number.
+   * @deprecated
+   * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
+   * @returns - web auth url
+   */
+  getWebAuthURLForLoginForPhone(opts) {
+    return __async(this, null, function* () {
+      return this.constructPortalUrl("loginAuth", __spreadValues({
+        authType: "phone"
+      }, opts));
+    });
+  }
   /**
    * Gets the private key for the given wallet.
    * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
@@ -2243,7 +2384,7 @@ var _ParaCore = class _ParaCore {
   }
   populatePregenWalletAddresses() {
     return __async(this, null, function* () {
-      const res = yield this.getPregenWallets();
+      const res = yield this.getPregenWalletsV2();
       res.forEach((entity) => {
         if (this.wallets[entity.id]) {
           this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
@@ -2253,387 +2394,1253 @@ var _ParaCore = class _ParaCore {
     });
   }
   /**
-   * Resend a verification email for the current user.
+   * Checks if a user exists for an email address.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.email the email to check.
+   * @returns true if user exists, false otherwise.
    */
-  resendVerificationCode() {
-    return __async(this, null, function* () {
-      yield this.ctx.client.resendVerificationCode(__spreadValues({
-        userId: this.userId
-      }, this.getVerificationEmailProps()));
+  checkIfUserExists(_0) {
+    return __async(this, arguments, function* ({ email }) {
+      const res = yield this.ctx.client.checkUserExists({ email });
+      return res.data.exists;
     });
   }
   /**
-   * Checks if the current session is active.
-   * @returns `true` if active, `false` otherwise
+   * Checks if a user exists for a phone number.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.phone - phone number to check.
+   * @param {string} opts.countryCode - the country code.
+   * @returns true if user exists, false otherwise.
    */
-  isSessionActive() {
+  checkIfUserExistsByPhone(auth) {
     return __async(this, null, function* () {
-      if (this.externalWalletConnectionType === "CONNECTION_ONLY") {
-        return true;
-      }
-      const { isAuthenticated } = yield this.touchSession();
-      return !!isAuthenticated;
+      const res = yield this.ctx.client.checkUserExists(auth);
+      return res.data.exists;
     });
   }
   /**
-   * Checks if a session is active and a wallet exists.
-   * @returns `true` if active, `false` otherwise
-   **/
-  isFullyLoggedIn() {
-    return __async(this, null, function* () {
-      if (this.externalWalletConnectionType === "CONNECTION_ONLY") {
-        return true;
-      }
-      const isSessionActive = yield this.isSessionActive();
-      return isSessionActive && this.currentWalletIdsArray.length > 0 && this.currentWalletIdsArray.reduce((acc, [id]) => acc && !!this.wallets[id], true);
+   * Creates a new user.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.email the email to use.
+   */
+  createUser(_0) {
+    return __async(this, arguments, function* ({ email }) {
+      this.requireApiKey();
+      yield this.setEmail(email);
+      const { userId } = yield this.ctx.client.createUser(__spreadValues({
+        email: this.email
+      }, this.getVerificationEmailProps()));
+      yield this.setUserId(userId);
     });
   }
-  supportedAuthMethods(auth) {
+  /**
+   * Creates a new user with a phone number.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.phone - the phone number to use for creating the user.
+   * @param {string} opts.countryCode - the country code to use for creating the user.
+   */
+  createUserByPhone(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;
+      this.requireApiKey();
+      yield this.setPhoneNumber(auth.phone);
+      const { userId } = yield this.ctx.client.createUser(auth);
+      yield this.setUserId(userId);
     });
   }
   /**
-   * Get hints associated with the users stored biometrics.
+   * Logs in or creates a new user using an external wallet address.
    * @deprecated
-   * @returns Array containing useragents and AAGuids for stored biometrics
+   * @param {Object} opts the options object
+   * @param {string} opts.address the external wallet address to use for identification.
+   * @param {WalletType} opts.type type of external wallet to use for identification.
+   * @param {string} opts.provider the name of the provider for the external wallet.
    */
-  getUserBiometricLocationHints() {
+  externalWalletLogin(wallet) {
     return __async(this, null, function* () {
-      const { auth } = this.assertIsAuthSet();
-      return yield this.ctx.client.getBiometricLocationHints(auth);
+      this.requireApiKey();
+      const res = yield this.ctx.client.externalWalletLogin({
+        externalAddress: wallet.address,
+        type: wallet.type,
+        externalWalletProvider: wallet.provider,
+        // If the wallet isn't using full Para auth we want to track the login here
+        shouldTrackUser: !wallet.withFullParaAuth
+      });
+      yield this.setExternalWallet(wallet);
+      yield this.setUserId(res.userId);
+      return res;
     });
   }
   /**
-   * Updates the session with the user management server, possibly
-   * opening a popup to refresh the session.
-   *
-   * @param {Object} opts the options object.
-   * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
-   * @returns a URL for the user to reauthenticate.
-   **/
-  refreshSession() {
+   * Passes the email code obtained from the user for verification.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} verificationCode the six-digit code to check
+   * @returns {string} the web auth url for creating a new credential
+   */
+  verifyEmail(_0) {
+    return __async(this, arguments, function* ({ verificationCode }) {
+      yield this.ctx.client.verifyEmail(this.userId, { verificationCode });
+      return this.getSetUpBiometricsURL();
+    });
+  }
+  /** @deprecated */
+  verifyExternalWallet(_0) {
     return __async(this, arguments, function* ({
-      shouldOpenPopup = false
-    } = {}) {
-      const { sessionId } = yield this.touchSession(true);
-      if (!this.loginEncryptionKeyPair) {
-        yield this.setLoginEncryptionKeyPair();
-      }
-      const link = yield this.getLoginUrl({
-        sessionId
-      });
-      if (shouldOpenPopup) {
-        this.platformUtils.openPopup(link);
-      }
-      return link;
+      address,
+      signedMessage,
+      cosmosPublicKeyHex,
+      cosmosSigner
+    }) {
+      yield this.ctx.client.verifyExternalWallet(this.userId, { address, signedMessage, cosmosPublicKeyHex, cosmosSigner });
+      return this.getSetUpBiometricsURL();
     });
   }
   /**
-   * Call this method after login to ensure that the user ID is set
-   * internally.
-   **/
-  userSetupAfterLogin() {
-    return __async(this, null, function* () {
-      const session = yield this.touchSession();
-      yield this.setUserId(session.userId);
-      if (session.currentWalletIds && session.currentWalletIds !== this.currentWalletIds)
-        yield this.setCurrentWalletIds(session.currentWalletIds, {
-          sessionLookupId: this.isPortal() ? session.sessionLookupId : void 0
-        });
-      return session;
+   * Passes the phone code obtained from the user for verification.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} verificationCode the six-digit code to check
+   * @returns {string} the web auth url for creating a new credential
+   */
+  verifyPhone(_0) {
+    return __async(this, arguments, function* ({ verificationCode }) {
+      yield this.ctx.client.verifyPhone(this.userId, { verificationCode });
+      return this.getSetUpBiometricsURLForPhone();
     });
   }
   /**
-   * Get transmission shares associated with session.
-   * @param {Object} opts the options object.
-   * @param {boolean} opts.isForNewDevice - true if this device is registering.
-   * @returns - transmission keyshares.
-   **/
-  getTransmissionKeyShares() {
-    return __async(this, arguments, function* ({ isForNewDevice = false } = {}) {
-      const session = yield this.touchSession();
-      const sessionLookupId = isForNewDevice ? `${session.sessionLookupId}-new-device` : session.sessionLookupId;
-      return this.ctx.client.getTransmissionKeyshares(this.userId, sessionLookupId);
+   * Validates the response received from an attempted Telegram login for authenticity, then
+   * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
+   * @deprecated
+   * @param authResponse - the response JSON object received from the Telegram widget.
+   * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
+   */
+  verifyTelegram(authObject) {
+    return __async(this, null, function* () {
+      const res = yield this.ctx.client.verifyTelegram(authObject);
+      if (res.isValid) {
+        const { userId, telegramUserId } = res;
+        const { photo_url: pfpUrl, username, first_name: firstName, last_name: lastName } = authObject;
+        yield this.setAuth(
+          { telegramUserId },
+          {
+            extras: {
+              pfpUrl,
+              username,
+              displayName: firstName ? `${firstName}${lastName ? ` ${lastName}` : ""}` : username ? `@${username}` : void 0
+            },
+            userId
+          }
+        );
+        yield this.touchSession(true);
+        if (!this.loginEncryptionKeyPair) {
+          yield this.setLoginEncryptionKeyPair();
+        }
+      }
+      return res;
     });
   }
   /**
-   * Call this method after login to perform setup.
-   * @param {Object} opts the options object.
-   * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
-   * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
-   **/
-  setupAfterLogin() {
-    return __async(this, arguments, function* ({
-      temporaryShares,
-      skipSessionRefresh = false
-    } = {}) {
-      if (!temporaryShares) {
-        temporaryShares = (yield this.getTransmissionKeyShares()).data.temporaryShares;
-      }
-      temporaryShares.forEach((share) => {
-        const signer = decryptWithPrivateKey(this.loginEncryptionKeyPair.privateKey, share.encryptedShare, share.encryptedKey);
-        this.wallets[share.walletId] = {
-          id: share.walletId,
-          signer
-        };
-      });
-      yield this.deleteLoginEncryptionKeyPair();
-      yield this.populateWalletAddresses();
-      yield this.touchSession(!skipSessionRefresh);
+   * Performs 2FA verification.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.email the email to use for performing a 2FA verification.
+   * @param {string} opts.verificationCode the verification code to received via 2FA.
+   * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
+   */
+  verify2FA(_0) {
+    return __async(this, arguments, function* ({ email, verificationCode }) {
+      const res = yield this.ctx.client.verify2FA(email, verificationCode);
+      return {
+        initiatedAt: res.data.initiatedAt,
+        status: res.data.status,
+        userId: res.data.userId,
+        wallets: res.data.wallets
+      };
     });
   }
   /**
-   * Distributes a new wallet recovery share.
-   * @param {Object} opts the options object.
-   * @param {string} opts.walletId the wallet to distribute the recovery share for.
-   * @param {string} opts.userShare optional user share generate the recovery share from. Defaults to the signer from the passed in walletId
-   * @param {boolean} opts.skipBiometricShareCreation whether or not to skip biometric share creation. Used when regenerating recovery shares.
-   * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
-   * @returns {string} the recovery share.
-   **/
-  distributeNewWalletShare(_0) {
+   * Performs 2FA verification.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.phone the phone number
+   * @param {string} opts.countryCode - the country code
+   * @param {string} opts.verificationCode - verification code to received via 2FA.
+   * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
+   */
+  verify2FAForPhone(_0) {
     return __async(this, arguments, function* ({
-      walletId,
-      userShare,
-      skipBiometricShareCreation = false,
-      forceRefresh = false
+      phone,
+      verificationCode
     }) {
-      let userSigner = userShare;
-      if (!userSigner) {
-        userSigner = this.wallets[walletId].signer;
+      const res = yield this.ctx.client.verify2FAForPhone(phone, 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.
+   * @deprecated
+   * @returns {string} uri - uri to use for setting up 2FA
+   * */
+  setup2FA() {
+    return __async(this, null, function* () {
+      const res = yield this.ctx.client.setup2FA(this.userId);
+      return {
+        uri: res.data.uri
+      };
+    });
+  }
+  /**
+   * Enables 2FA.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.verificationCode - the verification code received via 2FA.
+   */
+  enable2FA(_0) {
+    return __async(this, arguments, function* ({ verificationCode }) {
+      yield this.ctx.client.enable2FA(this.userId, verificationCode);
+    });
+  }
+  /**
+   * Determines if 2FA has been set up.
+   * @deprecated
+   * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
+   */
+  check2FAStatus() {
+    return __async(this, null, function* () {
+      if (!this.userId) {
+        return { isSetup: false };
       }
-      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()
+      const res = yield this.ctx.client.check2FAStatus(this.userId);
+      return {
+        isSetup: res.data.isSetup
+      };
+    });
+  }
+  /**
+   * Resend a verification email for the current user.
+   */
+  resendVerificationCode() {
+    return __async(this, null, function* () {
+      yield this.ctx.client.resendVerificationCode(__spreadValues({
+        userId: this.userId
+      }, this.getVerificationEmailProps()));
+    });
+  }
+  /**
+   * Resend a verification SMS for the current user.
+   * @deprecated
+   */
+  resendVerificationCodeByPhone() {
+    return __async(this, null, function* () {
+      yield this.ctx.client.resendVerificationCodeByPhone({
+        userId: this.userId
       });
-      return recoveryShare;
     });
   }
-  waitForWalletAddress(walletId) {
+  /**
+   * Returns a URL for setting up a new WebAuth passkey.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.authType - the auth type to use
+   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+   * @returns {string} the URL
+   */
+  getSetUpBiometricsURL() {
+    return __async(this, arguments, function* ({
+      authType = "email",
+      isForNewDevice = false
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
+        status: PublicKeyStatus.PENDING,
+        type: PublicKeyType.WEB
+      });
+      return this.getWebAuthURLForCreate({
+        authType,
+        isForNewDevice,
+        webAuthId: res.data.id,
+        partnerId: res.data.partnerId
+      });
+    });
+  }
+  /**
+   * Returns a URL for setting up a new WebAuth passkey for a phone number.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+   * @returns {string} the URL
+   */
+  getSetUpBiometricsURLForPhone() {
+    return __async(this, arguments, function* ({
+      isForNewDevice = false
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPublicKey(this.userId, {
+        status: PublicKeyStatus.PENDING,
+        type: PublicKeyType.WEB
+      });
+      return this.getWebAuthURLForCreate({
+        authType: "phone",
+        isForNewDevice,
+        webAuthId: res.data.id,
+        partnerId: res.data.partnerId
+      });
+    });
+  }
+  /**
+   * Returns a URL for setting up a new password.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {string} opts.authType - the auth type to use
+   * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+   * @param {Theme} [opts.theme] the portal theme to use in place of the partner's default
+   * @returns {string} the URL
+   */
+  getSetupPasswordURL() {
+    return __async(this, arguments, function* ({
+      authType = "email",
+      isForNewDevice = false,
+      theme
+    } = {}) {
+      const res = yield this.ctx.client.addSessionPasswordPublicKey(this.userId, {
+        status: PasswordStatus.PENDING
+      });
+      return this.getPasswordURLForCreate({
+        authType,
+        isForNewDevice,
+        passwordId: res.data.id,
+        partnerId: res.data.partnerId,
+        theme
+      });
+    });
+  }
+  /**
+   * Checks if the current session is active.
+   * @returns `true` if active, `false` otherwise
+   */
+  isSessionActive() {
     return __async(this, null, function* () {
-      let maxPolls = 0;
-      while (true) {
-        try {
-          if (maxPolls === 10) {
+      if (this.externalWalletConnectionType === "CONNECTION_ONLY") {
+        return true;
+      }
+      const { isAuthenticated } = yield this.touchSession();
+      return !!isAuthenticated;
+    });
+  }
+  /**
+   * Checks if a session is active and a wallet exists.
+   * @returns `true` if active, `false` otherwise
+   **/
+  isFullyLoggedIn() {
+    return __async(this, null, function* () {
+      if (this.externalWalletConnectionType === "CONNECTION_ONLY") {
+        return true;
+      }
+      const isSessionActive = yield this.isSessionActive();
+      return isSessionActive && this.currentWalletIdsArray.length > 0 && this.currentWalletIdsArray.reduce((acc, [id]) => acc && !!this.wallets[id], true);
+    });
+  }
+  /** @deprecated */
+  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;
-          }
-          ++maxPolls;
-          const res = yield this.ctx.client.getWallets(this.userId);
-          const wallet = res.data.wallets.find((w) => w.id === walletId);
-          if (wallet && wallet.address) {
-            return;
-          }
-          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
-        } catch (err) {
-          console.error(err);
         }
       }
-      throw new Error("timed out waiting for wallet address");
+      return authMethods;
     });
   }
   /**
-   * Waits for a pregen wallet address to be created.
-   *
-   * @param pregenIdentifier - the identifier of the user the pregen wallet is associated with.
-   * @param walletId - the wallet id
-   * @param pregenIdentifierType - the identifier type of the user the pregen wallet is associated with.
-   * @returns - recovery share.
+   * Get hints associated with the users stored biometrics.
+   * @deprecated
+   * @returns Array containing useragents and AAGuids for stored biometrics
+   */
+  getUserBiometricLocationHints() {
+    return __async(this, null, function* () {
+      const { auth } = this.assertIsAuthSet();
+      return yield this.ctx.client.getBiometricLocationHints(auth);
+    });
+  }
+  /**
+   * Initiates a login.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {String} opts.email - the email to login with
+   * @param {boolean} opts.useShortURL - whether to shorten the link
+   * @returns - the WebAuth URL for logging in
    **/
-  waitForPregenWalletAddress(walletId) {
+  initiateUserLogin(_e) {
     return __async(this, null, function* () {
-      let maxPolls = 0;
-      while (true) {
+      var _f = _e, { useShortUrl = false } = _f, auth = __objRest(_f, ["useShortUrl"]);
+      const authInfo = yield this.setAuth(auth);
+      if (!authInfo) {
+        return;
+      }
+      const { partnerId, sessionId } = yield this.touchSession(true);
+      if (!this.loginEncryptionKeyPair) {
+        yield this.setLoginEncryptionKeyPair();
+      }
+      const webAuthLoginURL = yield this.getWebAuthURLForLogin({
+        authType: authInfo.authType,
+        sessionId,
+        partnerId,
+        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair)
+      });
+      if (!useShortUrl) {
+        return webAuthLoginURL;
+      }
+      return this.shortenLoginLink(webAuthLoginURL);
+    });
+  }
+  /**
+   * Initiates a login.
+   * @deprecated
+   * @param email - the email to login with
+   * @returns - a set of supported auth methods for the user
+   **/
+  initiateUserLoginV2(auth) {
+    return __async(this, null, function* () {
+      let authInfo = __privateGet(this, _authInfo);
+      if (!authInfo || JSON.stringify(authInfo.auth) !== JSON.stringify(auth)) {
+        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.
+   * @deprecated
+   * @param opts the options object
+   * @param opts.phone the phone number
+   * @param opts.countryCode the country code
+   * @param opts.useShortURL - whether to shorten the link
+   * @returns - the WebAuth URL for logging in
+   **/
+  initiateUserLoginForPhone(_g) {
+    return __async(this, null, function* () {
+      var _h = _g, {
+        useShortUrl = false
+      } = _h, auth = __objRest(_h, [
+        "useShortUrl"
+      ]);
+      yield this.setAuth(auth);
+      const { sessionId, partnerId } = yield this.touchSession(true);
+      if (!this.loginEncryptionKeyPair) {
+        yield this.setLoginEncryptionKeyPair();
+      }
+      const webAuthLoginURL = yield this.getWebAuthURLForLoginForPhone({
+        sessionId,
+        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair),
+        partnerId
+      });
+      if (!useShortUrl) {
+        return webAuthLoginURL;
+      }
+      return this.shortenLoginLink(webAuthLoginURL);
+    });
+  }
+  /**
+   * @deprecated
+   * Waits for the session to be active.
+   **/
+  waitForAccountCreation() {
+    return __async(this, arguments, function* ({ popupWindow } = {}) {
+      yield this.touchSession();
+      if (!this.isExternalWalletAuth) {
+        this.externalWallets = {};
+      }
+      this.isAwaitingAccountCreation = true;
+      while (this.isAwaitingAccountCreation) {
         try {
-          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, POLLING_INTERVAL_MS));
+          if (yield this.isSessionActive()) {
+            this.isAwaitingAccountCreation = false;
+            dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
+            return true;
+          } else {
+            if (popupWindow == null ? void 0 : popupWindow.closed) {
+              this.isAwaitingAccountCreation = false;
+              return false;
+            }
           }
-          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
         } catch (err) {
           console.error(err);
         }
       }
-      throw new Error("timed out waiting for wallet address");
+      return false;
+    });
+  }
+  /**
+   * @deprecated
+   */
+  waitForPasskeyAndCreateWallet() {
+    return __async(this, arguments, function* ({
+      popupWindow
+    } = {}) {
+      yield this.waitForAccountCreation({ popupWindow });
+      const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
+      const pregenWallets = yield this.getPregenWalletsV2();
+      let recoverySecret, walletIds = {};
+      if (pregenWallets.length > 0) {
+        recoverySecret = yield this.claimPregenWallets();
+        walletIds = 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.
+   * @deprecated
+   * @return {string} the Farcaster connect URI
+   */
+  getFarcasterConnectURL() {
+    return __async(this, null, function* () {
+      yield this.logout();
+      yield this.touchSession(true);
+      const {
+        data: { connect_uri }
+      } = yield this.ctx.client.initializeFarcasterLogin();
+      return connect_uri;
+    });
+  }
+  /**
+   * Awaits the response from a user's attempt to log in with Farcaster.
+   * If successful, this returns the user's Farcaster username and profile picture and indicates whether the user already exists.
+   * @deprecated
+   * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
+   */
+  waitForFarcasterStatus() {
+    return __async(this, null, function* () {
+      this.isAwaitingFarcaster = true;
+      while (this.isAwaitingFarcaster) {
+        try {
+          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+          const res = yield this.ctx.client.getFarcasterAuthStatus();
+          if (res.data.state === "completed") {
+            const { userId, userExists, username, pfpUrl } = res.data;
+            yield this.setAuth(
+              { farcasterUsername: username },
+              { extras: { pfpUrl, username, displayName: username }, userId }
+            );
+            return {
+              userId,
+              userExists,
+              username,
+              pfpUrl
+            };
+          }
+        } catch (err) {
+          console.error(err);
+          this.isAwaitingFarcaster = false;
+        }
+      }
+    });
+  }
+  /**
+   * Generates a URL for the user to log in with OAuth using a desire method.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {OAuthMethod} opts.method the third-party service to use for OAuth.
+   * @param {string} [opts.deeplinkUrl] the deeplink to redirect to after the OAuth flow. This is for mobile only.
+   * @returns {string} the URL for the user to log in with OAuth.
+   */
+  getOAuthURL(_0) {
+    return __async(this, arguments, function* ({ method, deeplinkUrl }) {
+      yield this.logout();
+      const { sessionLookupId } = 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,
+          deeplinkUrl
+        }
+      });
+    });
+  }
+  /**
+   * Awaits the response from a user's attempt to log in with OAuth.
+   * If successful, this returns the user's email address and indicates whether the user already exists.
+   * @deprecated
+   * @param {Object} opts the options object.
+   * @param {Window} [opts.popupWindow] the popup window being used for login.
+   * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
+   */
+  waitForOAuth() {
+    return __async(this, arguments, function* ({ popupWindow } = {}) {
+      this.isAwaitingOAuth = true;
+      while (this.isAwaitingOAuth) {
+        try {
+          if (popupWindow == null ? void 0 : popupWindow.closed) {
+            return { isError: true, userExists: false };
+          }
+          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+          if (this.isAwaitingOAuth) {
+            const { userId, email } = yield this.touchSession();
+            if (!!userId) {
+              if (!this.loginEncryptionKeyPair) {
+                yield this.setLoginEncryptionKeyPair();
+              }
+              yield this.setUserId(userId);
+              yield this.setEmail(email);
+              this.isAwaitingOAuth = false;
+              return {
+                userExists: true,
+                email
+              };
+            }
+          }
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      return { userExists: false };
+    });
+  }
+  /**
+   * Waits for the session to be active and sets up the user.
+   * @deprecated
+   * @param {Object} opts the options object
+   * @param {Window} [opts.popupWindow] the popup window being used for login.
+   * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
+   * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
+   **/
+  waitForLoginAndSetup() {
+    return __async(this, arguments, function* ({
+      popupWindow,
+      skipSessionRefresh = false
+    } = {}) {
+      var _a;
+      if (!this.isExternalWalletAuth) {
+        this.externalWallets = {};
+      }
+      this.isAwaitingLogin = true;
+      while (this.isAwaitingLogin) {
+        let session;
+        try {
+          yield new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+          session = yield this.touchSession();
+          if (!session.isAuthenticated) {
+            if (popupWindow == null ? void 0 : popupWindow.closed) {
+              const resp2 = { isComplete: false, isError: true };
+              dispatchEvent(ParaEvent.LOGIN_EVENT, resp2, "failed to setup user");
+              return resp2;
+            }
+            continue;
+          }
+          session = yield this.userSetupAfterLogin();
+          const needsWallet = (_a = session.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: session.partnerId
+            };
+            dispatchEvent(ParaEvent.LOGIN_EVENT, resp2);
+            return resp2;
+          }
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      const resp = { isComplete: false };
+      dispatchEvent(ParaEvent.LOGIN_EVENT, resp, "exitted login without setting up user");
+      return resp;
+    });
+  }
+  /**
+   * Updates the session with the user management server, possibly
+   * opening a popup to refresh the session.
+   *
+   * @param {Object} opts the options object.
+   * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
+   * @returns a URL for the user to reauthenticate.
+   **/
+  refreshSession() {
+    return __async(this, arguments, function* ({
+      shouldOpenPopup = false
+    } = {}) {
+      const { sessionId } = yield this.touchSession(true);
+      if (!this.loginEncryptionKeyPair) {
+        yield this.setLoginEncryptionKeyPair();
+      }
+      const link = yield this.getWebAuthURLForLogin({
+        sessionId,
+        loginEncryptionPublicKey: getPublicKeyHex(this.loginEncryptionKeyPair)
+      });
+      if (shouldOpenPopup) {
+        this.platformUtils.openPopup(link);
+      }
+      return link;
+    });
+  }
+  /**
+   * Call this method after login to ensure that the user ID is set
+   * internally.
+   **/
+  userSetupAfterLogin() {
+    return __async(this, null, function* () {
+      const session = yield this.touchSession();
+      yield this.setUserId(session.userId);
+      if (session.currentWalletIds && session.currentWalletIds !== this.currentWalletIds)
+        yield this.setCurrentWalletIds(session.currentWalletIds, {
+          sessionLookupId: this.isPortal() ? session.sessionLookupId : void 0
+        });
+      return session;
+    });
+  }
+  /**
+   * Get transmission shares associated with session.
+   * @param {Object} opts the options object.
+   * @param {boolean} opts.isForNewDevice - true if this device is registering.
+   * @returns - transmission keyshares.
+   **/
+  getTransmissionKeyShares() {
+    return __async(this, arguments, function* ({ isForNewDevice = false } = {}) {
+      const session = yield this.touchSession();
+      const sessionLookupId = isForNewDevice ? `${session.sessionLookupId}-new-device` : session.sessionLookupId;
+      return this.ctx.client.getTransmissionKeyshares(this.userId, sessionLookupId);
+    });
+  }
+  /**
+   * Call this method after login to perform setup.
+   * @param {Object} opts the options object.
+   * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
+   * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
+   **/
+  setupAfterLogin() {
+    return __async(this, arguments, function* ({
+      temporaryShares,
+      skipSessionRefresh = false
+    } = {}) {
+      if (!temporaryShares) {
+        temporaryShares = (yield this.getTransmissionKeyShares()).data.temporaryShares;
+      }
+      temporaryShares.forEach((share) => {
+        const signer = decryptWithPrivateKey(this.loginEncryptionKeyPair.privateKey, share.encryptedShare, share.encryptedKey);
+        this.wallets[share.walletId] = {
+          id: share.walletId,
+          signer
+        };
+      });
+      yield this.deleteLoginEncryptionKeyPair();
+      yield this.populateWalletAddresses();
+      yield this.touchSession(!skipSessionRefresh);
+    });
+  }
+  /**
+   * Distributes a new wallet recovery share.
+   * @param {Object} opts the options object.
+   * @param {string} opts.walletId the wallet to distribute the recovery share for.
+   * @param {string} opts.userShare optional user share generate the recovery share from. Defaults to the signer from the passed in walletId
+   * @param {boolean} opts.skipBiometricShareCreation whether or not to skip biometric share creation. Used when regenerating recovery shares.
+   * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
+   * @returns {string} the recovery share.
+   **/
+  distributeNewWalletShare(_0) {
+    return __async(this, arguments, function* ({
+      walletId,
+      userShare,
+      skipBiometricShareCreation = false,
+      forceRefresh = false
+    }) {
+      let userSigner = userShare;
+      if (!userSigner) {
+        userSigner = this.wallets[walletId].signer;
+      }
+      const recoveryShare = skipBiometricShareCreation ? yield sendRecoveryForShare({
+        ctx: this.ctx,
+        userId: this.userId,
+        walletId,
+        userSigner,
+        emailProps: this.getBackupKitEmailProps(),
+        forceRefresh
+      }) : yield distributeNewShare({
+        ctx: this.ctx,
+        userId: this.userId,
+        walletId,
+        userShare: userSigner,
+        emailProps: this.getBackupKitEmailProps()
+      });
+      return recoveryShare;
+    });
+  }
+  waitForWalletAddress(walletId) {
+    return __async(this, null, function* () {
+      let maxPolls = 0;
+      while (true) {
+        try {
+          if (maxPolls === 10) {
+            break;
+          }
+          ++maxPolls;
+          const res = yield this.ctx.client.getWallets(this.userId);
+          const wallet = res.data.wallets.find((w) => w.id === walletId);
+          if (wallet && wallet.address) {
+            return;
+          }
+          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      throw new Error("timed out waiting for wallet address");
+    });
+  }
+  /**
+   * Waits for a pregen wallet address to be created.
+   *
+   * @param pregenIdentifier - the identifier of the user the pregen wallet is associated with.
+   * @param walletId - the wallet id
+   * @param pregenIdentifierType - the identifier type of the user the pregen wallet is associated with.
+   * @returns - recovery share.
+   **/
+  waitForPregenWalletAddress(walletId) {
+    return __async(this, null, function* () {
+      let maxPolls = 0;
+      while (true) {
+        try {
+          if (maxPolls === 10) {
+            break;
+          }
+          ++maxPolls;
+          const res = yield this.getPregenWalletsV2();
+          const wallet = res.find((w) => w.id === walletId);
+          if (wallet && wallet.address) {
+            return;
+          }
+          yield new Promise((resolve) => setTimeout(resolve, SHORT_POLLING_INTERVAL_MS));
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      throw new Error("timed out waiting for wallet address");
+    });
+  }
+  /**
+   * Creates several new wallets with the desired types. If no types are provided, this method
+   * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
+   * object that are not already present. This is automatically called upon account creation to ensure that
+   * the user has a wallet of each required type.
+   *
+   * @param {Object} [opts] the options object.
+   * @param {boolean} [opts.skipDistribute] if `true`, the wallets' recovery share will not be distributed.
+   * @param {WalletType[]} [opts.types] the types of wallets to create.
+   * @returns {Object} the wallets created, their ids, and the recovery secret.
+   **/
+  createWalletPerType() {
+    return __async(this, arguments, function* ({
+      skipDistribute = false,
+      types
+    } = {}) {
+      const wallets = [];
+      const walletIds = {};
+      let recoverySecret;
+      for (const type of yield this.getTypesToCreate(types)) {
+        const [wallet, recoveryShare] = yield this.createWallet({ type, skipDistribute });
+        wallets.push(wallet);
+        getEquivalentTypes(type).filter((t) => !!this.isWalletTypeEnabled[t]).forEach((t) => {
+          walletIds[t] = [wallet.id];
+        });
+        if (recoveryShare) {
+          recoverySecret = recoveryShare;
+        }
+      }
+      return { wallets, walletIds, recoverySecret };
+    });
+  }
+  /**
+   * Refresh the current user share for a wallet.
+   *
+   * @param {Object} opts the options object.
+   * @param {string} opts.walletId the wallet id to refresh.
+   * @param {string} opts.share the current user share.
+   * @param {string} [opts.oldPartnerId] the current partner id.
+   * @param {string} [opts.newPartnerId] the new partner id to set, if any.
+   * @param {string} [opts.keyShareProtocolId]
+   * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
+   * @returns {Object} the new user share and recovery secret.
+   **/
+  refreshShare(_0) {
+    return __async(this, arguments, function* ({
+      walletId,
+      share,
+      oldPartnerId,
+      newPartnerId,
+      keyShareProtocolId,
+      redistributeBackupEncryptedShares
+    }) {
+      const { signer, protocolId } = yield this.platformUtils.refresh(
+        this.ctx,
+        this.retrieveSessionCookie(),
+        this.userId,
+        walletId,
+        share,
+        oldPartnerId,
+        newPartnerId,
+        keyShareProtocolId
+      );
+      const recoverySecret = yield distributeNewShare({
+        ctx: this.ctx,
+        userId: this.userId,
+        walletId,
+        userShare: signer,
+        ignoreRedistributingBackupEncryptedShare: !redistributeBackupEncryptedShares,
+        emailProps: this.getBackupKitEmailProps(),
+        partnerId: newPartnerId,
+        protocolId
+      });
+      return { signer, recoverySecret, protocolId };
+    });
+  }
+  /**
+   * Creates a new wallet.
+   * @param {Object} opts the options object.
+   * @param {WalletType} opts.type the type of wallet to create.
+   * @param {boolean} opts.skipDistribute - if true, recovery share will not be distributed.
+   * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
+   **/
+  createWallet() {
+    return __async(this, arguments, function* ({
+      type: _type,
+      skipDistribute = false
+    } = {}) {
+      var _a, _b;
+      this.requireApiKey();
+      const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
+      const walletType = yield this.assertIsValidWalletType(
+        _type != null ? _type : (_a = 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;
+        }
+      }
+      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()
+        });
+      }
+      yield this.setCurrentWalletIds(__spreadProps(__spreadValues({}, this.currentWalletIds), {
+        [walletType]: [.../* @__PURE__ */ new Set([...(_b = this.currentWalletIds[walletType]) != null ? _b : [], walletId])]
+      }));
+      const walletNoSigner = __spreadValues({}, wallet);
+      delete walletNoSigner.signer;
+      dispatchEvent(ParaEvent.WALLET_CREATED, {
+        wallet: walletNoSigner,
+        recoverySecret: recoveryShare
+      });
+      return [wallet, recoveryShare];
+    });
+  }
+  /**
+   * Creates a new pregenerated wallet.
+   * @deprecated
+   * @param {Object} opts the options object.
+   * @param {string} opts.pregenIdentifier the identifier associated with the new wallet.
+   * @param {TPregenIdentifierType} [opts.pregenIdentifierType] the identifier type. Defaults to `EMAIL`.
+   * @param {WalletType} [opts.type] the type of wallet to create. Defaults to the first non-optional type in the instance's `supportedWalletTypes` array.
+   * @returns {Wallet} the created wallet.
+   **/
+  createPregenWallet(opts) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
+      const {
+        type: _type = (_a = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type,
+        pregenIdentifier,
+        pregenIdentifierType = "EMAIL"
+      } = opts;
+      this.requireApiKey();
+      const walletType = yield this.assertIsValidWalletType(
+        _type != null ? _type : (_b = 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.
+   * If no types are provided, this method will create one for each of the non-optional types
+   * specified in the instance's `supportedWalletTypes` array that are not already present.
+   * @deprecated
+   * @param {Object} opts the options object.
+   * @param {string} opts.pregenIdentifier the identifier to associate each wallet with.
+   * @param {TPregenIdentifierType} opts.pregenIdentifierType - either `'EMAIL'` or `'PHONE'`.
+   * @param {WalletType[]} [opts.types] the wallet types to create. Defaults to any types the instance supports that are not already present.
+   * @returns {Wallet[]} an array containing the created wallets.
+   **/
+  createPregenWalletPerType(_0) {
+    return __async(this, arguments, function* ({
+      types,
+      pregenIdentifier,
+      pregenIdentifierType = "EMAIL"
+    }) {
+      const wallets = [];
+      for (const type of yield this.getTypesToCreate(types)) {
+        const wallet = yield this.createPregenWallet({ type, pregenIdentifier, pregenIdentifierType });
+        wallets.push(wallet);
+      }
+      return wallets;
+    });
+  }
+  /**
+   * Claims a pregenerated wallet.
+   * @deprecated
+   * @param {Object} opts the options object.
+   * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+   * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the identifier of the user claiming the wallet
+   * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
+   **/
+  claimPregenWallets() {
+    return __async(this, arguments, function* ({
+      pregenIdentifier,
+      pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
+    } = {}) {
+      var _a;
+      this.requireApiKey();
+      const pregenWallets = pregenIdentifier && pregenIdentifierType ? yield this.getPregenWallets({ pregenIdentifier, pregenIdentifierType }) : yield this.getPregenWallets();
+      if (pregenWallets.length === 0) {
+        return void 0;
+      }
+      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,
+          pregenIdentifier: void 0,
+          pregenIdentifierType: void 0
+        });
+        const walletNoSigner = __spreadValues({}, this.wallets[wallet.id]);
+        delete walletNoSigner.signer;
+        dispatchEvent(ParaEvent.PREGEN_WALLET_CLAIMED, {
+          wallet: walletNoSigner,
+          recoverySecret: newRecoverySecret
+        });
+      }
+      yield this.setWallets(this.wallets);
+      return newRecoverySecret;
     });
   }
   /**
-   * Creates several new wallets with the desired types. If no types are provided, this method
-   * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
-   * object that are not already present. This is automatically called upon account creation to ensure that
-   * the user has a wallet of each required type.
-   *
-   * @param {Object} [opts] the options object.
-   * @param {boolean} [opts.skipDistribute] if `true`, the wallets' recovery share will not be distributed.
-   * @param {WalletType[]} [opts.types] the types of wallets to create.
-   * @returns {Object} the wallets created, their ids, and the recovery secret.
+   * Updates the identifier for a pregen wallet.
+   * @deprecated
+   * @param {Object} opts the options object.
+   * @param {string} opts.walletId the pregen wallet ID
+   * @param {string} opts.newPregenIdentifier the new identtifier
+   * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
    **/
-  createWalletPerType() {
+  updatePregenWalletIdentifier(_0) {
     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];
+      walletId,
+      newPregenIdentifier,
+      newPregenIdentifierType
+    }) {
+      this.requireApiKey();
+      yield this.ctx.client.updatePregenWallet(walletId, {
+        pregenIdentifier: newPregenIdentifier,
+        pregenIdentifierType: newPregenIdentifierType
+      });
+      if (!!this.wallets[walletId]) {
+        this.wallets[walletId] = __spreadProps(__spreadValues({}, this.wallets[walletId]), {
+          pregenIdentifier: newPregenIdentifier,
+          pregenIdentifierType: newPregenIdentifierType
         });
-        if (recoveryShare) {
-          recoverySecret = recoveryShare;
-        }
+        yield this.setWallets(this.wallets);
       }
-      return { wallets, walletIds, recoverySecret };
     });
   }
   /**
-   * Refresh the current user share for a wallet.
-   *
+   * Checks if a pregen Wallet exists for the given identifier with the current partner.
+   * @deprecated
    * @param {Object} opts the options object.
-   * @param {string} opts.walletId the wallet id to refresh.
-   * @param {string} opts.share the current user share.
-   * @param {string} [opts.oldPartnerId] the current partner id.
-   * @param {string} [opts.newPartnerId] the new partner id to set, if any.
-   * @param {string} [opts.keyShareProtocolId]
-   * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
-   * @returns {Object} the new user share and recovery secret.
+   * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+   * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
+   * @returns {boolean} whether the pregen wallet exists
    **/
-  refreshShare(_0) {
+  hasPregenWallet(_0) {
     return __async(this, arguments, function* ({
-      walletId,
-      share,
-      oldPartnerId,
-      newPartnerId,
-      keyShareProtocolId,
-      redistributeBackupEncryptedShares
+      pregenIdentifier,
+      pregenIdentifierType
     }) {
-      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 };
+      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;
     });
   }
   /**
-   * Creates a new wallet.
+   * Get pregen wallets for the given identifier.
+   * @deprecated
    * @param {Object} opts the options object.
-   * @param {WalletType} opts.type the type of wallet to create.
-   * @param {boolean} opts.skipDistribute - if true, recovery share will not be distributed.
-   * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
+   * @param {string} opts.pregenIdentifier - the identifier of the user claiming the wallet
+   * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
+   * @returns {Promise<WalletEntity[]>} the array of found wallets
    **/
-  createWallet() {
+  getPregenWallets() {
     return __async(this, arguments, function* ({
-      type: _type,
-      skipDistribute = false
+      pregenIdentifier,
+      pregenIdentifierType = !!pregenIdentifier ? "EMAIL" : void 0
     } = {}) {
-      var _a, _b;
       this.requireApiKey();
-      const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
-      const walletType = yield this.assertIsValidWalletType(
-        _type != null ? _type : (_a = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type
+      const res = yield this.ctx.client.getPregenWallets(
+        pregenIdentifier && pregenIdentifierType ? { [pregenIdentifierType]: [pregenIdentifier] } : this.pregenIds,
+        this.isPortal(),
+        this.userId
       );
-      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;
-        }
-      }
-      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()
-        });
-      }
-      yield this.setCurrentWalletIds(__spreadProps(__spreadValues({}, this.currentWalletIds), {
-        [walletType]: [.../* @__PURE__ */ new Set([...(_b = this.currentWalletIds[walletType]) != null ? _b : [], walletId])]
-      }));
-      const walletNoSigner = __spreadValues({}, wallet);
-      delete walletNoSigner.signer;
-      dispatchEvent(ParaEvent.WALLET_CREATED, {
-        wallet: walletNoSigner,
-        recoverySecret: recoveryShare
-      });
-      return [wallet, recoveryShare];
+      return res.wallets.filter((w) => this.isWalletSupported(entityToWallet(w)));
     });
   }
   encodeWalletBase64(wallet) {
@@ -2671,7 +3678,9 @@ var _ParaCore = class _ParaCore {
   }
   getTransactionReviewUrl(transactionId, timeoutMs) {
     return __async(this, null, function* () {
+      const { id: partnerId } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
       return this.constructPortalUrl("txReview", {
+        partnerId,
         pathId: transactionId,
         params: {
           email: this.email,
@@ -2680,18 +3689,19 @@ var _ParaCore = class _ParaCore {
       });
     });
   }
-  getOnRampTransactionUrl(_a) {
+  getOnRampTransactionUrl(_i) {
     return __async(this, null, function* () {
-      var _b = _a, {
+      var _j = _i, {
         purchaseId,
         providerKey
-      } = _b, walletParams = __objRest(_b, [
+      } = _j, walletParams = __objRest(_j, [
         "purchaseId",
         "providerKey"
       ]);
-      const { sessionId } = yield this.touchSession();
+      const { partnerId, sessionId } = yield this.touchSession();
       const [key, identifier] = extractWalletRef(walletParams);
       return this.constructPortalUrl("onRamp", {
+        partnerId,
         pathId: purchaseId,
         sessionId,
         params: {
@@ -2894,6 +3904,44 @@ var _ParaCore = class _ParaCore {
       return signRes;
     });
   }
+  /**
+   * @deprecated
+   * Sends a transaction.
+   * @param walletId - id of the wallet to send the transaction from.
+   * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
+   * @param chainId - chain id of the chain the transaction is being sent on.
+   **/
+  sendTransaction(_0) {
+    return __async(this, arguments, function* ({
+      walletId,
+      rlpEncodedTxBase64,
+      chainId
+    }) {
+      this.assertIsValidWalletId(walletId);
+      const wallet = this.wallets[walletId];
+      const signRes = yield this.platformUtils.sendTransaction(
+        this.ctx,
+        this.userId,
+        walletId,
+        this.wallets[walletId].signer,
+        rlpEncodedTxBase64,
+        chainId,
+        this.retrieveSessionCookie(),
+        wallet.scheme === WalletScheme2.DKLS
+      );
+      if (signRes.pendingTransactionId) {
+        this.platformUtils.openPopup(
+          yield this.getTransactionReviewUrl(signRes.pendingTransactionId),
+          { type: "SIGN_TRANSACTION_REVIEW" /* SIGN_TRANSACTION_REVIEW */ }
+        );
+        const error = new TransactionReviewError(
+          yield this.getTransactionReviewUrl(signRes.pendingTransactionId)
+        );
+        throw error;
+      }
+      return signRes;
+    });
+  }
   isProviderModalDisabled() {
     return !!this.disableProviderModal;
   }
@@ -2990,36 +4038,36 @@ var _ParaCore = class _ParaCore {
   /**
    * @deprecated
    */
-  // protected exitAccountCreation() {
-  //   this.isAwaitingAccountCreation = false;
-  // }
+  exitAccountCreation() {
+    this.isAwaitingAccountCreation = false;
+  }
   /**
    * @deprecated
    */
-  // protected exitLogin() {
-  //   this.isAwaitingLogin = false;
-  // }
+  exitLogin() {
+    this.isAwaitingLogin = false;
+  }
   /**
    * @deprecated
    */
-  // protected exitFarcaster() {
-  //   this.isAwaitingFarcaster = false;
-  // }
+  exitFarcaster() {
+    this.isAwaitingFarcaster = false;
+  }
   /**
    * @deprecated
    */
-  // protected exitOAuth() {
-  //   this.isAwaitingOAuth = false;
-  // }
+  exitOAuth() {
+    this.isAwaitingOAuth = false;
+  }
   /**
    * @deprecated
    */
-  // protected exitLoops() {
-  //   this.exitAccountCreation();
-  //   this.exitLogin();
-  //   this.exitFarcaster();
-  //   this.exitOAuth();
-  // }
+  exitLoops() {
+    this.exitAccountCreation();
+    this.exitLogin();
+    this.exitFarcaster();
+    this.exitOAuth();
+  }
   /**
    * Retrieves a token to verify the current session.
    * @returns {Promise<string>} the ID
@@ -3117,13 +4165,13 @@ var _ParaCore = class _ParaCore {
     return `Para ${JSON.stringify(obj, null, 2)}`;
   }
   /** NEW METHODS */
-  getNewCredentialAndUrl() {
+  getNewCredentialAndUrl(_0) {
     return __async(this, arguments, function* ({
       authMethod = "PASSKEY",
       isForNewDevice = false,
       portalTheme,
       shorten = false
-    } = {}) {
+    }) {
       this.assertIsAuthSet();
       let credentialId, urlType;
       switch (authMethod) {
@@ -3145,7 +4193,7 @@ var _ParaCore = class _ParaCore {
           urlType = "createPassword";
           break;
       }
-      const url = yield this.constructPortalUrl(urlType, {
+      const url = yield this.constructPortalUrlV2(urlType, {
         isForNewDevice,
         pathId: credentialId,
         portalTheme,
@@ -3154,15 +4202,7 @@ var _ParaCore = class _ParaCore {
       return { credentialId, url };
     });
   }
-  /**
-   * Returns a Para Portal URL for logging in with a WebAuth passkey or a password.
-   * @param {Object} opts the options object
-   * @param {String} opts.auth - the user auth to sign up or log in with, in the form ` { email: string } | { phone: `+${number}` } `
-   * @param {boolean} opts.useShortUrls - whether to shorten the generated portal URLs
-   * @param {Theme} opts.portalTheme the Para Portal theme to apply to the password creation URL, if other than the default theme
-   * @returns {SignUpOrLogInResponse} an object in the form of either: `{ stage: 'verify' }` or `{ stage: 'login'; passkeyUrl?: string; passwordUrl?: string; biometricHints?: BiometricLocationHint[] }`
-   */
-  getLoginUrl(_0) {
+  getLoginUrlV2(_0) {
     return __async(this, arguments, function* ({
       authMethod = "PASSKEY",
       shorten = false,
@@ -3184,14 +4224,14 @@ var _ParaCore = class _ParaCore {
         default:
           throw new Error(`invalid authentication method: '${authMethod}'`);
       }
-      return this.constructPortalUrl(urlType, {
+      return this.constructPortalUrlV2(urlType, {
         sessionId,
         shorten,
         portalTheme
       });
     });
   }
-  getOAuthUrl(_0) {
+  getOAuthUrlV2(_0) {
     return __async(this, arguments, function* ({ method, deeplinkUrl }) {
       yield this.logout();
       const { sessionLookupId } = yield this.touchSession(true);
@@ -3206,18 +4246,22 @@ var _ParaCore = class _ParaCore {
       });
     });
   }
-  signUpOrLogIn(_c) {
+  signUpOrLogInV2(_k) {
     return __async(this, null, function* () {
-      var _d = _c, { auth } = _d, urlOptions = __objRest(_d, ["auth"]);
+      var _l = _k, {
+        auth
+      } = _l, urlOptions = __objRest(_l, [
+        "auth"
+      ]);
       const serverAuthState = yield this.ctx.client.signUpOrLogIn(__spreadValues(__spreadValues({}, auth), this.getVerificationEmailProps()));
       return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
     });
   }
-  verifyNewAccount(_e) {
+  verifyNewAccountV2(_m) {
     return __async(this, null, function* () {
-      var _f = _e, {
+      var _n = _m, {
         verificationCode
-      } = _f, urlOptions = __objRest(_f, [
+      } = _n, urlOptions = __objRest(_n, [
         "verificationCode"
       ]);
       this.assertIsAuthSet(["email", "phone"]);
@@ -3228,16 +4272,16 @@ var _ParaCore = class _ParaCore {
       return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
     });
   }
-  verifyOAuth(_g) {
+  verifyOAuthV2(_o) {
     return __async(this, null, function* () {
-      var _h = _g, {
+      var _p = _o, {
         method,
         deeplinkUrl,
         isCanceled = () => false,
         onCancel,
         onPoll,
         onOAuthUrl
-      } = _h, urlOptions = __objRest(_h, [
+      } = _p, urlOptions = __objRest(_p, [
         "method",
         "deeplinkUrl",
         "isCanceled",
@@ -3281,14 +4325,14 @@ var _ParaCore = class _ParaCore {
       });
     });
   }
-  verifyFarcaster(_i) {
+  verifyFarcasterV2(_q) {
     return __async(this, null, function* () {
-      var _j = _i, {
+      var _r = _q, {
         isCanceled = () => false,
         onConnectUri,
         onCancel,
         onPoll
-      } = _j, urlOptions = __objRest(_j, [
+      } = _r, urlOptions = __objRest(_r, [
         "isCanceled",
         "onConnectUri",
         "onCancel",
@@ -3308,7 +4352,7 @@ var _ParaCore = class _ParaCore {
                 return reject("canceled");
               }
               yield new Promise((_resolve) => setTimeout(_resolve, POLLING_INTERVAL_MS));
-              const serverAuthState = yield this.ctx.client.getFarcasterAuthStatus();
+              const serverAuthState = yield this.ctx.client.getFarcasterAuthStatusV2();
               if (isServerAuthState(serverAuthState)) {
                 const authState = yield __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
                 return resolve(authState);
@@ -3329,15 +4373,15 @@ 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[] }`
    */
-  verifyTelegram(_k) {
+  verifyTelegramV2(_s) {
     return __async(this, null, function* () {
-      var _l = _k, {
+      var _t = _s, {
         telegramAuthResponse
-      } = _l, urlOptions = __objRest(_l, [
+      } = _t, urlOptions = __objRest(_t, [
         "telegramAuthResponse"
       ]);
       try {
-        const serverAuthState = yield this.ctx.client.verifyTelegram(telegramAuthResponse);
+        const serverAuthState = yield this.ctx.client.verifyTelegramV2(telegramAuthResponse);
         return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
       } catch (e) {
         throw new Error(e.message);
@@ -3352,7 +4396,7 @@ 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
    **/
-  waitForLogin() {
+  waitForLoginV2() {
     return __async(this, arguments, function* ({
       isCanceled = () => false,
       onCancel,
@@ -3391,7 +4435,7 @@ var _ParaCore = class _ParaCore {
               const tempSharesRes = yield this.getTransmissionKeyShares();
               if (tempSharesRes.data.temporaryShares.length === fetchedWallets.length) {
                 yield this.setupAfterLogin({ temporaryShares: tempSharesRes.data.temporaryShares, skipSessionRefresh });
-                yield this.claimPregenWallets();
+                yield this.claimPregenWalletsV2();
                 const resp = {
                   needsWallet: needsWallet || Object.values(this.wallets).length === 0,
                   partnerId: session.partnerId
@@ -3409,7 +4453,7 @@ var _ParaCore = class _ParaCore {
       });
     });
   }
-  waitForSignup(_0) {
+  waitForSignupV2(_0) {
     return __async(this, arguments, function* ({
       isCanceled = () => false,
       onCancel,
@@ -3444,17 +4488,17 @@ var _ParaCore = class _ParaCore {
       });
     });
   }
-  waitForWalletCreation() {
+  waitForWalletCreationV2() {
     return __async(this, arguments, function* ({
       isCanceled = () => false,
       onCancel
     } = {}) {
-      yield this.waitForSignup({ isCanceled, onCancel });
+      yield this.waitForSignupV2({ isCanceled, onCancel });
       const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
-      const pregenWallets = yield this.getPregenWallets();
+      const pregenWallets = yield this.getPregenWalletsV2();
       let recoverySecret, walletIds = {};
       if (pregenWallets.length > 0) {
-        recoverySecret = yield this.claimPregenWallets();
+        recoverySecret = yield this.claimPregenWalletsV2();
         walletIds = supportedWalletTypes.reduce((acc, { type }) => {
           var _a;
           return __spreadProps(__spreadValues({}, acc), {
@@ -3470,32 +4514,32 @@ var _ParaCore = class _ParaCore {
       return resp;
     });
   }
-  loginExternalWallet(_m) {
+  loginExternalWalletV2(_u) {
     return __async(this, null, function* () {
-      var _n = _m, {
+      var _v = _u, {
         externalWallet
-      } = _n, urlOptions = __objRest(_n, [
+      } = _v, urlOptions = __objRest(_v, [
         "externalWallet"
       ]);
       this.requireApiKey();
-      const serverAuthState = yield this.ctx.client.loginExternalWallet({ externalWallet });
+      const serverAuthState = yield this.ctx.client.loginExternalWalletV2({ externalWallet });
       return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
     });
   }
-  verifyExternalWallet(_o) {
+  verifyExternalWalletV2(_w) {
     return __async(this, null, function* () {
-      var _p = _o, {
+      var _x = _w, {
         externalWallet,
         signedMessage,
         cosmosPublicKeyHex,
         cosmosSigner
-      } = _p, urlOptions = __objRest(_p, [
+      } = _x, urlOptions = __objRest(_x, [
         "externalWallet",
         "signedMessage",
         "cosmosPublicKeyHex",
         "cosmosSigner"
       ]);
-      const serverAuthState = yield this.ctx.client.verifyExternalWallet(this.userId, {
+      const serverAuthState = yield this.ctx.client.verifyExternalWalletV2(this.userId, {
         externalWallet,
         signedMessage,
         cosmosPublicKeyHex,
@@ -3511,9 +4555,9 @@ var _ParaCore = class _ParaCore {
    * @param {string} opts.verificationCode the verification code to received via 2FA.
    * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
    */
-  verify2fa(_0) {
+  verify2faV2(_0) {
     return __async(this, arguments, function* ({ auth, verificationCode }) {
-      const res = yield this.ctx.client.verify2FA(auth, verificationCode);
+      const res = yield this.ctx.client.verify2FAV2(auth, verificationCode);
       return {
         initiatedAt: res.data.initiatedAt,
         status: res.data.status,
@@ -3526,10 +4570,10 @@ var _ParaCore = class _ParaCore {
    * Sets up two-factor authentication for the current user.
    * @returns {string} uri - uri to use for setting up 2FA
    * */
-  setup2fa() {
+  setup2faV2() {
     return __async(this, null, function* () {
       const userId = this.assertUserId();
-      const res = yield this.ctx.client.setup2FA(userId);
+      const res = yield this.ctx.client.setup2FAV2(userId);
       return res;
     });
   }
@@ -3538,7 +4582,7 @@ var _ParaCore = class _ParaCore {
    * @param {Object} opts the options object
    * @param {string} opts.verificationCode - the verification code received via 2FA.
    */
-  enable2fa(_0) {
+  enable2faV2(_0) {
     return __async(this, arguments, function* ({ verificationCode }) {
       const userId = this.assertUserId();
       yield this.ctx.client.enable2FA(userId, verificationCode);
@@ -3553,7 +4597,7 @@ 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.
    **/
-  createPregenWallet(opts) {
+  createPregenWalletV2(opts) {
     return __async(this, null, function* () {
       var _a, _b;
       const { supportedWalletTypes } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
@@ -3610,14 +4654,14 @@ 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.
    **/
-  createPregenWalletPerType(_0) {
+  createPregenWalletPerTypeV2(_0) {
     return __async(this, arguments, function* ({
       types,
       pregenId
     }) {
       const wallets = [];
       for (const type of yield this.getTypesToCreate(types)) {
-        const wallet = yield this.createPregenWallet({ type, pregenId });
+        const wallet = yield this.createPregenWalletV2({ type, pregenId });
         wallets.push(wallet);
       }
       return wallets;
@@ -3630,13 +4674,13 @@ 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.
    **/
-  claimPregenWallets() {
+  claimPregenWalletsV2() {
     return __async(this, arguments, function* ({
       pregenId
     } = {}) {
       var _a;
       this.requireApiKey();
-      const pregenWallets = pregenId ? yield this.getPregenWallets({ pregenId }) : yield this.getPregenWallets();
+      const pregenWallets = pregenId ? yield this.getPregenWalletsV2({ pregenId }) : yield this.getPregenWalletsV2();
       if (pregenWallets.length === 0) {
         return void 0;
       }
@@ -3696,7 +4740,7 @@ var _ParaCore = class _ParaCore {
    * @param {string} opts.newPregenIdentifier the new identtifier
    * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
    **/
-  updatePregenWalletIdentifier(_0) {
+  updatePregenWalletIdentifierV2(_0) {
     return __async(this, arguments, function* ({
       walletId,
       newPregenId
@@ -3723,11 +4767,11 @@ 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
    **/
-  hasPregenWallet(_0) {
+  hasPregenWalletV2(_0) {
     return __async(this, arguments, function* ({ pregenId }) {
       this.requireApiKey();
       const [pregenIdentifierType, pregenIdentifier] = toPregenTypeAndId(pregenId);
-      const wallets = yield this.getPregenWallets({ pregenId });
+      const wallets = yield this.getPregenWalletsV2({ pregenId });
       const wallet = wallets.find(
         (w) => w.pregenIdentifier === pregenIdentifier && w.pregenIdentifierType === pregenIdentifierType
       );
@@ -3744,8 +4788,10 @@ 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
    **/
-  getPregenWallets() {
-    return __async(this, arguments, function* ({ pregenId } = {}) {
+  getPregenWalletsV2() {
+    return __async(this, arguments, function* ({
+      pregenId
+    } = {}) {
       this.requireApiKey();
       const res = yield this.ctx.client.getPregenWallets(
         pregenId ? toPregenIds(pregenId) : this.pregenIds,
@@ -3875,8 +4921,8 @@ prepareLoginState_fn = function(_0, _1) {
   }) {
     const _a = loginState, { loginAuthMethods } = _a, authState = __objRest(_a, ["loginAuthMethods"]);
     return __spreadValues(__spreadValues(__spreadValues({}, authState), !this.isNativePasskey && loginAuthMethods.includes(AuthMethod.PASSKEY) ? {
-      passkeyUrl: yield this.getLoginUrl({ sessionId: sessionLookupId, shorten, portalTheme }),
-      passkeyKnownDeviceUrl: yield this.constructPortalUrl("loginAuth", {
+      passkeyUrl: yield this.getLoginUrlV2({ sessionId: sessionLookupId, shorten, portalTheme }),
+      passkeyKnownDeviceUrl: yield this.constructPortalUrlV2("loginAuth", {
         sessionId: sessionLookupId,
         newDevice: {
           sessionId: sessionLookupId,
@@ -3886,7 +4932,7 @@ prepareLoginState_fn = function(_0, _1) {
         portalTheme
       })
     } : {}), loginAuthMethods.includes(AuthMethod.PASSWORD) ? {
-      passwordUrl: yield this.constructPortalUrl("loginPassword", {
+      passwordUrl: yield this.constructPortalUrlV2("loginPassword", {
         sessionId: sessionLookupId,
         shorten,
         portalTheme
@@ -3941,7 +4987,7 @@ import {
   OnRampPurchaseType,
   OnRampProvider,
   OnRampPurchaseStatus,
-  OAuthMethod,
+  OAuthMethod as OAuthMethod2,
   NON_ED25519,
   PREGEN_IDENTIFIER_TYPES
 } from "@getpara/user-management-client";
@@ -3955,7 +5001,7 @@ export {
   KeyContainer,
   NON_ED25519,
   Network,
-  OAuthMethod,
+  OAuthMethod2 as OAuthMethod,
   OnRampAsset,
   OnRampMethod,
   OnRampProvider,