@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/esm/services/PregenWalletService.js

@@ -0,0 +1,393 @@
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise;
+import {
+  isPregenAuth,
+  toPregenIds,
+  toPregenTypeAndId
+} from "@getpara/user-management-client";
+import {
+  entityToWallet,
+  getEquivalentTypes,
+  isPregenIdentifierMatch,
+  newUuid,
+  WalletSchemeTypeMap
+} from "../utils/wallet.js";
+import { dispatchEvent } from "../utils/index.js";
+import { ParaEvent } from "../types/events.js";
+import { distributeNewShare } from "../shares/shareDistribution.js";
+import { SHORT_POLLING_INTERVAL_MS } from "../constants.js";
+import { waitForCoreStateChange } from "../utils/stateListener.js";
+class PregenWalletService {
+  constructor(paraCore) {
+    __privateAdd(this, _stateManager);
+    __privateAdd(this, _authService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _pollingService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _isCreateGuestWalletsPending, false);
+    __privateAdd(this, _fetchOverridePromise, null);
+    this.init = ({
+      authService,
+      walletService,
+      pollingService,
+      stateManager
+    }) => {
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _pollingService, pollingService);
+      __privateSet(this, _stateManager, stateManager);
+    };
+    this.isPregenWalletUnclaimed = (wallet) => {
+      return __privateGet(this, _walletService).isWalletSupported(wallet) && (!(wallet == null ? void 0 : wallet.userId) || (wallet == null ? void 0 : wallet.isPregen) && !!(wallet == null ? void 0 : wallet.pregenIdentifier) && !!(wallet == null ? void 0 : wallet.pregenIdentifierType));
+    };
+    this.isPregenWalletClaimable = (wallet) => {
+      return __privateGet(this, _walletService).isWalletSupported(wallet) && this.isPregenWalletUnclaimed(wallet) && (!["EMAIL", "PHONE", "TELEGRAM"].includes(wallet == null ? void 0 : wallet.pregenIdentifierType) || isPregenIdentifierMatch(
+        (wallet == null ? void 0 : wallet.pregenIdentifierType) === "EMAIL" ? __privateGet(this, _authService).email : (wallet == null ? void 0 : wallet.pregenIdentifierType) === "TELEGRAM" ? __privateGet(this, _authService).telegramUserId : __privateGet(this, _authService).phone,
+        wallet == null ? void 0 : wallet.pregenIdentifier,
+        wallet == null ? void 0 : wallet.pregenIdentifierType
+      ));
+    };
+    this.fetchPregenWalletsFromOverride = (_0) => __async(this, [_0], function* ({ authInfo }) {
+      if (__privateGet(this, _paraCoreInterface).fetchPregenWalletsOverride && isPregenAuth(authInfo)) {
+        const previous = __privateGet(this, _fetchOverridePromise);
+        __privateSet(this, _fetchOverridePromise, (() => __async(this, null, function* () {
+          if (previous !== null) yield previous.catch(() => {
+          });
+          try {
+            const { userShare } = yield __privateGet(this, _paraCoreInterface).fetchPregenWalletsOverride({ pregenId: authInfo });
+            if (userShare) {
+              yield __privateGet(this, _walletService).setUserShare(userShare);
+            }
+          } finally {
+            __privateSet(this, _fetchOverridePromise, null);
+          }
+        }))());
+        yield __privateGet(this, _fetchOverridePromise);
+      }
+    });
+    this.performClaimPregenWallets = () => __async(this, null, function* () {
+      if (__privateGet(this, _fetchOverridePromise) !== null) {
+        try {
+          yield __privateGet(this, _fetchOverridePromise);
+        } catch (e) {
+        }
+      }
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const pregenWallets = yield this.getPregenWallets();
+      let recoverySecret, walletIds = {};
+      if (pregenWallets.length > 0) {
+        try {
+          const shares = yield __privateGet(this, _paraCoreInterface).ctx.enclaveClient.getPregenShares({
+            userId: __privateGet(this, _authService).userId,
+            walletIds: pregenWallets.map((w) => w.id),
+            partnerId: pregenWallets[0].partnerId
+          });
+          for (const share of shares) {
+            const wallet = pregenWallets.find((w) => w.id === share.walletId);
+            if (wallet) {
+              __privateGet(this, _walletService).wallets[wallet.id] = {
+                id: wallet.id,
+                address: wallet.address,
+                scheme: wallet.scheme,
+                type: wallet.type,
+                partnerId: wallet.partnerId,
+                isPregen: wallet.isPregen,
+                pregenIdentifier: wallet.pregenIdentifier,
+                pregenIdentifierType: wallet.pregenIdentifierType,
+                signer: share.signer,
+                createdAt: String(wallet.createdAt)
+              };
+            }
+          }
+        } catch (err) {
+          console.warn("[performClaimPregenWallets] Failed to fetch pregen shares:", err);
+        }
+        recoverySecret = yield this.claimPregenWallets();
+        walletIds = supportedWalletTypes.reduce((acc, { type }) => {
+          const wallet = pregenWallets.find((w) => !!WalletSchemeTypeMap[w.scheme][type]);
+          if (!wallet) {
+            return acc;
+          }
+          return __spreadProps(__spreadValues({}, acc), {
+            [type]: [wallet.id]
+          });
+        }, {});
+      }
+      yield __privateGet(this, _walletService).addToCurrentWalletIds(walletIds);
+      const resp = { walletIds, recoverySecret };
+      return resp;
+    });
+    this.claimPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
+      var _a;
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const pregenWallets = pregenId ? yield this.getPregenWallets({ pregenId }) : yield this.getPregenWallets();
+      if (pregenWallets.length === 0) {
+        return void 0;
+      }
+      const missingWallets = pregenWallets.filter((wallet) => !__privateGet(this, _walletService).wallets[wallet.id]);
+      if (missingWallets.length > 0) {
+        throw new Error(
+          `Cannot claim pregen wallets because wallet data is missing. Please call setUserShare first to load the wallet data for the following wallet IDs: ${missingWallets.map((w) => w.id).join(", ")}`
+        );
+      }
+      let newRecoverySecret;
+      const { walletIds } = yield __privateGet(this, _paraCoreInterface).ctx.client.claimPregenWallets({
+        userId: __privateGet(this, _authService).userId,
+        walletIds: pregenWallets.map((w) => w.id)
+      });
+      for (const walletId of walletIds) {
+        const wallet = __privateGet(this, _walletService).wallets[walletId];
+        let refreshedShare;
+        if (wallet.scheme === "ED25519") {
+          const distributeRes = yield distributeNewShare({
+            ctx: __privateGet(this, _paraCoreInterface).ctx,
+            userId: __privateGet(this, _authService).userId,
+            walletId: wallet.id,
+            userShare: __privateGet(this, _walletService).wallets[wallet.id].signer,
+            emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+            partnerId: wallet.partnerId,
+            isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+            walletScheme: wallet.scheme
+          });
+          if (distributeRes.length > 0) {
+            newRecoverySecret = distributeRes;
+          }
+        } else {
+          refreshedShare = yield __privateGet(this, _walletService).refreshShare({
+            walletId: wallet.id,
+            share: __privateGet(this, _walletService).wallets[wallet.id].signer,
+            oldPartnerId: wallet.partnerId,
+            newPartnerId: wallet.partnerId,
+            redistributeBackupEncryptedShares: true
+          });
+          if (refreshedShare.recoverySecret) {
+            newRecoverySecret = refreshedShare.recoverySecret;
+          }
+        }
+        __privateGet(this, _walletService).wallets[wallet.id] = __spreadProps(__spreadValues({}, __privateGet(this, _walletService).wallets[wallet.id]), {
+          signer: (_a = refreshedShare == null ? void 0 : refreshedShare.signer) != null ? _a : wallet.signer,
+          userId: __privateGet(this, _authService).userId,
+          pregenIdentifier: void 0,
+          pregenIdentifierType: void 0
+        });
+        const walletNoSigner = __spreadValues({}, __privateGet(this, _walletService).wallets[wallet.id]);
+        delete walletNoSigner.signer;
+        dispatchEvent(ParaEvent.PREGEN_WALLET_CLAIMED, {
+          wallet: walletNoSigner,
+          recoverySecret: newRecoverySecret
+        });
+      }
+      yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+      return newRecoverySecret;
+    });
+    this.getPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
+      const pregenIds = pregenId ? toPregenIds(pregenId) : this.pregenIds;
+      if (!pregenIds || Object.keys(pregenIds).length === 0) {
+        return [];
+      }
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const res = yield __privateGet(this, _paraCoreInterface).ctx.client.getPregenWallets(
+        pregenIds,
+        __privateGet(this, _paraCoreInterface).isPortal(),
+        __privateGet(this, _authService).userId
+      );
+      return res.wallets.filter((w) => __privateGet(this, _walletService).isWalletSupported(entityToWallet(w)));
+    });
+    this.populatePregenWalletAddresses = () => __async(this, null, function* () {
+      const res = yield this.getPregenWallets();
+      res.forEach((entity) => {
+        if (__privateGet(this, _walletService).wallets[entity.id]) {
+          __privateGet(this, _walletService).wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), __privateGet(this, _walletService).wallets[entity.id]);
+        }
+      });
+      yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+    });
+    this.createPregenWallet = (params) => __async(this, null, function* () {
+      var _a, _b;
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const { type: _type = (_a = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type, pregenId } = params;
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const walletType = yield __privateGet(this, _walletService).assertIsValidWalletType(
+        _type != null ? _type : (_b = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _b.type
+      );
+      const [pregenIdentifierType, pregenIdentifier] = toPregenTypeAndId(pregenId);
+      let keygenRes;
+      switch (walletType) {
+        case "SOLANA":
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.ed25519PreKeygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            pregenIdentifier,
+            pregenIdentifierType,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
+          );
+          break;
+        default:
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.preKeygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            void 0,
+            pregenIdentifier,
+            pregenIdentifierType,
+            walletType,
+            null,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
+          );
+          break;
+      }
+      const { signer, walletId } = keygenRes;
+      __privateGet(this, _walletService).wallets[walletId] = {
+        id: walletId,
+        signer,
+        scheme: walletType === "SOLANA" ? "ED25519" : "DKLS",
+        type: walletType,
+        isPregen: true,
+        pregenIdentifier,
+        pregenIdentifierType
+      };
+      yield __privateGet(this, _pollingService).poll({
+        checkCondition: __privateGet(this, _pollingService).waitForPregenWalletAddress({ walletId }),
+        intervalMs: SHORT_POLLING_INTERVAL_MS,
+        maxPolls: 10,
+        id: "waitForPregenWalletAddress"
+      });
+      yield this.populatePregenWalletAddresses();
+      return __privateGet(this, _walletService).wallets[walletId];
+    });
+    this.createPregenWalletPerType = (_0) => __async(this, [_0], function* ({ types, pregenId }) {
+      const wallets = [];
+      for (const type of yield __privateGet(this, _walletService).getTypesToCreate(types)) {
+        const wallet = yield this.createPregenWallet({ type, pregenId });
+        wallets.push(wallet);
+      }
+      return wallets;
+    });
+    this.updatePregenWalletIdentifier = (_0) => __async(this, [_0], function* ({ walletId, newPregenId }) {
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const [newPregenIdentifierType, newPregenIdentifier] = toPregenTypeAndId(newPregenId);
+      yield __privateGet(this, _paraCoreInterface).ctx.client.updatePregenWallet(walletId, {
+        pregenIdentifier: newPregenIdentifier,
+        pregenIdentifierType: newPregenIdentifierType
+      });
+      if (!!__privateGet(this, _walletService).wallets[walletId]) {
+        __privateGet(this, _walletService).wallets[walletId] = __spreadProps(__spreadValues({}, __privateGet(this, _walletService).wallets[walletId]), {
+          pregenIdentifier: newPregenIdentifier,
+          pregenIdentifierType: newPregenIdentifierType
+        });
+        yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+      }
+    });
+    this.hasPregenWallet = (_0) => __async(this, [_0], function* ({ pregenId }) {
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const [pregenIdentifierType, pregenIdentifier] = toPregenTypeAndId(pregenId);
+      const wallets = yield this.getPregenWallets({ pregenId });
+      const wallet = wallets.find(
+        (w) => w.pregenIdentifier === pregenIdentifier && w.pregenIdentifierType === pregenIdentifierType
+      );
+      if (!wallet) {
+        return false;
+      }
+      return true;
+    });
+    this.performCreateGuestWallets = () => __async(this, null, function* () {
+      let error;
+      if (__privateGet(this, _isCreateGuestWalletsPending)) {
+        error = new Error("Guest wallets creation already in progress");
+        dispatchEvent(ParaEvent.GUEST_WALLETS_CREATED, null, error.message);
+        throw error;
+      }
+      if (this.isGuestMode) {
+        error = new Error("Guest wallets already created");
+        dispatchEvent(ParaEvent.GUEST_WALLETS_CREATED, null, error.message);
+        throw error;
+      }
+      try {
+        __privateSet(this, _isCreateGuestWalletsPending, true);
+        const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+        const wallets = [];
+        const guestId = newUuid();
+        for (const type of yield __privateGet(this, _walletService).getTypesToCreate(
+          supportedWalletTypes.filter(({ optional }) => !optional).map(({ type: type2 }) => type2)
+        )) {
+          const wallet = yield this.createPregenWallet({ type, pregenId: { guestId } });
+          wallets.push(wallet);
+        }
+        dispatchEvent(ParaEvent.GUEST_WALLETS_CREATED, wallets);
+        __privateSet(this, _isCreateGuestWalletsPending, false);
+        return wallets;
+      } catch (error2) {
+        dispatchEvent(ParaEvent.GUEST_WALLETS_CREATED, null, error2 == null ? void 0 : error2.message);
+        __privateSet(this, _isCreateGuestWalletsPending, false);
+        throw error2;
+      }
+    });
+    this.createGuestWallets = () => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "INITIALIZE_GUEST_MODE" });
+      return yield waitForCoreStateChange({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [{ phase: "guest_mode", onPhase: (state) => state.guestWallets }]
+      });
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getPregenWalletServiceInterface());
+  }
+  /**
+   * A map of pre-generated wallet identifiers that can be claimed in the current instance.
+   */
+  get pregenIds() {
+    return __spreadValues({}, Object.values(__privateGet(this, _walletService).wallets).filter((wallet) => !__privateGet(this, _authService).userId || this.isPregenWalletClaimable(wallet)).reduce((acc, wallet) => {
+      var _a, _b;
+      if (((_a = acc[wallet.pregenIdentifierType]) != null ? _a : []).includes(wallet.pregenIdentifier)) {
+        return acc;
+      }
+      return __spreadProps(__spreadValues({}, acc), {
+        [wallet.pregenIdentifierType]: [
+          .../* @__PURE__ */ new Set([...(_b = acc[wallet.pregenIdentifierType]) != null ? _b : [], wallet.pregenIdentifier])
+        ]
+      });
+    }, {}));
+  }
+  get guestWalletIds() {
+    var _a, _b, _c;
+    if (!((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.supportedWalletTypes)) {
+      return {};
+    }
+    const guestId = (_c = (_b = this.pregenIds) == null ? void 0 : _b.GUEST_ID) == null ? void 0 : _c[0];
+    return !!guestId ? Object.entries(__privateGet(this, _walletService).wallets).reduce((acc, [id, wallet]) => {
+      if (wallet.isPregen && !wallet.userId && wallet.pregenIdentifierType === "GUEST_ID" && wallet.pregenIdentifier === guestId) {
+        return __spreadValues(__spreadValues({}, acc), getEquivalentTypes(wallet.type).filter((type) => __privateGet(this, _paraCoreInterface).partner.supportedWalletTypes.some((entry) => entry.type === type)).reduce((acc2, eqType) => {
+          var _a2;
+          return __spreadProps(__spreadValues({}, acc2), { [eqType]: [.../* @__PURE__ */ new Set([...(_a2 = acc2[eqType]) != null ? _a2 : [], id])] });
+        }, {}));
+      }
+      return acc;
+    }, {}) : {};
+  }
+  get guestWalletIdsArray() {
+    return Object.entries(this.guestWalletIds).reduce((acc, [type, ids]) => {
+      return [...acc, ...ids.map((id) => [id, type])];
+    }, []);
+  }
+  get isGuestMode() {
+    return this.guestWalletIdsArray.length > 0 && Object.values(__privateGet(this, _walletService).wallets).every(
+      ({ userId, partnerId }) => {
+        var _a;
+        return partnerId === ((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.id) && (!userId || userId !== __privateGet(this, _authService).userId);
+      }
+    );
+  }
+}
+_stateManager = new WeakMap();
+_authService = new WeakMap();
+_walletService = new WeakMap();
+_pollingService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_isCreateGuestWalletsPending = new WeakMap();
+_fetchOverridePromise = new WeakMap();
+export {
+  PregenWalletService
+};

package/dist/esm/services/SessionManagementService.js

@@ -0,0 +1,236 @@
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "../chunk-7B52C2XE.js";
+var _authService, _portalUrlService, _walletService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _isImportedSession, _regeneratePromise, _handleTouchSessionError, _doTouchSession;
+import { currentWalletIdsEq, supportedWalletTypesEq } from "../utils/wallet.js";
+class SessionManagementService {
+  constructor(paraCore) {
+    __privateAdd(this, _authService);
+    __privateAdd(this, _portalUrlService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _pregenWalletService);
+    __privateAdd(this, _externalWalletService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _isImportedSession);
+    __privateAdd(this, _regeneratePromise);
+    this.init = ({
+      authService,
+      portalUrlService,
+      walletService,
+      externalWalletService,
+      pregenWalletService
+    }) => {
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _portalUrlService, portalUrlService);
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _externalWalletService, externalWalletService);
+      __privateSet(this, _pregenWalletService, pregenWalletService);
+    };
+    /**
+     * Handle specific touchSession errors with user-friendly messages
+     * @private
+     */
+    __privateAdd(this, _handleTouchSessionError, (error) => {
+      const errorStr = String(error);
+      const errorMessage = error instanceof Error ? error.message : "";
+      if (errorStr.includes("blocked by CORS policy") && errorStr.includes("Access-Control-Allow-Origin")) {
+        const message = "Request rate limit reached. Please wait a couple of minutes and try again.";
+        console.error(`[Para] ${message}`);
+        __privateGet(this, _paraCoreInterface).displayModalError(message);
+        return;
+      }
+      if (error.status === 403 && errorMessage.includes("origin not authorized")) {
+        __privateGet(this, _paraCoreInterface).displayModalError(
+          "The current origin is not allowed. Update your allowed origins in the Para developer portal to allow the current origin."
+        );
+        return;
+      }
+    });
+    this.touchSession = (regenerate = false) => __async(this, null, function* () {
+      if (regenerate && __privateGet(this, _regeneratePromise) !== void 0) {
+        return __privateGet(this, _regeneratePromise);
+      }
+      const promise = __privateGet(this, _doTouchSession).call(this, regenerate);
+      if (regenerate) {
+        __privateSet(this, _regeneratePromise, promise);
+        yield promise.finally(() => {
+          __privateSet(this, _regeneratePromise, void 0);
+        });
+      }
+      return promise;
+    });
+    __privateAdd(this, _doTouchSession, (regenerate) => __async(this, null, function* () {
+      var _a, _b;
+      if (!__privateGet(this, _paraCoreInterface).isWorkerInitialized) {
+        void __privateGet(this, _paraCoreInterface).initializeWorker();
+      }
+      let session;
+      try {
+        session = yield __privateGet(this, _paraCoreInterface).ctx.client.touchSession(regenerate);
+      } catch (error) {
+        __privateGet(this, _handleTouchSessionError).call(this, error);
+        throw error;
+      }
+      if (!__privateGet(this, _paraCoreInterface).partner || __privateGet(this, _paraCoreInterface).partner.id !== session.partnerId || !supportedWalletTypesEq(__privateGet(this, _paraCoreInterface).partner.supportedWalletTypes || [], session.supportedWalletTypes) || (__privateGet(this, _paraCoreInterface).partner.cosmosPrefix || "cosmos") !== session.cosmosPrefix) {
+        if (!session.partnerId && !__privateGet(this, _paraCoreInterface).isPortal()) {
+          __privateGet(this, _paraCoreInterface).displayModalError(
+            `Invalid API Key. Please ensure you have a valid API key for the current environment: ${(_a = __privateGet(this, _paraCoreInterface).ctx.env) == null ? void 0 : _a.toUpperCase()}.`
+          );
+          console.error(`
+  \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+  \u{1F6A8} PARA SDK CONFIGURATION ERROR \u{1F6A8}
+
+  INVALID API KEY FOR CONFIGURED ENVIRONMENT
+
+  Your API key does not match the configured environment. This usually means:
+
+  1. You're using a production API key with a development environment
+  2. You're using a development API key with a production environment
+  3. Your API key is invalid or has been regenerated
+
+  SOLUTION:
+  \u2022 Verify your API key at: https://developer.getpara.com
+  \u2022 If your API key doesn't contain an environment prefix, ensure your API key is the correct key for your target environment
+
+  Current Environment: ${__privateGet(this, _paraCoreInterface).ctx.env}
+  API Key Prefix: ${((_b = __privateGet(this, _paraCoreInterface).ctx.apiKey) == null ? void 0 : _b.split("_")[0].toUpperCase()) || "None"}
+
+  Need help? Visit: https://docs.getpara.com or contact support
+  \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+          `);
+          throw new Error("Invalid API Key.");
+        } else {
+          yield __privateGet(this, _paraCoreInterface).getPartner(session.partnerId);
+        }
+      }
+      if (session.currentWalletIds && !currentWalletIdsEq(session.currentWalletIds, __privateGet(this, _walletService).currentWalletIds)) {
+        yield __privateGet(this, _walletService).setCurrentWalletIds(session.currentWalletIds);
+      }
+      return session;
+    }));
+    this.isSessionActive = () => __async(this, null, function* () {
+      if (__privateGet(this, _externalWalletService).externalWalletConnectionType === "CONNECTION_ONLY") {
+        return true;
+      }
+      const { isAuthenticated, verifiedExternalWalletAddresses } = yield this.touchSession();
+      if (__privateGet(this, _externalWalletService).externalWalletConnectionType === "VERIFICATION") {
+        if (!verifiedExternalWalletAddresses) {
+          return false;
+        }
+        const externalAddresses = Object.values(__privateGet(this, _externalWalletService).externalWallets).map((w) => w.id);
+        return externalAddresses.every((address) => verifiedExternalWalletAddresses.includes(address));
+      }
+      return !!isAuthenticated;
+    });
+    this.isFullyLoggedIn = () => __async(this, null, function* () {
+      if (!__privateGet(this, _paraCoreInterface).isReady) {
+        return false;
+      }
+      if (!this.isImportedSession && __privateGet(this, _externalWalletService).externalWalletConnectionType !== "NONE") {
+        yield __privateGet(this, _externalWalletService).assertValidConnection();
+      }
+      if (__privateGet(this, _externalWalletService).externalWalletConnectionType === "CONNECTION_ONLY") {
+        return true;
+      }
+      if (__privateGet(this, _pregenWalletService).isGuestMode) {
+        return true;
+      }
+      const isSessionActive = yield this.isSessionActive();
+      if (__privateGet(this, _externalWalletService).externalWalletConnectionType === "VERIFICATION") {
+        return isSessionActive;
+      }
+      if (__privateGet(this, _paraCoreInterface).isSwitchingWallets) {
+        return isSessionActive;
+      }
+      if (!isSessionActive) {
+        return false;
+      }
+      if (__privateGet(this, _paraCoreInterface).isNoWalletConfig) {
+        return true;
+      }
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const requiredWalletTypes = supportedWalletTypes.filter(({ optional }) => !optional);
+      for (const { type } of requiredWalletTypes) {
+        const hasWalletForType = __privateGet(this, _walletService).currentWalletIdsArray.some(([walletId, walletType]) => {
+          try {
+            const wallet = __privateGet(this, _walletService).wallets[walletId];
+            return wallet && walletType === type && typeof wallet.address === "string";
+          } catch (e) {
+            return false;
+          }
+        });
+        if (!hasWalletForType) {
+          return false;
+        }
+      }
+      const allWalletsLoaded = __privateGet(this, _walletService).currentWalletIdsArray.every(([walletId]) => {
+        const wallet = __privateGet(this, _walletService).wallets[walletId];
+        return wallet && typeof wallet.address === "string";
+      });
+      if (!allWalletsLoaded) {
+        return false;
+      }
+      return true;
+    });
+    this.refreshSession = (..._0) => __async(this, [..._0], function* ({ shouldOpenPopup = false } = {}) {
+      const { sessionId } = yield this.touchSession(true);
+      if (!__privateGet(this, _paraCoreInterface).loginEncryptionKeyPair) {
+        yield __privateGet(this, _paraCoreInterface).setLoginEncryptionKeyPair();
+      }
+      const link = yield __privateGet(this, _portalUrlService).getLoginUrl({
+        sessionId
+      });
+      if (shouldOpenPopup) {
+        yield __privateGet(this, _paraCoreInterface).platformUtils.openPopup(link);
+      }
+      return link;
+    });
+    this.keepSessionAlive = () => __async(this, null, function* () {
+      try {
+        yield __privateGet(this, _paraCoreInterface).ctx.client.keepSessionAlive(__privateGet(this, _authService).userId);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+    this.getVerificationToken = () => __async(this, null, function* () {
+      const { sessionLookupId } = yield this.touchSession();
+      return sessionLookupId;
+    });
+    this.issueJwt = (..._0) => __async(this, [..._0], function* ({ keyIndex = 0 } = {}) {
+      try {
+        return yield __privateGet(this, _paraCoreInterface).ctx.client.issueJwt({ keyIndex });
+      } catch (error) {
+        if (error.status === 403 || error.status === 401) {
+          const errorMessage = "The user needs to be logged in to issue a JWT. Please log in and try again.";
+          __privateGet(this, _paraCoreInterface).displayModalError(errorMessage);
+          console.warn(errorMessage);
+        }
+        throw error;
+      }
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getSessionManagementServiceInterface());
+  }
+  get isImportedSession() {
+    return __privateGet(this, _isImportedSession) || false;
+  }
+  set isImportedSession(value) {
+    __privateSet(this, _isImportedSession, value);
+  }
+}
+_authService = new WeakMap();
+_portalUrlService = new WeakMap();
+_walletService = new WeakMap();
+_pregenWalletService = new WeakMap();
+_externalWalletService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_isImportedSession = new WeakMap();
+_regeneratePromise = new WeakMap();
+_handleTouchSessionError = new WeakMap();
+_doTouchSession = new WeakMap();
+export {
+  SessionManagementService
+};