@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/esm/services/AuthService.js

@@ -0,0 +1,717 @@
+import {
+  __async,
+  __objRest,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+var _stateManager, _loginFlowService, _signupFlowService, _verificationFlowService, _externalWalletService, _pregenWalletService, _sessionManagementService, _portalUrlService, _paraCoreInterface, _authInfo, _isEnclaveUser;
+import {
+  AuthMethod,
+  AuthMethodStatus,
+  extractAuthInfo,
+  isEmail,
+  isExternalWallet,
+  isFarcaster,
+  isPhone,
+  isTelegram,
+  PublicKeyType
+} from "@getpara/user-management-client";
+import * as constants from "../constants.js";
+import { LoginFlowService } from "./LoginFlowService.js";
+import { VerificationFlowService } from "./VerificationFlowService.js";
+import { SignupFlowService } from "./SignupFlowService.js";
+import { waitForAuthStateChange } from "../utils/stateListener.js";
+class AuthService {
+  constructor(paraCore) {
+    __privateAdd(this, _stateManager);
+    __privateAdd(this, _loginFlowService);
+    __privateAdd(this, _signupFlowService);
+    __privateAdd(this, _verificationFlowService);
+    __privateAdd(this, _externalWalletService);
+    __privateAdd(this, _pregenWalletService);
+    __privateAdd(this, _sessionManagementService);
+    __privateAdd(this, _portalUrlService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _authInfo);
+    __privateAdd(this, _isEnclaveUser, false);
+    this.init = ({
+      stateManager,
+      portalUrlService,
+      externalWalletService,
+      sessionManagementService,
+      pregenWalletService,
+      walletService
+    }) => {
+      __privateSet(this, _stateManager, stateManager);
+      __privateSet(this, _externalWalletService, externalWalletService);
+      __privateSet(this, _portalUrlService, portalUrlService);
+      __privateSet(this, _sessionManagementService, sessionManagementService);
+      __privateSet(this, _pregenWalletService, pregenWalletService);
+      __privateSet(this, _loginFlowService, new LoginFlowService(__privateGet(this, _paraCoreInterface), stateManager, {
+        portalUrlService,
+        walletService,
+        sessionManagementService,
+        externalWalletService,
+        authService: this
+      }));
+      __privateSet(this, _signupFlowService, new SignupFlowService(__privateGet(this, _paraCoreInterface), stateManager, {
+        portalUrlService,
+        walletService,
+        sessionManagementService,
+        externalWalletService,
+        authService: this
+      }));
+      __privateSet(this, _verificationFlowService, new VerificationFlowService(__privateGet(this, _paraCoreInterface), stateManager, {
+        portalUrlService,
+        walletService,
+        sessionManagementService,
+        externalWalletService,
+        authService: this
+      }));
+    };
+    this.prepareLogin = () => __async(this, null, function* () {
+      yield __privateGet(this, _paraCoreInterface).logout({ skipStateReset: true });
+      const { sessionLookupId } = yield __privateGet(this, _sessionManagementService).touchSession(true);
+      if (!__privateGet(this, _paraCoreInterface).loginEncryptionKeyPair) {
+        yield __privateGet(this, _paraCoreInterface).setLoginEncryptionKeyPair();
+      }
+      return sessionLookupId;
+    });
+    this.setAuth = (_0, ..._1) => __async(this, [_0, ..._1], function* (auth, { extras = {}, userId } = {}) {
+      const authInfo = __spreadValues(__spreadValues({}, extractAuthInfo(auth, { isRequired: true })), extras || {});
+      yield this.setAuthInfo(authInfo);
+      if (!!userId) {
+        yield this.setUserId(userId);
+      }
+      return this.authInfo;
+    });
+    this.setAuthInfo = (authInfo) => __async(this, null, function* () {
+      this.authInfo = authInfo;
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(constants.LOCAL_STORAGE_AUTH_INFO, JSON.stringify(authInfo));
+      yield __privateGet(this, _paraCoreInterface).localStorageRemoveItem(constants.LOCAL_STORAGE_EMAIL);
+      yield __privateGet(this, _paraCoreInterface).localStorageRemoveItem(constants.LOCAL_STORAGE_PHONE);
+      yield __privateGet(this, _paraCoreInterface).localStorageRemoveItem(constants.LOCAL_STORAGE_COUNTRY_CODE);
+      yield __privateGet(this, _paraCoreInterface).localStorageRemoveItem(constants.LOCAL_STORAGE_FARCASTER_USERNAME);
+      yield __privateGet(this, _paraCoreInterface).localStorageRemoveItem(constants.LOCAL_STORAGE_TELEGRAM_USER_ID);
+    });
+    this.setUserId = (userId) => __async(this, null, function* () {
+      this.userId = userId;
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(constants.LOCAL_STORAGE_USER_ID, userId);
+    });
+    this.assertIsAuthSet = (allowed) => {
+      if (!this.authInfo) {
+        throw new Error("auth is not set");
+      }
+      if (allowed && !allowed.includes(this.authInfo.authType)) {
+        throw new Error(`invalid auth type, expected ${allowed.join(", ")}`);
+      }
+      return this.authInfo;
+    };
+    this.assertUserId = ({ allowGuestMode = false } = {}) => {
+      if (!this.userId || !allowGuestMode && __privateGet(this, _pregenWalletService).isGuestMode) {
+        throw new Error("no userId is set");
+      }
+      return this.userId;
+    };
+    this.prepareAuthState = (_0, ..._1) => __async(this, [_0, ..._1], function* (serverAuthState, opts = {}) {
+      var _a, _b, _c;
+      if (!opts.sessionLookupId && serverAuthState.stage === "login" && (!serverAuthState.externalWallet || !(((_a = serverAuthState.externalWallet) == null ? void 0 : _a.withFullParaAuth) && ((_b = serverAuthState.loginAuthMethods) == null ? void 0 : _b.includes(AuthMethod.PIN))))) {
+        opts.sessionLookupId = yield this.prepareLogin();
+      }
+      const { auth, externalWallet, userId, displayName, pfpUrl, username } = serverAuthState;
+      const authInfo = __spreadValues(__spreadValues({}, extractAuthInfo(auth, { isRequired: true })), Object.fromEntries(
+        Object.entries({
+          displayName,
+          pfpUrl,
+          username,
+          externalWallet
+        }).filter(([_, v]) => !!v)
+      ));
+      yield this.setAuthInfo(authInfo);
+      this.assertIsAuthSet();
+      if (!!externalWallet) {
+        yield __privateGet(this, _externalWalletService).setExternalWallet({ externalWallet: [externalWallet] });
+      }
+      if (!!userId) {
+        yield this.setUserId(userId);
+      }
+      switch (serverAuthState.stage) {
+        case "login":
+          if (externalWallet && !(externalWallet == null ? void 0 : externalWallet.withFullParaAuth)) {
+            return serverAuthState;
+          }
+          return yield __privateGet(this, _loginFlowService).prepareState(serverAuthState, opts);
+        case "signup":
+          if (externalWallet && !(externalWallet == null ? void 0 : externalWallet.withFullParaAuth)) {
+            return serverAuthState;
+          }
+          return yield __privateGet(this, _signupFlowService).prepareState(serverAuthState, opts);
+        case "verify":
+          return yield __privateGet(this, _verificationFlowService).prepareState(serverAuthState, __spreadProps(__spreadValues({}, opts), {
+            sessionLookupId: opts.sessionLookupId
+          }));
+        case "done":
+          if ((_c = serverAuthState.externalWallet) == null ? void 0 : _c.isConnectionOnly) {
+            return serverAuthState;
+          }
+          let isSLOPossible = serverAuthState.authMethods.includes(AuthMethod.BASIC_LOGIN);
+          this.isEnclaveUser = isSLOPossible;
+          yield __privateGet(this, _paraCoreInterface).localStorageSetItem(
+            constants.LOCAL_STORAGE_IS_ENCLAVE_USER,
+            JSON.stringify(isSLOPossible)
+          );
+          return serverAuthState;
+      }
+    });
+    this.prepareLoginState = (_0, _1) => __async(this, [_0, _1], function* (loginState, { useShortUrls: shorten = false, portalTheme, sessionLookupId }) {
+      return yield __privateGet(this, _loginFlowService).prepareState(loginState, {
+        useShortUrls: shorten,
+        portalTheme,
+        sessionLookupId
+      });
+    });
+    this.performSignUpOrLogIn = (params) => __async(this, null, function* () {
+      const _a = params, { auth } = _a, urlOptions = __objRest(_a, ["auth"]);
+      try {
+        const serverAuthState = yield __privateGet(this, _paraCoreInterface).ctx.client.signUpOrLogIn(__spreadValues(__spreadValues({}, auth), __privateGet(this, _paraCoreInterface).getVerificationEmailProps()));
+        return { authState: serverAuthState, opts: urlOptions };
+      } catch (error) {
+        if (error.message.includes("max beta users reached")) {
+          __privateGet(this, _paraCoreInterface).displayModalError(
+            `50 user limit reached. [Go to Production.](https://docs.getpara.com/v2/general/checklist#go-live-checklist)`
+          );
+        }
+        throw error;
+      }
+    });
+    this.signUpOrLogIn = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "AUTHENTICATE_EMAIL_PHONE", data: __spreadProps(__spreadValues({}, params), { isLegacy: true }) });
+      return yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          { phase: "awaiting_session_start", onPhase: (state) => state.authStateResult },
+          {
+            phase: "awaiting_account_verification",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+    this.authenticateWithEmailOrPhone = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "AUTHENTICATE_EMAIL_PHONE", data: __spreadProps(__spreadValues({}, params), { isLegacy: false }) });
+      const authState = yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          // awaiting_session_start will be hit for non-SLO logins & all SLO logins/sign ups
+          { phase: "awaiting_session_start", onPhase: (state) => state.authStateResult },
+          // awaiting_account_verification will be hit for non-SLO sign ups
+          {
+            phase: "awaiting_account_verification",
+            onPhase: (state) => state.authStateResult
+          }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("Authentication canceled")
+          }
+        ]
+      });
+      if (authState.stage === "verify") {
+        const isSLO = !!authState.loginUrl;
+        if (!isSLO) {
+          yield waitForAuthStateChange({
+            stateManager: __privateGet(this, _stateManager),
+            resolvePhases: [{ phase: "awaiting_session_start", onPhase: (state) => state.authStateResult }],
+            // Only reject if we get to an error phase, account verification can be retried while an error is present and we don't want to cancel the flow in that case
+            rejectInErrorPhaseOnly: true,
+            rejectPhases: [
+              {
+                phase: "unauthenticated",
+                onPhase: () => new Error("Authentication canceled")
+              }
+            ]
+          });
+        }
+      }
+      __privateGet(this, _stateManager).send({
+        type: "WAIT_FOR_SESSION",
+        data: __spreadProps(__spreadValues({}, params.sessionPollingCallbacks), { autoCreateWallets: true })
+      });
+      const resp = yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: (state) => {
+              const createdWallets = state.newWalletsResult;
+              if (createdWallets) {
+                return {
+                  hasCreatedWallets: true,
+                  recoverySecret: state.newWalletsResult.recoverySecret
+                };
+              }
+              return {
+                hasCreatedWallets: false,
+                recoverySecret: void 0
+              };
+            }
+          }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("Session waiting canceled")
+          }
+        ],
+        waitForCoreAuthenticated: true
+      });
+      return __spreadValues({ authInfo: this.authInfo }, resp);
+    });
+    this.performVerifyNewAccount = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).performVerifyNewAccount(params);
+    });
+    this.verifyNewAccount = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).verifyNewAccount(params);
+    });
+    this.waitForLogin = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _loginFlowService).waitForLogin(params);
+    });
+    this.waitForSignup = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _signupFlowService).waitForSignup(params);
+    });
+    this.waitForWalletCreation = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _signupFlowService).waitForWalletCreation(params);
+    });
+    this.performVerifyExternalWallet = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).performVerifyExternalWallet(params);
+    });
+    this.verifyExternalWallet = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).verifyExternalWallet(params);
+    });
+    this.retryVerifyExternalWallet = () => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).retryVerifyExternalWallet();
+    });
+    this.performLoginExternalWallet = (params) => __async(this, null, function* () {
+      const _a = params, { externalWallet, chainId, uri } = _a, urlOptions = __objRest(_a, ["externalWallet", "chainId", "uri"]);
+      const externalWallets = Array.isArray(params.externalWallet) ? params.externalWallet : [params.externalWallet];
+      try {
+        yield __privateGet(this, _paraCoreInterface).ctx.client.trackExternalWalletConnections({
+          wallets: externalWallets.map((wallet) => ({
+            address: wallet.address,
+            type: wallet.type,
+            provider: wallet.provider
+          }))
+        });
+      } catch (err) {
+        console.error("Error tracking external wallet connections:", err);
+      }
+      if (__privateGet(this, _paraCoreInterface).externalWalletConnectionOnly || externalWallets.every((wallet) => wallet.isConnectionOnly)) {
+        yield __privateGet(this, _externalWalletService).addExternalWallets({
+          externalWallets: externalWallets.map((wallet) => __spreadProps(__spreadValues({}, wallet), {
+            withFullParaAuth: false
+          }))
+        });
+        const connectionOnlyWallet = __spreadProps(__spreadValues({}, externalWallets[0]), { withFullParaAuth: false, isConnectionOnly: true });
+        return Promise.resolve({
+          authState: {
+            stage: "done",
+            userId: constants.EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
+            externalWallet: connectionOnlyWallet,
+            auth: {
+              externalWalletAddress: externalWallets[0].address
+            },
+            authMethods: [],
+            // Returning true as a placeholder, since we don't process this through Para we can't determine this here
+            isNewUser: true
+          },
+          opts: urlOptions
+        });
+      }
+      if (Array.isArray(externalWallet)) {
+        throw new Error(
+          "Cannot authenticate multiple external wallets at once. To connect multiple wallets at once, use CONNECTION_ONLY mode."
+        );
+      }
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const serverAuthState = yield __privateGet(this, _paraCoreInterface).ctx.client.loginExternalWallet({ externalWallet, chainId, uri });
+      if (!externalWallet.withFullParaAuth && externalWallet.withVerification) {
+        yield __privateGet(this, _sessionManagementService).touchSession(true);
+      }
+      if (externalWallet.withFullParaAuth) {
+        yield __privateGet(this, _paraCoreInterface).ctx.client.sessionAddPortalVerification();
+      }
+      return { authState: serverAuthState, opts: urlOptions };
+    });
+    this.loginExternalWallet = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "AUTHENTICATE_EXTERNAL_WALLET", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          { phase: "awaiting_session_start", onPhase: (state) => state.authStateResult },
+          {
+            phase: "awaiting_wallet_signature",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "awaiting_account_verification",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "awaiting_wallet_verification",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "authenticated",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+    this.connectExternalWallet = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "CONNECT_EXTERNAL_WALLET", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          { phase: "awaiting_session_start", onPhase: (state) => state.authStateResult },
+          {
+            phase: "awaiting_wallet_signature",
+            onPhase: (state) => state.authStateResult
+          },
+          { phase: "authenticated", onPhase: (state) => state.authStateResult }
+        ]
+      });
+    });
+    this.signExternalWalletVerification = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "SIGN_EXTERNAL_WALLET_VERIFICATION", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          {
+            phase: "awaiting_wallet_verification",
+            onPhase: () => __privateGet(this, _stateManager).getSnapshot().externalWalletSignVerification
+          }
+        ]
+      });
+    });
+    this.verifyOAuthProcess = (params) => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({
+        type: "AUTHENTICATE_OAUTH",
+        data: __spreadProps(__spreadValues({}, params), {
+          onCancel: params.onCancel,
+          onPoll: params.onPoll,
+          isCanceled: params.isCanceled,
+          isLegacy: true
+        })
+      });
+      return yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          { phase: "awaiting_session_start", onPhase: (state) => state.authStateResult }
+        ]
+      });
+    });
+    this.authenticateWithOAuth = (params) => __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      switch (params.method) {
+        case "TELEGRAM": {
+          __privateGet(this, _stateManager).send({
+            type: "AUTHENTICATE_TELEGRAM",
+            data: __spreadProps(__spreadValues({}, params), {
+              method: params.method,
+              isCanceled: (_a = params.oAuthPollingCallbacks) == null ? void 0 : _a.isCanceled,
+              onOAuthPopup: (_b = params.redirectCallbacks) == null ? void 0 : _b.onOAuthPopup,
+              onOAuthUrl: (_c = params.redirectCallbacks) == null ? void 0 : _c.onOAuthUrl
+            })
+          });
+          break;
+        }
+        case "FARCASTER": {
+          __privateGet(this, _stateManager).send({
+            type: "AUTHENTICATE_FARCASTER",
+            data: __spreadProps(__spreadValues({}, params), {
+              method: params.method,
+              isCanceled: (_d = params.oAuthPollingCallbacks) == null ? void 0 : _d.isCanceled,
+              onOAuthPopup: (_e = params.redirectCallbacks) == null ? void 0 : _e.onOAuthPopup,
+              onOAuthUrl: (_f = params.redirectCallbacks) == null ? void 0 : _f.onOAuthUrl
+            })
+          });
+          break;
+        }
+        default: {
+          __privateGet(this, _stateManager).send({
+            type: "AUTHENTICATE_OAUTH",
+            data: __spreadProps(__spreadValues({}, params), {
+              method: params.method,
+              onCancel: (_g = params.oAuthPollingCallbacks) == null ? void 0 : _g.onCancel,
+              onPoll: (_h = params.oAuthPollingCallbacks) == null ? void 0 : _h.onPoll,
+              isCanceled: (_i = params.oAuthPollingCallbacks) == null ? void 0 : _i.isCanceled,
+              isLegacy: false,
+              onOAuthPopup: (_j = params.redirectCallbacks) == null ? void 0 : _j.onOAuthPopup,
+              onOAuthUrl: (_k = params.redirectCallbacks) == null ? void 0 : _k.onOAuthUrl
+            })
+          });
+          break;
+        }
+      }
+      yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          // awaiting_session_start will be hit for non-SLO logins & all SLO logins/sign ups
+          { phase: "awaiting_session_start", onPhase: () => void 0 }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("OAuth canceled")
+          }
+        ]
+      });
+      __privateGet(this, _stateManager).send({
+        type: "WAIT_FOR_SESSION",
+        data: __spreadProps(__spreadValues({}, params.sessionPollingCallbacks), { autoCreateWallets: true })
+      });
+      const resp = yield waitForAuthStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: (state) => {
+              const createdWallets = state.newWalletsResult;
+              if (createdWallets) {
+                return {
+                  hasCreatedWallets: true,
+                  recoverySecret: state.newWalletsResult.recoverySecret
+                };
+              }
+              return {
+                hasCreatedWallets: false,
+                recoverySecret: void 0
+              };
+            }
+          }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("Session waiting canceled")
+          }
+        ],
+        waitForCoreAuthenticated: true
+      });
+      return __spreadValues({ authInfo: this.authInfo }, resp);
+    });
+    this.performVerifyTelegram = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).performVerifyTelegram(params);
+    });
+    this.verifyTelegram = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).verifyTelegram(params);
+    });
+    this.performVerifyFarcaster = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).performVerifyFarcaster(params);
+    });
+    this.verifyFarcaster = (params) => __async(this, null, function* () {
+      return yield __privateGet(this, _verificationFlowService).verifyFarcaster(params);
+    });
+    this.supportedUserAuthMethods = () => __async(this, null, function* () {
+      this.assertIsAuthSet();
+      const { supportedAuthMethods, hasPasswordWithoutPIN } = yield __privateGet(this, _paraCoreInterface).ctx.client.getSupportedAuthMethodsV2(this.authInfo.auth);
+      const authMethods = /* @__PURE__ */ new Set();
+      for (const type of supportedAuthMethods) {
+        switch (type) {
+          case "PASSWORD":
+            if (hasPasswordWithoutPIN) {
+              authMethods.add(AuthMethod.PASSWORD);
+            }
+            break;
+          case "PASSKEY":
+            authMethods.add(AuthMethod.PASSKEY);
+            break;
+          case "PIN":
+            authMethods.add(AuthMethod.PIN);
+            break;
+          case "BASIC_LOGIN":
+            authMethods.add(AuthMethod.BASIC_LOGIN);
+            break;
+        }
+      }
+      return authMethods;
+    });
+    this.getNewCredentialAndUrl = (..._0) => __async(this, [..._0], function* ({
+      authMethod: optsAuthMethod,
+      isForNewDevice = false,
+      portalTheme,
+      shorten = false
+    } = {}) {
+      const userAuthMethods = yield this.supportedUserAuthMethods();
+      const isEnclaveUser = userAuthMethods.has(AuthMethod.BASIC_LOGIN);
+      const isAddingBasicLogin = optsAuthMethod === "BASIC_LOGIN";
+      if (isEnclaveUser && isAddingBasicLogin) {
+        throw new Error("That user is already using basic login");
+      }
+      if (isEnclaveUser || isAddingBasicLogin) {
+        isForNewDevice = true;
+      }
+      const authMethods = optsAuthMethod ? [optsAuthMethod] : isForNewDevice ? ["PASSKEY", "PIN", "PASSWORD"] : ["PASSKEY"];
+      this.assertIsAuthSet();
+      let passkeyId, passwordId, urlType, credentialId;
+      if (!isAddingBasicLogin) {
+        const canAddPasswordOrPIN = !userAuthMethods.has(AuthMethod.PASSWORD) && !userAuthMethods.has(AuthMethod.PIN);
+        if (authMethods.includes("PASSKEY") && (yield __privateGet(this, _paraCoreInterface).isPasskeySupported())) {
+          ({
+            data: { id: passkeyId }
+          } = yield __privateGet(this, _paraCoreInterface).ctx.client.addSessionPublicKey(this.userId, {
+            status: AuthMethodStatus.PENDING,
+            type: PublicKeyType.WEB
+          }));
+          urlType = "createAuth";
+        }
+        if (authMethods.includes("PASSWORD")) {
+          if (!canAddPasswordOrPIN) {
+            if (optsAuthMethod === "PASSWORD") throw new Error("A user cannot have more than one password or PIN.");
+          } else {
+            ({
+              data: { id: passwordId }
+            } = yield __privateGet(this, _paraCoreInterface).ctx.client.addSessionPasswordPublicKey(this.userId, {
+              status: AuthMethodStatus.PENDING
+            }));
+            urlType = "createPassword";
+          }
+        }
+        if (authMethods.includes("PIN")) {
+          if (!canAddPasswordOrPIN) {
+            if (optsAuthMethod === "PIN") throw new Error("A user cannot have more than one password or PIN.");
+          } else {
+            ({
+              data: { id: passwordId }
+            } = yield __privateGet(this, _paraCoreInterface).ctx.client.addSessionPasswordPublicKey(this.userId, {
+              status: AuthMethodStatus.PENDING
+            }));
+            urlType = "createPIN";
+          }
+        }
+        credentialId = passkeyId != null ? passkeyId : passwordId;
+        if (__privateGet(this, _paraCoreInterface).isNativePasskey && authMethods.includes("PASSKEY")) {
+          return { credentialId };
+        }
+      }
+      const { sessionId } = yield __privateGet(this, _sessionManagementService).touchSession();
+      const url = (isForNewDevice || urlType) && (yield __privateGet(this, _portalUrlService).constructPortalUrl(isForNewDevice ? "addNewCredential" : urlType, {
+        isForNewDevice,
+        pathId: credentialId,
+        portalTheme,
+        shorten,
+        sessionId: isForNewDevice ? sessionId : void 0,
+        addNewCredentialType: optsAuthMethod,
+        addNewCredentialPasskeyId: passkeyId,
+        addNewCredentialPasswordId: passwordId
+      }));
+      return __spreadValues({ credentialId }, url ? { url } : {});
+    });
+    this.addCredential = (_0) => __async(this, [_0], function* ({ authMethod }) {
+      if (authMethod === "PASSKEY" && !(yield __privateGet(this, _paraCoreInterface).isPasskeySupported())) {
+        throw new Error("Passkeys are not supported.");
+      }
+      const { url } = yield this.getNewCredentialAndUrl({ isForNewDevice: true, authMethod });
+      return url;
+    });
+    this.resendVerificationCode = (_0) => __async(this, [_0], function* ({ type: reason = "SIGNUP" }) {
+      let type, linkedAccountId;
+      switch (reason) {
+        case "SIGNUP":
+        case "LOGIN":
+          {
+            const authInfo = this.assertIsAuthSet(["email", "phone"]);
+            type = authInfo.authType.toUpperCase();
+          }
+          break;
+        case "LINK_ACCOUNT":
+          {
+            const accountLinkInProgress = __privateGet(this, _paraCoreInterface).assertIsLinkingAccount(["EMAIL", "PHONE"]);
+            linkedAccountId = accountLinkInProgress.id;
+            type = accountLinkInProgress.type;
+          }
+          break;
+      }
+      const userId = this.assertUserId({ allowGuestMode: true });
+      if (type !== "EMAIL" && type !== "PHONE") {
+        throw new Error("invalid auth type for verification code");
+      }
+      yield __privateGet(this, _paraCoreInterface).ctx.client.resendVerificationCode(__spreadValues({
+        userId,
+        type,
+        linkedAccountId
+      }, __privateGet(this, _paraCoreInterface).getVerificationEmailProps()));
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getAuthServiceInterface());
+  }
+  get isEnclaveUser() {
+    return __privateGet(this, _isEnclaveUser);
+  }
+  set isEnclaveUser(value) {
+    __privateSet(this, _isEnclaveUser, value);
+  }
+  get email() {
+    var _a;
+    return isEmail((_a = this.authInfo) == null ? void 0 : _a.auth) ? this.authInfo.auth.email : void 0;
+  }
+  get phone() {
+    var _a;
+    return isPhone((_a = this.authInfo) == null ? void 0 : _a.auth) ? this.authInfo.auth.phone : void 0;
+  }
+  get farcasterUsername() {
+    var _a;
+    return isFarcaster((_a = this.authInfo) == null ? void 0 : _a.auth) ? this.authInfo.auth.farcasterUsername : void 0;
+  }
+  get telegramUserId() {
+    var _a;
+    return isTelegram((_a = this.authInfo) == null ? void 0 : _a.auth) ? this.authInfo.auth.telegramUserId : void 0;
+  }
+  get isEmail() {
+    var _a;
+    return isEmail((_a = this.authInfo) == null ? void 0 : _a.auth);
+  }
+  get isPhone() {
+    var _a;
+    return isPhone((_a = this.authInfo) == null ? void 0 : _a.auth);
+  }
+  get isFarcaster() {
+    var _a;
+    return isFarcaster((_a = this.authInfo) == null ? void 0 : _a.auth);
+  }
+  get isTelegram() {
+    var _a;
+    return isTelegram((_a = this.authInfo) == null ? void 0 : _a.auth);
+  }
+  get isExternalWalletAuth() {
+    var _a, _b, _c;
+    return isExternalWallet((_a = this.authInfo) == null ? void 0 : _a.auth) && !!((_c = (_b = this.authInfo) == null ? void 0 : _b.externalWallet) == null ? void 0 : _c.withFullParaAuth);
+  }
+  get isExternalWalletWithVerification() {
+    var _a, _b, _c;
+    return isExternalWallet((_a = this.authInfo) == null ? void 0 : _a.auth) && !!((_c = (_b = this.authInfo) == null ? void 0 : _b.externalWallet) == null ? void 0 : _c.withVerification);
+  }
+  get authInfo() {
+    return __privateGet(this, _authInfo);
+  }
+  set authInfo(authInfo) {
+    __privateSet(this, _authInfo, authInfo);
+  }
+}
+_stateManager = new WeakMap();
+_loginFlowService = new WeakMap();
+_signupFlowService = new WeakMap();
+_verificationFlowService = new WeakMap();
+_externalWalletService = new WeakMap();
+_pregenWalletService = new WeakMap();
+_sessionManagementService = new WeakMap();
+_portalUrlService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_authInfo = new WeakMap();
+_isEnclaveUser = new WeakMap();
+export {
+  AuthService
+};