@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/esm/services/SignupFlowService.js

@@ -0,0 +1,119 @@
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { AuthMethod } from "@getpara/user-management-client";
+import { BaseAuthFlowService } from "./BaseAuthFlowService.js";
+import { ParaEvent } from "../types/index.js";
+import { dispatchEvent } from "../utils/index.js";
+import { extractErrorMessage } from "../utils/stateErrorHelpers.js";
+import { waitForAuthStateChange, waitForCoreStateChange } from "../utils/stateListener.js";
+class SignupFlowService extends BaseAuthFlowService {
+  constructor() {
+    super(...arguments);
+    this.prepareState = (serverAuthState, opts) => __async(this, null, function* () {
+      yield this.setupAuthFromServerState(serverAuthState);
+      const _a = serverAuthState, { signupAuthMethods = [] } = _a, authState = __objRest(_a, ["signupAuthMethods"]);
+      const { useShortUrls: shorten = false, portalTheme } = opts;
+      const isPasskeySupported = yield this.paraCoreInterface.isPasskeySupported();
+      const [isPasskey, isPassword, isPIN] = [
+        signupAuthMethods.includes(AuthMethod.PASSKEY),
+        signupAuthMethods.includes(AuthMethod.PASSWORD) || !isPasskeySupported,
+        signupAuthMethods.includes(AuthMethod.PIN)
+      ];
+      if (!isPasskey && !isPassword && !isPIN) {
+        throw new Error("No supported authentication methods found...");
+      }
+      const signupState = __spreadProps(__spreadValues({}, authState), {
+        isPasskeySupported,
+        signupAuthMethods
+      });
+      if (isPasskey) {
+        const { url: passkeyUrl, credentialId: passkeyId } = yield this.services.authService.getNewCredentialAndUrl({
+          authMethod: "PASSKEY",
+          shorten
+        });
+        if (passkeyUrl) signupState.passkeyUrl = passkeyUrl;
+        signupState.passkeyId = passkeyId;
+      }
+      if (isPassword) {
+        const { url: passwordUrl, credentialId: passwordId } = yield this.services.authService.getNewCredentialAndUrl({
+          authMethod: "PASSWORD",
+          portalTheme,
+          shorten
+        });
+        signupState.passwordUrl = passwordUrl;
+        signupState.passwordId = passwordId;
+      }
+      if (isPIN) {
+        const { url: pinUrl, credentialId: pinId } = yield this.services.authService.getNewCredentialAndUrl({
+          authMethod: "PIN",
+          portalTheme,
+          shorten
+        });
+        signupState.pinUrl = pinUrl;
+        signupState.pinId = pinId;
+      }
+      return signupState;
+    });
+    this.waitForSignup = (_0) => __async(this, [_0], function* ({ isCanceled = () => false, onCancel, onPoll }) {
+      this.stateManager.send({
+        type: "WAIT_FOR_SESSION",
+        data: {
+          onCancel,
+          onPoll,
+          isCanceled
+        }
+      });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: () => {
+              dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
+              return true;
+            }
+          }
+        ],
+        onReject: (state) => {
+          var _a;
+          (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_CREATION_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
+        },
+        waitForCoreAuthenticated: false
+      });
+    });
+    this.waitForWalletCreation = (..._0) => __async(this, [..._0], function* ({ isCanceled = () => false, onCancel, onPoll } = {}) {
+      this.stateManager.send({
+        type: "WAIT_FOR_WALLET_CREATION",
+        data: {
+          onCancel,
+          onPoll,
+          isCanceled
+        }
+      });
+      return yield waitForCoreStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: (state) => {
+              const resp = state.newWalletsResult;
+              dispatchEvent(ParaEvent.ACCOUNT_SETUP_EVENT, resp);
+              return resp;
+            }
+          }
+        ],
+        onReject: (state) => {
+          var _a;
+          (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_SETUP_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
+        }
+      });
+    });
+  }
+}
+export {
+  SignupFlowService
+};

package/dist/esm/services/VerificationFlowService.js

@@ -0,0 +1,178 @@
+import {
+  __async,
+  __objRest,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { AuthMethod } from "@getpara/user-management-client";
+import { BaseAuthFlowService } from "./BaseAuthFlowService.js";
+import { LOCAL_STORAGE_IS_ENCLAVE_USER } from "../constants.js";
+import { waitForAuthStateChange } from "../utils/stateListener.js";
+class VerificationFlowService extends BaseAuthFlowService {
+  constructor() {
+    super(...arguments);
+    this.prepareState = (serverAuthState, opts) => __async(this, null, function* () {
+      var _a;
+      yield this.setupAuthFromServerState(serverAuthState);
+      const { useShortUrls: shorten = false, portalTheme, sessionLookupId } = opts;
+      let isSLOPossible = false;
+      if (serverAuthState.nextStage === "login") {
+        isSLOPossible = serverAuthState.loginAuthMethods.includes(AuthMethod.BASIC_LOGIN);
+      } else if (serverAuthState.nextStage === "signup") {
+        isSLOPossible = serverAuthState.signupAuthMethods.includes(AuthMethod.BASIC_LOGIN);
+      }
+      this.services.authService.isEnclaveUser = isSLOPossible;
+      yield this.paraCoreInterface.localStorageSetItem(LOCAL_STORAGE_IS_ENCLAVE_USER, JSON.stringify(isSLOPossible));
+      const isExternalWalletFullAuth = (_a = serverAuthState.externalWallet) == null ? void 0 : _a.withFullParaAuth;
+      return __spreadValues(__spreadValues({}, serverAuthState), isSLOPossible || isExternalWalletFullAuth ? {
+        loginUrl: yield this.services.portalUrlService.getLoginUrl({
+          authMethod: AuthMethod.BASIC_LOGIN,
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme
+        })
+      } : {});
+    });
+    this.performVerifyNewAccount = (params) => __async(this, null, function* () {
+      this.services.authService.assertIsAuthSet(["email", "phone"]);
+      const _a = params, { verificationCode } = _a, urlOptions = __objRest(_a, ["verificationCode"]);
+      const serverAuthState = yield this.paraCoreInterface.ctx.client.verifyAccount(this.services.authService.userId, {
+        verificationCode
+      });
+      if (serverAuthState.stage === "login" || serverAuthState.stage === "done") {
+        throw new Error("Account already exists.");
+      }
+      yield this.services.sessionManagementService.touchSession(true);
+      return { authState: serverAuthState, opts: urlOptions };
+    });
+    this.verifyNewAccount = (params) => __async(this, null, function* () {
+      this.stateManager.send({ type: "VERIFY_NEW_ACCOUNT", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [{ phase: "awaiting_session_start", onPhase: (state) => state.authStateResult }]
+      });
+    });
+    this.performVerifyExternalWallet = (params) => __async(this, null, function* () {
+      var _a;
+      let serverAuthState;
+      let urlOptions;
+      if ("serverAuthState" in params && params.serverAuthState !== void 0) {
+        serverAuthState = params.serverAuthState;
+      } else if ("externalWallet" in params) {
+        let signedMessage = params.signedMessage, cosmosPublicKeyHex = params.cosmosPublicKeyHex, cosmosSigner = params.cosmosSigner;
+        const { externalWallet, signatureVerificationMessage, portalTheme, useShortUrls } = params;
+        if (!signedMessage && !signatureVerificationMessage) {
+          throw new Error("One of signedMessage or signatureVerificationMessage is required for verifying external wallet");
+        }
+        if (!signedMessage) {
+          const signResponse = yield this.services.externalWalletService.signMessage({
+            type: externalWallet.type,
+            address: externalWallet.address,
+            message: signatureVerificationMessage
+          });
+          signedMessage = signResponse.signature;
+          cosmosPublicKeyHex = signResponse.cosmosPublicKeyHex;
+          cosmosSigner = signResponse.cosmosSigner;
+        }
+        const _serverAuthState = yield this.paraCoreInterface.ctx.client.verifyExternalWallet(
+          this.services.authService.userId,
+          {
+            externalWallet,
+            signedMessage,
+            cosmosPublicKeyHex,
+            cosmosSigner
+          }
+        );
+        serverAuthState = _serverAuthState;
+        urlOptions = { portalTheme, useShortUrls };
+      }
+      let sessionLookupId;
+      if (serverAuthState.stage === "login" && ((_a = serverAuthState.loginAuthMethods) == null ? void 0 : _a.includes(AuthMethod.PIN))) {
+        sessionLookupId = (yield this.services.sessionManagementService.touchSession()).sessionLookupId;
+      }
+      return { authState: serverAuthState, opts: __spreadValues({}, urlOptions), sessionLookupId };
+    });
+    this.verifyExternalWallet = (params) => __async(this, null, function* () {
+      this.stateManager.send({ type: "VERIFY_EXTERNAL_WALLET", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "awaiting_session_start",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "authenticated",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+    this.retryVerifyExternalWallet = () => __async(this, null, function* () {
+      this.stateManager.send({ type: "VERIFY_EXTERNAL_WALLET" });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "awaiting_wallet_verification",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "awaiting_session_start",
+            onPhase: (state) => state.authStateResult
+          },
+          {
+            phase: "authenticated",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+    this.performVerifyTelegram = (_a) => __async(this, null, function* () {
+      var _b = _a, {
+        serverAuthState: optsServerAuthState,
+        telegramAuthResponse
+      } = _b, urlOptions = __objRest(_b, [
+        "serverAuthState",
+        "telegramAuthResponse"
+      ]);
+      if (!optsServerAuthState && !telegramAuthResponse) {
+        throw new Error("one of serverAuthState or telegramAuthResponse are required for verifying telegram");
+      }
+      const serverAuthState = optsServerAuthState != null ? optsServerAuthState : yield this.paraCoreInterface.ctx.client.verifyTelegram({ authObject: telegramAuthResponse });
+      const { sessionLookupId } = yield this.services.sessionManagementService.touchSession();
+      return { authState: serverAuthState, opts: urlOptions, sessionLookupId };
+    });
+    this.verifyTelegram = (params) => __async(this, null, function* () {
+      this.stateManager.send({ type: "AUTHENTICATE_TELEGRAM_LEGACY", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "awaiting_session_start",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+    this.performVerifyFarcaster = (_c) => __async(this, null, function* () {
+      var _d = _c, { serverAuthState } = _d, urlOptions = __objRest(_d, ["serverAuthState"]);
+      const { sessionLookupId } = yield this.services.sessionManagementService.touchSession();
+      return { authState: serverAuthState, opts: urlOptions, sessionLookupId };
+    });
+    this.verifyFarcaster = (params) => __async(this, null, function* () {
+      this.stateManager.send({ type: "AUTHENTICATE_FARCASTER_LEGACY", data: params });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "awaiting_session_start",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+  }
+}
+export {
+  VerificationFlowService
+};