@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/cjs/services/VerificationFlowService.js

@@ -0,0 +1,242 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var VerificationFlowService_exports = {};
+__export(VerificationFlowService_exports, {
+  VerificationFlowService: () => VerificationFlowService
+});
+module.exports = __toCommonJS(VerificationFlowService_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+var import_BaseAuthFlowService = require("./BaseAuthFlowService.js");
+var import_constants = require("../constants.js");
+var import_stateListener = require("../utils/stateListener.js");
+class VerificationFlowService extends import_BaseAuthFlowService.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(import_user_management_client.AuthMethod.BASIC_LOGIN);
+      } else if (serverAuthState.nextStage === "signup") {
+        isSLOPossible = serverAuthState.signupAuthMethods.includes(import_user_management_client.AuthMethod.BASIC_LOGIN);
+      }
+      this.services.authService.isEnclaveUser = isSLOPossible;
+      yield this.paraCoreInterface.localStorageSetItem(import_constants.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: import_user_management_client.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 (0, import_stateListener.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(import_user_management_client.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 (0, import_stateListener.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 (0, import_stateListener.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 (0, import_stateListener.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 (0, import_stateListener.waitForAuthStateChange)({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "awaiting_session_start",
+            onPhase: (state) => state.authStateResult
+          }
+        ]
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VerificationFlowService
+});