@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/esm/services/PollingService.js

@@ -0,0 +1,389 @@
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+var _authService, _pregenWalletService, _walletService, _portalUrlService, _sessionManagementService, _paraCoreInterface, _activePollingOperations, _pollingCancelFlags, _openOAuthPopup;
+import { PopupType } from "../types/popup.js";
+import { isServerAuthState } from "../utils/types.js";
+import { POLLING_INTERVAL_MS, POLLING_TIMEOUT_MS } from "../constants.js";
+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: 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 = POLLING_INTERVAL_MS,
+        timeoutMs = 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`);
+        }, 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 (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 (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();
+export {
+  PollingService
+};