@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/cjs/services/BaseAuthFlowService.js

@@ -0,0 +1,78 @@
+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 __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 BaseAuthFlowService_exports = {};
+__export(BaseAuthFlowService_exports, {
+  BaseAuthFlowService: () => BaseAuthFlowService
+});
+module.exports = __toCommonJS(BaseAuthFlowService_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+class BaseAuthFlowService {
+  constructor(paraCoreInterface, stateManager, services) {
+    this.paraCoreInterface = paraCoreInterface;
+    this.stateManager = stateManager;
+    this.services = services;
+    // Shared auth setup from server state
+    this.setupAuthFromServerState = (serverAuthState) => __async(this, null, function* () {
+      const { auth, userId, displayName, pfpUrl, username, externalWallet } = serverAuthState;
+      const authInfo = __spreadValues(__spreadValues({}, (0, import_user_management_client.extractAuthInfo)(auth, { isRequired: true })), Object.fromEntries(Object.entries({ displayName, pfpUrl, username, externalWallet }).filter(([_, v]) => !!v)));
+      yield this.services.authService.setAuthInfo(authInfo);
+      this.services.authService.assertIsAuthSet();
+      if (userId) {
+        yield this.services.authService.setUserId(userId);
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAuthFlowService
+});

package/dist/cjs/services/ExternalWalletService.js

@@ -0,0 +1,386 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var ExternalWalletService_exports = {};
+__export(ExternalWalletService_exports, {
+  ExternalWalletService: () => ExternalWalletService
+});
+module.exports = __toCommonJS(ExternalWalletService_exports);
+var import_events = require("../types/events.js");
+var import_constants = require("../constants.js");
+var import_utils = require("../utils/index.js");
+var _stateManager, _authService, _walletService, _paraCoreInterface, _externalWallets, _watchedProviders, _onWalletDisconnected;
+class ExternalWalletService {
+  constructor(paraCore) {
+    __privateAdd(this, _stateManager);
+    __privateAdd(this, _authService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _externalWallets, {});
+    __privateAdd(this, _watchedProviders, /* @__PURE__ */ new Set());
+    this.externalWalletProviderInterfaces = {};
+    this.init = ({
+      authService,
+      walletService,
+      stateManager
+    }) => {
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _stateManager, stateManager);
+    };
+    this.initExternalWalletProvider = (_0) => __async(this, [_0], function* ({ type, interface: providerInterface }) {
+      this.externalWalletProviderInterfaces[type] = providerInterface;
+    });
+    this.waitForProvidersLoading = () => __async(this, null, function* () {
+      const storedWalletTypes = new Set(Object.values(this.externalWallets).map((wallet) => wallet.type));
+      if (storedWalletTypes.size === 0) {
+        return true;
+      }
+      for (let i = 0; i < 20; i++) {
+        const neededProviderInterfaces = Array.from(storedWalletTypes).map((type) => ({
+          type,
+          interface: this.externalWalletProviderInterfaces[type]
+        })).filter(({ interface: providerInterface }) => !!providerInterface);
+        if (neededProviderInterfaces.length !== storedWalletTypes.size) {
+          yield new Promise((resolve) => setTimeout(resolve, 100));
+          continue;
+        }
+        const loadingResults = yield Promise.all(
+          neededProviderInterfaces.map((_0) => __async(this, [_0], function* ({ type, interface: providerInterface }) {
+            try {
+              const providerAddresses = yield providerInterface.getAddress();
+              const storedAddressesForType = Object.values(this.externalWallets).filter((wallet) => wallet.type === type).map((wallet) => Object.keys(this.externalWallets).find((addr) => this.externalWallets[addr] === wallet)).filter(Boolean);
+              const allAddressesAvailable = storedAddressesForType.every((addr) => providerAddresses.includes(addr));
+              return allAddressesAvailable;
+            } catch (error) {
+              console.warn(`Error checking provider ${type}:`, error);
+              return false;
+            }
+          }))
+        );
+        if (loadingResults.every((result) => result === true)) {
+          neededProviderInterfaces.forEach(({ type, interface: providerInterface }) => {
+            if (!__privateGet(this, _watchedProviders).has(type)) {
+              __privateGet(this, _watchedProviders).add(type);
+              providerInterface.watchDisconnection(() => __async(this, null, function* () {
+                yield __privateGet(this, _onWalletDisconnected).call(this);
+              }));
+              providerInterface.watchWalletChange((params) => __async(this, null, function* () {
+                yield this.switchExternalWallet(params);
+              }));
+            }
+          });
+          return true;
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      return false;
+    });
+    this.assertValidConnection = () => __async(this, null, function* () {
+      if (__privateGet(this, _stateManager).getSnapshot().authStatePhase === "switching_external_wallet") {
+        return;
+      }
+      if (this.externalWalletConnectionType === "NONE") {
+        return;
+      }
+      const connectedAddresses = (yield Promise.all(
+        Object.values(this.externalWalletProviderInterfaces).map((providerInterface) => __async(this, null, function* () {
+          return yield providerInterface.getAddress();
+        }))
+      )).filter((a) => !!a);
+      const storedExternalWalletAddresses = Object.keys(this.externalWallets);
+      const someConnectedHaveStoredWallets = connectedAddresses.some(
+        (connectedAddress) => connectedAddress && this.externalWallets[connectedAddress]
+      );
+      const allStoredWalletsAreConnected = storedExternalWalletAddresses.every(
+        (storedAddress) => connectedAddresses.includes(storedAddress)
+      );
+      const validConnection = someConnectedHaveStoredWallets && allStoredWalletsAreConnected;
+      if (!validConnection) {
+        yield __privateGet(this, _paraCoreInterface).logout();
+      }
+    });
+    /**
+     * Function to perform signing a message with an external wallet
+     */
+    this.signMessage = (_0) => __async(this, [_0], function* ({ type, message, address }) {
+      const providerInterface = this.externalWalletProviderInterfaces[type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${type} is not initialized.`);
+      }
+      const signature = yield providerInterface.signMessage({ message, address });
+      return __spreadValues({ address }, signature);
+    });
+    this.connectParaConnectors = () => __async(this, null, function* () {
+      const types = Array.from(new Set(Object.values(__privateGet(this, _walletService).wallets).map((w) => w.type)));
+      for (const type of types) {
+        const providerInterface = this.externalWalletProviderInterfaces[type];
+        if (!providerInterface) {
+          console.error(
+            `External wallet provider interface for type ${type} is not initialized. Para connector will not be connected.`
+          );
+          continue;
+        }
+        try {
+          yield providerInterface.connectParaConnector();
+        } catch (e) {
+        }
+      }
+    });
+    this.performSwitchExternalWallet = (params) => __async(this, null, function* () {
+      if (this.externalWalletConnectionType !== "CONNECTION_ONLY") {
+        throw new Error("Cannot switch external wallets when using Para authentication or wallet verification.");
+      }
+      try {
+        const partner = yield __privateGet(this, _paraCoreInterface).assertPartner();
+        const loginResp = yield __privateGet(this, _authService).performLoginExternalWallet({
+          externalWallet: __spreadProps(__spreadValues({}, params.externalWallet), {
+            partnerId: partner.id,
+            withFullParaAuth: false,
+            withVerification: false
+          })
+        });
+        if (loginResp.authState.stage !== "done" && loginResp.authState.stage !== "verify") {
+          throw new Error("External wallet switch did not complete successfully.");
+        }
+        yield this.setExternalWallet({ externalWallet: [loginResp.authState.externalWallet] });
+        return { externalWallet: loginResp.authState.externalWallet };
+      } catch (error) {
+        console.error("Error during external wallet switch login:", error);
+        throw error;
+      }
+    });
+    this.switchExternalWallet = (params) => __async(this, null, function* () {
+      if (__privateGet(this, _externalWallets)[params.externalWallet.address]) {
+        return;
+      }
+      __privateGet(this, _stateManager).send({ type: "SWITCH_EXTERNAL_WALLET", data: params });
+    });
+    __privateAdd(this, _onWalletDisconnected, () => __async(this, null, function* () {
+      if (this.externalWalletConnectionType === "NONE") {
+        return;
+      }
+      yield __privateGet(this, _paraCoreInterface).logout();
+    }));
+    /**
+     * Function to perform connecting an external wallet
+     */
+    this.performConnectExternalWallet = (_0) => __async(this, [_0], function* ({ connect }) {
+      const connectResp = yield connect();
+      const providerInterface = this.externalWalletProviderInterfaces[connectResp.externalWallet.type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${connectResp.externalWallet.type} is not initialized.`);
+      }
+      if (!__privateGet(this, _watchedProviders).has(connectResp.externalWallet.type)) {
+        __privateGet(this, _watchedProviders).add(connectResp.externalWallet.type);
+        providerInterface.watchDisconnection(() => __async(this, null, function* () {
+          yield __privateGet(this, _onWalletDisconnected).call(this);
+        }));
+        providerInterface.watchWalletChange((params) => __async(this, null, function* () {
+          yield this.switchExternalWallet(params);
+        }));
+      }
+      return connectResp;
+    });
+    this.disconnectExternalWallet = (type) => __async(this, null, function* () {
+      const providerInterface = this.externalWalletProviderInterfaces[type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${type} is not initialized.`);
+      }
+      return yield providerInterface.disconnect();
+    });
+    this.disconnectAllExternalWallets = () => __async(this, null, function* () {
+      const disconnectPromises = Object.values(this.externalWalletProviderInterfaces).map(
+        (providerInterface) => providerInterface.disconnect()
+      );
+      yield Promise.all(disconnectPromises);
+      __privateGet(this, _watchedProviders).clear();
+    });
+    this.setExternalWallet = (_0) => __async(this, [_0], function* ({ externalWallet }) {
+      const { id: partnerId, supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      this.externalWallets = (Array.isArray(externalWallet) ? externalWallet : [externalWallet]).reduce(
+        (acc, {
+          partnerId: wPartnerId,
+          address,
+          type,
+          provider,
+          providerId,
+          addressBech32,
+          withFullParaAuth,
+          isConnectionOnly,
+          withVerification
+        }) => {
+          if (partnerId === wPartnerId && supportedWalletTypes.some(({ type: supportedType }) => supportedType === type)) {
+            return __spreadProps(__spreadValues({}, acc), {
+              [address]: {
+                id: address,
+                partnerId,
+                address: addressBech32 != null ? addressBech32 : address,
+                type,
+                name: provider,
+                isExternal: true,
+                isExternalWithParaAuth: withFullParaAuth,
+                externalProviderId: providerId,
+                signer: "",
+                isExternalConnectionOnly: isConnectionOnly,
+                isExternalWithVerification: withVerification
+              }
+            });
+          } else {
+            if (partnerId !== wPartnerId) {
+              throw new Error(`Partner ID on the wallet does not match the current partner.`);
+            }
+            console.warn(
+              `External wallet with address ${address} and type ${type} is not supported by the current partner, skipping this wallet. Supported wallet types are: ${supportedWalletTypes.map(({ type: supportedType }) => supportedType).join(", ")}`
+            );
+          }
+          return acc;
+        },
+        {}
+      );
+      yield this.setExternalWallets({ externalWallets: this.externalWallets });
+      (0, import_utils.dispatchEvent)(import_events.ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
+    });
+    this.setExternalWallets = (_0) => __async(this, [_0], function* ({ externalWallets }) {
+      if (typeof externalWallets === "function") {
+        this.externalWallets = externalWallets(this.externalWallets);
+      } else {
+        this.externalWallets = externalWallets;
+      }
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(import_constants.LOCAL_STORAGE_EXTERNAL_WALLETS, JSON.stringify(this.externalWallets));
+    });
+    this.addExternalWallets = (_0) => __async(this, [_0], function* ({ externalWallets }) {
+      const { id: partnerId, supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      this.externalWallets = __spreadValues(__spreadValues({}, Object.entries(this.externalWallets).reduce((acc, [address, wallet]) => {
+        if (partnerId === wallet.partnerId && supportedWalletTypes.some(({ type }) => type === wallet.type)) {
+          return __spreadProps(__spreadValues({}, acc), {
+            [address]: wallet
+          });
+        }
+        return acc;
+      }, {})), externalWallets.reduce(
+        (acc, { address, type, provider, providerId, addressBech32, withFullParaAuth, isConnectionOnly, withVerification }) => {
+          return __spreadProps(__spreadValues({}, acc), {
+            [address]: {
+              id: address,
+              partnerId,
+              address: addressBech32 != null ? addressBech32 : address,
+              type,
+              name: provider,
+              isExternal: true,
+              isExternalWithParaAuth: withFullParaAuth,
+              externalProviderId: providerId,
+              signer: "",
+              isExternalConnectionOnly: isConnectionOnly,
+              isExternalWithVerification: withVerification
+            }
+          });
+        },
+        {}
+      ));
+      this.setExternalWallets({ externalWallets: this.externalWallets });
+      (0, import_utils.dispatchEvent)(import_events.ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getExternalWalletServiceInterface());
+  }
+  get externalWalletWithParaAuth() {
+    const externalWallets = Object.values(this.externalWallets);
+    return externalWallets.find((w) => w.isExternalWithParaAuth);
+  }
+  get externalWallets() {
+    return __privateGet(this, _externalWallets);
+  }
+  set externalWallets(value) {
+    __privateSet(this, _externalWallets, value);
+  }
+  get externalWalletConnectionType() {
+    var _a, _b, _c;
+    if ((_a = __privateGet(this, _authService)) == null ? void 0 : _a.isExternalWalletAuth) {
+      return "AUTHENTICATED";
+    } else if ((_b = __privateGet(this, _authService)) == null ? void 0 : _b.isExternalWalletWithVerification) {
+      return "VERIFICATION";
+    } else if (!!Object.keys(this.externalWallets).length) {
+      const hasEmbeddedWallets = Object.keys((_c = __privateGet(this, _walletService)) == null ? void 0 : _c.wallets).some(
+        (id) => {
+          var _a2;
+          return !((_a2 = __privateGet(this, _walletService)) == null ? void 0 : _a2.wallets[id].isExternal);
+        }
+      );
+      if (hasEmbeddedWallets) {
+        return "NONE";
+      } else {
+        return "CONNECTION_ONLY";
+      }
+    }
+    return "NONE";
+  }
+}
+_stateManager = new WeakMap();
+_authService = new WeakMap();
+_walletService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_externalWallets = new WeakMap();
+_watchedProviders = new WeakMap();
+_onWalletDisconnected = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExternalWalletService
+});

package/dist/cjs/services/LoginFlowService.js

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __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 LoginFlowService_exports = {};
+__export(LoginFlowService_exports, {
+  LoginFlowService: () => LoginFlowService
+});
+module.exports = __toCommonJS(LoginFlowService_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+var import_BaseAuthFlowService = require("./BaseAuthFlowService.js");
+var import_utils = require("../cryptography/utils.js");
+var import_events = require("../types/events.js");
+var import_utils2 = require("../utils/index.js");
+var import_stateListener = require("../utils/stateListener.js");
+class LoginFlowService extends import_BaseAuthFlowService.BaseAuthFlowService {
+  constructor() {
+    super(...arguments);
+    this.prepareState = (serverAuthState, opts) => __async(this, null, function* () {
+      var _a, _b;
+      if (!opts.sessionLookupId && (!serverAuthState.externalWallet || !(((_a = serverAuthState.externalWallet) == null ? void 0 : _a.withFullParaAuth) && ((_b = serverAuthState.loginAuthMethods) == null ? void 0 : _b.includes(import_user_management_client.AuthMethod.PIN))))) {
+        opts.sessionLookupId = yield this.services.authService.prepareLogin();
+      }
+      yield this.setupAuthFromServerState(serverAuthState);
+      const _c = serverAuthState, { loginAuthMethods = [], hasPasswordWithoutPIN } = _c, authState = __objRest(_c, ["loginAuthMethods", "hasPasswordWithoutPIN"]);
+      const { useShortUrls: shorten = false, portalTheme, sessionLookupId } = opts;
+      const isPasskeySupported = yield this.paraCoreInterface.isPasskeySupported();
+      const isPasskeyPossible = loginAuthMethods.includes(import_user_management_client.AuthMethod.PASSKEY) && !this.paraCoreInterface.isNativePasskey;
+      const isPasswordPossible = loginAuthMethods.includes(import_user_management_client.AuthMethod.PASSWORD) && hasPasswordWithoutPIN;
+      const isPINPossible = loginAuthMethods.includes(import_user_management_client.AuthMethod.PIN);
+      return __spreadValues(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, authState), {
+        isPasskeySupported,
+        loginAuthMethods
+      }), isPasskeyPossible ? {
+        passkeyUrl: yield this.services.portalUrlService.getLoginUrl({
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme
+        }),
+        passkeyKnownDeviceUrl: yield this.services.portalUrlService.constructPortalUrl("loginAuth", {
+          sessionId: sessionLookupId,
+          newDevice: {
+            sessionId: sessionLookupId,
+            encryptionKey: (0, import_utils.getPublicKeyHex)(this.paraCoreInterface.loginEncryptionKeyPair)
+          },
+          shorten,
+          portalTheme
+        })
+      } : {}), isPasswordPossible ? {
+        passwordUrl: yield this.services.portalUrlService.constructPortalUrl("loginPassword", {
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme,
+          params: { isEmbedded: `${!serverAuthState.isWalletSelectionNeeded}` }
+        })
+      } : {}), isPINPossible ? {
+        pinUrl: yield this.services.portalUrlService.constructPortalUrl("loginPIN", {
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme,
+          params: { isEmbedded: `${!serverAuthState.isWalletSelectionNeeded}` }
+        })
+      } : {});
+    });
+    this.waitForLogin = (params) => __async(this, null, function* () {
+      this.stateManager.send({
+        type: "WAIT_FOR_SESSION",
+        data: __spreadValues({}, params)
+      });
+      return yield (0, import_stateListener.waitForAuthStateChange)({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: () => {
+              const needsWallet = this.stateManager.getSnapshot().needsWallet;
+              (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, true);
+              return {
+                partnerId: this.paraCoreInterface.partnerId,
+                needsWallet: needsWallet || Object.values(this.services.walletService.wallets).length === 0
+              };
+            }
+          }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("canceled")
+          }
+        ],
+        onReject: () => {
+          (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, { isComplete: false }, "failed to setup user");
+        }
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoginFlowService
+});