@getpara/core-sdk 2.11.0 → 2.13.0

package/dist/cjs/services/PollingService.js

@@ -0,0 +1,448 @@
+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 PollingService_exports = {};
+__export(PollingService_exports, {
+  PollingService: () => PollingService
+});
+module.exports = __toCommonJS(PollingService_exports);
+var import_popup = require("../types/popup.js");
+var import_types = require("../utils/types.js");
+var import_constants = require("../constants.js");
+var _authService, _pregenWalletService, _walletService, _portalUrlService, _sessionManagementService, _paraCoreInterface, _activePollingOperations, _pollingCancelFlags, _openOAuthPopup;
+class PollingService {
+  constructor(paraCore) {
+    __privateAdd(this, _authService);
+    __privateAdd(this, _pregenWalletService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _portalUrlService);
+    __privateAdd(this, _sessionManagementService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _activePollingOperations, /* @__PURE__ */ new Set());
+    __privateAdd(this, _pollingCancelFlags, /* @__PURE__ */ new Map());
+    this.init = ({
+      authService,
+      pregenWalletService,
+      walletService,
+      portalUrlService,
+      sessionManagementService
+    }) => {
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _pregenWalletService, pregenWalletService);
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _portalUrlService, portalUrlService);
+      __privateSet(this, _sessionManagementService, sessionManagementService);
+    };
+    __privateAdd(this, _openOAuthPopup, () => __async(this, null, function* () {
+      try {
+        __privateGet(this, _paraCoreInterface).popupWindow = yield __privateGet(this, _paraCoreInterface).platformUtils.openPopup("about:blank", {
+          type: import_popup.PopupType.OAUTH
+        });
+      } catch (error) {
+        throw new Error(`Failed to open OAuth popup: ${error}`);
+      }
+    }));
+    /**
+     * Cancels all active polling operations
+     * Useful for cleanup during logout or app shutdown
+     */
+    this.cancelAllPolling = () => {
+      __privateGet(this, _paraCoreInterface).devLog(
+        `[PollingService] Canceling ${__privateGet(this, _activePollingOperations).size} active polling operations`
+      );
+      __privateGet(this, _pollingCancelFlags).forEach((cancelFlag) => {
+        cancelFlag.canceled = true;
+      });
+      __privateGet(this, _activePollingOperations).clear();
+      __privateGet(this, _pollingCancelFlags).clear();
+      if (__privateGet(this, _paraCoreInterface).popupWindow && !__privateGet(this, _paraCoreInterface).popupWindow.closed) {
+        __privateGet(this, _paraCoreInterface).popupWindow.close();
+        __privateGet(this, _paraCoreInterface).popupWindow = null;
+      }
+    };
+    this.poll = (config) => __async(this, null, function* () {
+      const {
+        init,
+        checkCondition,
+        maxPolls = 150,
+        intervalMs = import_constants.POLLING_INTERVAL_MS,
+        timeoutMs = import_constants.POLLING_TIMEOUT_MS,
+        onPoll,
+        onCancel,
+        isCanceled,
+        id = "genericPolling"
+      } = config;
+      const pollingId = `${id}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      __privateGet(this, _activePollingOperations).add(pollingId);
+      const cancelFlag = { canceled: false };
+      __privateGet(this, _pollingCancelFlags).set(pollingId, cancelFlag);
+      const cleanup = () => {
+        __privateGet(this, _activePollingOperations).delete(pollingId);
+        __privateGet(this, _pollingCancelFlags).delete(pollingId);
+      };
+      const isOperationCanceled = () => {
+        return cancelFlag.canceled || (isCanceled == null ? void 0 : isCanceled());
+      };
+      let pollCount = 0;
+      let consecutiveErrors = 0;
+      let hasInitialized = false;
+      const startTime = Date.now();
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      try {
+        if (!hasInitialized && init) {
+          yield init();
+          hasInitialized = true;
+        }
+        while (pollCount < maxPolls) {
+          if (isOperationCanceled()) {
+            cleanup();
+            onCancel == null ? void 0 : onCancel();
+            return { type: "CANCEL" };
+          }
+          if (Date.now() - startTime > timeoutMs) {
+            cleanup();
+            onCancel == null ? void 0 : onCancel();
+            return { type: "ERROR", error: "TIMEOUT" };
+          }
+          try {
+            const { finished, data } = yield checkCondition();
+            consecutiveErrors = 0;
+            if (finished) {
+              cleanup();
+              return { type: "COMPLETE", data };
+            }
+            pollCount++;
+            __privateGet(this, _paraCoreInterface).devLog(`[${id}] Poll iteration`, {
+              pollCount,
+              elapsedMs: Date.now() - startTime
+            });
+            onPoll == null ? void 0 : onPoll();
+            if (pollCount < maxPolls) {
+              yield sleep(intervalMs);
+            }
+          } catch (error) {
+            consecutiveErrors++;
+            if (consecutiveErrors >= 3) {
+              console.warn(`[${id}] ${consecutiveErrors} consecutive polling errors`, error);
+            }
+            pollCount++;
+            onPoll == null ? void 0 : onPoll();
+            if (pollCount < maxPolls) {
+              yield sleep(intervalMs);
+            }
+          }
+        }
+        cleanup();
+        onCancel == null ? void 0 : onCancel();
+        return { type: "ERROR", error: "MAX_POLLS_EXCEEDED" };
+      } catch (error) {
+        console.error("Polling initialization error:", error);
+        cleanup();
+        onCancel == null ? void 0 : onCancel();
+        return { type: "ERROR", error: "INITIALIZATION_FAILED" };
+      }
+    });
+    this.waitForOAuthEvent = (_0) => __async(this, [_0], function* ({
+      method,
+      onOAuthPopup,
+      onOAuthUrl,
+      portalTheme,
+      useShortUrls,
+      isCanceled,
+      appScheme
+    }) {
+      const oAuthConfigs = {
+        TELEGRAM: {
+          name: "Telegram",
+          portalUrlType: "telegramLoginVerify",
+          events: {
+            success: "TELEGRAM_SUCCESS",
+            failed: "TELEGRAM_FAILED"
+          }
+        },
+        FARCASTER: {
+          name: "Farcaster",
+          portalUrlType: "loginFarcaster",
+          events: {
+            success: "FARCASTER_SUCCESS",
+            failed: "FARCASTER_FAILED"
+          }
+        }
+      };
+      const config = oAuthConfigs[method];
+      const operationId = `waitForOAuthEvent_${method}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+      __privateGet(this, _activePollingOperations).add(operationId);
+      const cancelFlag = { canceled: false };
+      __privateGet(this, _pollingCancelFlags).set(operationId, cancelFlag);
+      const cleanup = () => {
+        __privateGet(this, _activePollingOperations).delete(operationId);
+        __privateGet(this, _pollingCancelFlags).delete(operationId);
+      };
+      const isOperationCanceled = () => {
+        return cancelFlag.canceled || (isCanceled == null ? void 0 : isCanceled());
+      };
+      if (onOAuthPopup) {
+        yield __privateGet(this, _openOAuthPopup).call(this);
+      }
+      yield __privateGet(this, _authService).prepareLogin();
+      const oAuthUrl = yield __privateGet(this, _portalUrlService).constructPortalUrl(config.portalUrlType, {
+        portalTheme,
+        shorten: useShortUrls,
+        appScheme
+      });
+      if (onOAuthUrl) {
+        onOAuthUrl(oAuthUrl);
+      } else if (!!__privateGet(this, _paraCoreInterface).popupWindow) {
+        __privateGet(this, _paraCoreInterface).popupWindow.location.href = oAuthUrl;
+        onOAuthPopup(__privateGet(this, _paraCoreInterface).popupWindow);
+      }
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        let timeoutId;
+        let cancelCheckInterval;
+        const cleanupAll = () => {
+          __privateGet(this, _paraCoreInterface).platformUtils.removeEventListener({
+            event: config.events.success,
+            handler: successHandler
+          });
+          __privateGet(this, _paraCoreInterface).platformUtils.removeEventListener({
+            event: config.events.failed,
+            handler: errorHandler
+          });
+          if (timeoutId) clearTimeout(timeoutId);
+          if (cancelCheckInterval) clearInterval(cancelCheckInterval);
+          cleanup();
+        };
+        const successHandler = (eventData) => {
+          if (settled) return;
+          settled = true;
+          cleanupAll();
+          resolve({ authState: eventData.payload, opts: { portalTheme, useShortUrls } });
+        };
+        const errorHandler = () => {
+          if (settled) return;
+          settled = true;
+          cleanupAll();
+          reject(`${config.name} authentication failed`);
+        };
+        __privateGet(this, _paraCoreInterface).platformUtils.addEventListener({
+          ctx: __privateGet(this, _paraCoreInterface).ctx,
+          event: config.events.success,
+          handler: successHandler
+        });
+        __privateGet(this, _paraCoreInterface).platformUtils.addEventListener({
+          ctx: __privateGet(this, _paraCoreInterface).ctx,
+          event: config.events.failed,
+          handler: errorHandler
+        });
+        cancelCheckInterval = setInterval(() => {
+          if (isOperationCanceled()) {
+            if (settled) return;
+            settled = true;
+            cleanupAll();
+            reject(`${config.name} authentication canceled`);
+          }
+        }, 100);
+        timeoutId = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanupAll();
+          reject(`${config.name} authentication timed out`);
+        }, import_constants.POLLING_TIMEOUT_MS);
+      });
+    });
+    this.waitForTelegramEvent = (params) => __async(this, null, function* () {
+      return yield this.waitForOAuthEvent(__spreadProps(__spreadValues({}, params), { method: "TELEGRAM" }));
+    });
+    this.waitForFarcasterEvent = (params) => __async(this, null, function* () {
+      return yield this.waitForOAuthEvent(__spreadProps(__spreadValues({}, params), { method: "FARCASTER" }));
+    });
+    this.waitForFarcasterAuth = ({ onSuccess }) => () => __async(this, null, function* () {
+      try {
+        const serverAuthState = yield __privateGet(this, _paraCoreInterface).ctx.client.getFarcasterAuthStatus();
+        if ((0, import_types.isServerAuthState)(serverAuthState)) {
+          onSuccess == null ? void 0 : onSuccess(serverAuthState);
+          return { finished: true };
+        }
+        return { finished: false };
+      } catch (e) {
+        return { finished: false };
+      }
+    });
+    this.initOAuthPolling = (_0) => __async(this, [_0], function* ({ onOAuthPopup, onOAuthUrl, method, appScheme }) {
+      if (onOAuthPopup) {
+        yield __privateGet(this, _openOAuthPopup).call(this);
+      }
+      let sessionLookupId;
+      if (onOAuthUrl || onOAuthPopup) {
+        sessionLookupId = yield __privateGet(this, _authService).prepareLogin();
+        const oAuthUrl = yield __privateGet(this, _portalUrlService).getOAuthUrl({
+          method,
+          appScheme,
+          sessionLookupId
+        });
+        switch (true) {
+          case !!onOAuthUrl: {
+            onOAuthUrl(oAuthUrl);
+            break;
+          }
+          case (!!onOAuthPopup && !!__privateGet(this, _paraCoreInterface).popupWindow): {
+            __privateGet(this, _paraCoreInterface).popupWindow.location.href = oAuthUrl;
+            onOAuthPopup(__privateGet(this, _paraCoreInterface).popupWindow);
+            break;
+          }
+        }
+      } else {
+        ({ sessionLookupId } = yield __privateGet(this, _sessionManagementService).touchSession());
+      }
+      return { sessionLookupId };
+    });
+    this.waitForOAuth = ({ onSuccess }) => () => __async(this, null, function* () {
+      try {
+        const serverAuthState = yield __privateGet(this, _paraCoreInterface).ctx.client.verifyOAuth();
+        if ((0, import_types.isServerAuthState)(serverAuthState)) {
+          onSuccess == null ? void 0 : onSuccess(serverAuthState);
+          return { finished: true };
+        }
+        return { finished: false };
+      } catch (e) {
+        return { finished: false };
+      }
+    });
+    this.waitForSession = () => __async(this, null, function* () {
+      __privateGet(this, _paraCoreInterface).devLog("[waitForSession] Checking session");
+      const isActive = yield __privateGet(this, _sessionManagementService).isSessionActive();
+      __privateGet(this, _paraCoreInterface).devLog(`[waitForSession] Session active: ${isActive}`);
+      return { finished: isActive };
+    });
+    this.waitForWallets = ({ parent }) => () => __async(this, null, function* () {
+      var _a;
+      const isPortal = __privateGet(this, _paraCoreInterface).isPortal();
+      const session = yield __privateGet(this, _sessionManagementService).touchSession();
+      yield __privateGet(this, _authService).setUserId(session.userId);
+      if (session.currentWalletIds && session.currentWalletIds !== __privateGet(this, _walletService).currentWalletIds)
+        yield __privateGet(this, _walletService).setCurrentWalletIds(session.currentWalletIds, {
+          sessionLookupId: isPortal ? session.sessionLookupId : void 0
+        });
+      const needsWallet = (_a = session.needsWallet) != null ? _a : false;
+      parent.send({ type: "SET_NEEDS_WALLET", data: { needsWallet } });
+      if (!needsWallet) {
+        if (__privateGet(this, _walletService).currentWalletIdsArray.length === 0) {
+          return { finished: false };
+        }
+      }
+      const sessionLookupId = session.sessionLookupId;
+      const temporaryShares = (yield __privateGet(this, _paraCoreInterface).ctx.client.getTransmissionKeyshares(__privateGet(this, _authService).userId, sessionLookupId)).data.temporaryShares;
+      parent.send({ type: "SET_TEMPORARY_SHARES", data: { temporaryShares } });
+      let hasSharesForCurrentWallets;
+      if (!isPortal) {
+        const fetchedWallets = yield __privateGet(this, _walletService).fetchWallets();
+        hasSharesForCurrentWallets = temporaryShares.length === fetchedWallets.length;
+      } else {
+        hasSharesForCurrentWallets = __privateGet(this, _walletService).currentWalletIdsArray.every(([walletId]) => {
+          return temporaryShares.some((share) => share.walletId === walletId);
+        });
+      }
+      if (hasSharesForCurrentWallets) {
+        return { finished: true };
+      }
+      return { finished: false };
+    });
+    this.waitForWalletAddress = ({ walletId }) => () => __async(this, null, function* () {
+      try {
+        const res = yield (__privateGet(this, _paraCoreInterface).isPortal() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets : __privateGet(this, _paraCoreInterface).ctx.client.getWallets)(__privateGet(this, _authService).userId);
+        const wallet = res.data.wallets.find((w) => w.id === walletId);
+        if (wallet && wallet.address) {
+          return { finished: true };
+        }
+        return { finished: false };
+      } catch (e) {
+        return { finished: false };
+      }
+    });
+    this.waitForPregenWalletAddress = ({ walletId }) => () => __async(this, null, function* () {
+      try {
+        const res = yield __privateGet(this, _pregenWalletService).getPregenWallets();
+        const wallet = res.find((w) => w.id === walletId);
+        if (wallet && wallet.address) {
+          return { finished: true };
+        }
+        return { finished: false };
+      } catch (e) {
+        return { finished: false };
+      }
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getPollingServiceInterface());
+  }
+}
+_authService = new WeakMap();
+_pregenWalletService = new WeakMap();
+_walletService = new WeakMap();
+_portalUrlService = new WeakMap();
+_sessionManagementService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_activePollingOperations = new WeakMap();
+_pollingCancelFlags = new WeakMap();
+_openOAuthPopup = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PollingService
+});