@embarkai/ui-kit 0.4.20 → 0.4.22

package/dist/chunk-ISXWRCDC.js

@@ -0,0 +1,1514 @@
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-DBFKMKYT.js";
+
+// src/config/assets.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var GoogleIcon, TelegramIcon, TwitterIcon, DiscordIcon;
+var init_assets = __esm({
+  "src/config/assets.tsx"() {
+    GoogleIcon = ({ className }) => /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 24 24", className, children: [
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          fill: "#4285F4",
+          d: "M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          fill: "#34A853",
+          d: "M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          fill: "#FBBC05",
+          d: "M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          fill: "#EA4335",
+          d: "M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+        }
+      )
+    ] });
+    TelegramIcon = ({ className }) => /* @__PURE__ */ jsx("svg", { viewBox: "0 0 24 24", className, fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M9.78 18.65l.28-4.23 7.68-6.92c.34-.31-.07-.46-.52-.19L7.74 13.3 3.64 12c-.88-.25-.89-.86.2-1.3l15.97-6.16c.73-.33 1.43.18 1.15 1.3l-2.72 12.81c-.19.91-.74 1.13-1.5.71L12.6 16.3l-1.99 1.93c-.23.23-.42.42-.83.42z" }) });
+    TwitterIcon = ({ className }) => /* @__PURE__ */ jsx("svg", { viewBox: "0 0 24 24", className, fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z" }) });
+    DiscordIcon = ({ className }) => /* @__PURE__ */ jsx("svg", { viewBox: "0 0 24 24", className, children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        fill: "currentColor",
+        d: "M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515a.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0a12.64 12.64 0 0 0-.617-1.25a.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057a19.9 19.9 0 0 0 5.993 3.03a.078.078 0 0 0 .084-.028a14.09 14.09 0 0 0 1.226-1.994a.076.076 0 0 0-.041-.106a13.107 13.107 0 0 1-1.872-.892a.077.077 0 0 1-.008-.128a10.2 10.2 0 0 0 .372-.292a.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127a12.299 12.299 0 0 1-1.873.892a.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028a19.839 19.839 0 0 0 6.002-3.03a.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.956-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.955-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.946 2.418-2.157 2.418Z"
+      }
+    ) });
+  }
+});
+
+// src/config/initial.tsx
+var initial_exports = {};
+__export(initial_exports, {
+  DEFAULT_PROVIDER_CONFIG: () => DEFAULT_PROVIDER_CONFIG,
+  getBlockscoutApiUrl: () => getBlockscoutApiUrl,
+  getIframeUrl: () => getIframeUrl,
+  getServiceUrls: () => getServiceUrls
+});
+import { BSC_TESTNET } from "@embarkai/core/read";
+function getServiceUrls() {
+  const config = DEFAULT_PROVIDER_CONFIG;
+  const globalOverride = typeof window !== "undefined" && window.__EMBARK_SERVICES__ || {};
+  const searchParams = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : void 0;
+  const paramTss = searchParams?.get("tssUrl") || void 0;
+  const paramVault = searchParams?.get("shareVaultUrl") || void 0;
+  const paramDashboard = searchParams?.get("dashboardApiUrl") || void 0;
+  const buildTss = "https://api.lumiapassport.com/tss";
+  const buildVault = "https://api.lumiapassport.com/vault";
+  const buildRequireWasm = false;
+  const buildWasmDebug = false;
+  const defaultTss = "/tss";
+  const defaultVault = "/vault";
+  const result = {
+    tssUrl: paramTss || globalOverride.tssUrl || buildTss || config.services.tssUrl || defaultTss,
+    shareVaultUrl: paramVault || globalOverride.shareVaultUrl || buildVault || config.services.shareVaultUrl || defaultVault,
+    dashboardApiUrl: paramDashboard || globalOverride.dashboardApiUrl || config.services.dashboardApiUrl || "https://dashboard.lumiapassport.com/api",
+    tssRequireWasm: globalOverride.tssRequireWasm ?? buildRequireWasm ?? config.services.tssRequireWasm ?? false,
+    tssWasmDebug: globalOverride.tssWasmDebug ?? buildWasmDebug ?? config.services.tssWasmDebug ?? false
+  };
+  return result;
+}
+function getIframeUrl() {
+  const config = DEFAULT_PROVIDER_CONFIG;
+  const buildIframeUrl = "https://auth.lumiapassport.com";
+  const iframeUrl = buildIframeUrl || config.services.iframeUrl || "https://auth.lumiapassport.com";
+  return iframeUrl;
+}
+function getBlockscoutApiUrl(chainConfig) {
+  return chainConfig?.blockscoutApiUrl || null;
+}
+var DEFAULT_PROVIDER_CONFIG;
+var init_initial = __esm({
+  "src/config/initial.tsx"() {
+    init_assets();
+    DEFAULT_PROVIDER_CONFIG = {
+      passkey: {
+        enabled: true,
+        showCreateButton: true,
+        primaryButtonText: "Sign in with Passkey"
+      },
+      email: {
+        enabled: true,
+        placeholder: "Enter your email",
+        buttonText: "Continue",
+        verificationTitle: "Check your email"
+      },
+      social: {
+        enabled: true,
+        providers: [
+          { id: "google", name: "Google", enabled: true, icon: GoogleIcon, comingSoon: true },
+          {
+            id: "telegram",
+            name: "Telegram",
+            enabled: true,
+            icon: TelegramIcon,
+            comingSoon: false,
+            meta: {
+              botUsername: "LumiaPassportDevBot",
+              salt: "demo"
+            }
+          }
+        ]
+      },
+      wallet: {
+        enabled: false,
+        supportedChains: [1, 137, 56],
+        requireSignature: true,
+        walletConnectProjectId: void 0,
+        mode: "linked",
+        allowedWallets: void 0
+      },
+      // preferedColorMode: 'light', // undefined means 'auto'
+      ui: {
+        title: "Sign in",
+        subtitle: void 0,
+        authOrder: ["email", "social", "wallet"]
+      },
+      network: {
+        name: BSC_TESTNET.name,
+        symbol: BSC_TESTNET.nativeCurrency.symbol,
+        chainId: BSC_TESTNET.id,
+        rpcUrl: BSC_TESTNET.rpcUrls[0],
+        explorerUrl: BSC_TESTNET.blockExplorerUrl,
+        testnet: true,
+        forceChain: false
+      },
+      services: {
+        tssUrl: "",
+        // Will fallback to build-time env vars
+        shareVaultUrl: "",
+        // Will fallback to build-time env vars
+        iframeUrl: "https://auth.lumiapassport.com",
+        // Secure iframe for MPC operations
+        tssRequireWasm: false,
+        tssWasmDebug: false
+      },
+      features: {
+        mpcSecurity: true,
+        strictMode: false,
+        requestDeduplication: true,
+        kycNeeded: false,
+        displayNameNeeded: false,
+        showActiveBalanceAsFiat: false
+      },
+      warnings: {
+        backupWarning: true,
+        emailNotConnectedWarning: true
+      },
+      kyc: {
+        provider: void 0,
+        options: void 0
+      }
+    };
+  }
+});
+
+// src/lib/errors.ts
+var AccountAbstractionError = class _AccountAbstractionError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "LumiaPassportError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AccountAbstractionError);
+    }
+  }
+};
+var _UserRejectedError = class _UserRejectedError extends AccountAbstractionError {
+  constructor(message = "User rejected transaction") {
+    super(message, _UserRejectedError.CODE);
+    this.name = "UserRejectedError";
+  }
+};
+_UserRejectedError.CODE = "USER_REJECTED";
+var UserRejectedError = _UserRejectedError;
+var ErrorCodes = {
+  MPC_SIGNING_ERROR: "MPC_SIGNING_ERROR",
+  USER_REJECTED: UserRejectedError.CODE
+};
+function createAccountAbstractionError(params) {
+  const { message, code } = params;
+  if (!code) {
+    return new Error(message);
+  }
+  switch (code) {
+    case UserRejectedError.CODE:
+      return new UserRejectedError(message);
+    default:
+      return new AccountAbstractionError(message, code);
+  }
+}
+
+// src/internal/lib/iframe-manager.ts
+var IframeManager = class {
+  constructor(config) {
+    this.iframe = null;
+    this.channelToken = null;
+    this.isReady = false;
+    this.initPromise = null;
+    // Message handling
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.usedNonces = /* @__PURE__ */ new Set();
+    this.messageListener = null;
+    // Track hidden dialog elements for restoration
+    this.hiddenElements = [];
+    this.pointerGuardCleanup = null;
+    this.iframeHideTimeout = null;
+    this.iframeActive = false;
+    this.providerSessions = /* @__PURE__ */ new Map();
+    this.providerConnections = /* @__PURE__ */ new Map();
+    // Timeouts
+    this.REQUEST_TIMEOUT = 3e5;
+    // 5 minutes (for user interactions like consent)
+    this.NONCE_EXPIRY = 3e5;
+    // 5 minutes
+    this.HEARTBEAT_INTERVAL = 5 * 60 * 1e3;
+    this.isReconnecting = false;
+    // SSE event listeners
+    this.sseListeners = /* @__PURE__ */ new Set();
+    this.iframeUrl = config.iframeUrl;
+    this.projectId = config.projectId;
+    this.debug = config.debug || false;
+    this.onWalletReadyCallback = config.onWalletReady;
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+    this.log("[IframeManager] Initialized with:", {
+      iframeUrl: this.iframeUrl,
+      projectId: this.projectId
+    });
+  }
+  setDebug(debug) {
+    this.debug = debug;
+  }
+  /**
+   * Initialize iframe and wait for it to be ready
+   */
+  async initialize() {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.doInitialize();
+    return this.initPromise;
+  }
+  async doInitialize() {
+    this.iframe = document.createElement("iframe");
+    let iframeUrl = this.iframeUrl;
+    this.iframe.src = iframeUrl;
+    this.iframe.id = "lumia-passport-iframe";
+    this.iframe.style.display = "none";
+    this.iframe.style.position = "fixed";
+    this.iframe.style.top = "0";
+    this.iframe.style.left = "0";
+    this.iframe.style.width = "100%";
+    this.iframe.style.height = "100%";
+    this.iframe.style.border = "none";
+    this.iframe.style.zIndex = "999999";
+    this.iframe.style.background = "rgba(0, 0, 0, 0.5)";
+    this.iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox");
+    this.iframe.setAttribute("allow", "publickey-credentials-get *; publickey-credentials-create *");
+    this.messageListener = this.handleMessage.bind(this);
+    window.addEventListener("message", this.messageListener);
+    document.body.appendChild(this.iframe);
+    await this.readyPromise;
+    await this.authenticateSDK();
+    await this.primeProviderSessions();
+    this.startHeartbeat();
+    this.setupVisibilityHandler();
+    this.log("[IframeManager] \u2705 Iframe ready and authenticated");
+  }
+  /**
+   * Set the onWalletReady callback
+   */
+  setOnWalletReady(callback) {
+    this.onWalletReadyCallback = callback;
+  }
+  /**
+   * Authenticate SDK with iframe to establish secure channel
+   */
+  async authenticateSDK() {
+    const response = await this.sendMessage("SDK_AUTH", {
+      projectId: this.projectId
+    });
+    if (response.type === "IFRAME_MSG_SDK_AUTH_SUCCESS") {
+      this.channelToken = response.sessionToken;
+    } else {
+      throw new Error("SDK channel authentication failed");
+    }
+  }
+  /**
+   * Start periodic heartbeat to check SDK channel validity
+   */
+  startHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+    this.heartbeatInterval = setInterval(async () => {
+      if (!this.channelToken) return;
+      try {
+        const response = await this.sendMessage("SDK_CHANNEL_HEARTBEAT", {});
+        if (!response.valid) {
+          this.log("[IframeManager] SDK channel invalid, reconnecting...");
+          await this.reconnect();
+        }
+      } catch (error) {
+        this.log("[IframeManager] Heartbeat failed:", error);
+        await this.reconnect();
+      }
+    }, this.HEARTBEAT_INTERVAL);
+    this.log("[IframeManager] Heartbeat started (interval: 5 min)");
+  }
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+      this.log("[IframeManager] Heartbeat stopped");
+    }
+  }
+  /**
+   * Reconnect SDK channel after it becomes invalid
+   */
+  async reconnect() {
+    if (this.isReconnecting) {
+      this.log("[IframeManager] Already reconnecting, skipping...");
+      return;
+    }
+    this.isReconnecting = true;
+    this.log("[IframeManager] Reconnecting SDK channel...");
+    try {
+      this.channelToken = null;
+      await this.authenticateSDK();
+      this.log("[IframeManager] \u2705 SDK channel reconnected");
+    } catch (error) {
+      this.log("[IframeManager] \u274C Reconnect failed:", error);
+      throw error;
+    } finally {
+      this.isReconnecting = false;
+    }
+  }
+  /**
+   * Setup visibility change handler to check channel when tab becomes visible
+   */
+  setupVisibilityHandler() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("visibilitychange", async () => {
+      if (document.visibilityState === "visible" && this.channelToken) {
+        this.log("[IframeManager] Tab visible, checking SDK channel...");
+        try {
+          const response = await this.sendMessage("SDK_CHANNEL_HEARTBEAT", {});
+          if (!response.valid) {
+            this.log("[IframeManager] SDK channel expired while tab was hidden");
+            await this.reconnect();
+          }
+        } catch (error) {
+          this.log("[IframeManager] Channel check failed, reconnecting...");
+          await this.reconnect();
+        }
+      }
+    });
+    this.log("[IframeManager] Visibility handler setup");
+  }
+  /**
+   * Normalize legacy message types from cached iframe versions.
+   * Old iframe sends LUMIA_PASSPORT_*, new iframe sends IFRAME_MSG_*.
+   * This ensures both work until all browser caches expire.
+   */
+  normalizeMessageType(type) {
+    if (type.startsWith("LUMIA_PASSPORT_")) {
+      return type.replace("LUMIA_PASSPORT_", "IFRAME_MSG_");
+    }
+    return type;
+  }
+  /**
+   * Handle incoming postMessage events
+   */
+  handleMessage(event) {
+    const message = event.data;
+    if (!message || typeof message !== "object" || !message.type) {
+      return;
+    }
+    message.type = this.normalizeMessageType(message.type);
+    const validIframeTypes = [
+      "IFRAME_MSG_IFRAME_READY",
+      "IFRAME_MSG_WALLET_READY",
+      "IFRAME_MSG_SHOW_IFRAME",
+      "IFRAME_MSG_HIDE_IFRAME",
+      "IFRAME_MSG_SDK_AUTH_SUCCESS",
+      "IFRAME_MSG_AUTH_SUCCESS",
+      "IFRAME_MSG_DKG_SUCCESS",
+      "IFRAME_MSG_SIGNATURE",
+      "IFRAME_MSG_ADDRESS",
+      "IFRAME_MSG_KEYSHARE_STATUS",
+      "IFRAME_MSG_TRUSTED_APPS_LIST",
+      "IFRAME_MSG_TRUSTED_APP_REMOVED",
+      "IFRAME_MSG_REQUEST_NEW_TOKEN",
+      "IFRAME_MSG_TOKEN_REFRESHED",
+      "IFRAME_MSG_HEARTBEAT_RESPONSE",
+      "IFRAME_MSG_RESPONSE",
+      "IFRAME_MSG_ERROR",
+      "IFRAME_SSE_EVENT"
+    ];
+    if (!validIframeTypes.includes(message.type) && !message.messageId) {
+      return;
+    }
+    const iframeOrigin = new URL(this.iframeUrl).origin;
+    if (event.origin !== iframeOrigin) {
+      this.log("[IframeManager] \u26A0\uFE0F Ignored message from invalid origin:", {
+        received: event.origin,
+        expected: iframeOrigin
+      });
+      return;
+    }
+    if (message.type === "IFRAME_SSE_EVENT") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_SSE_EVENT", message.data);
+      for (const listener of this.sseListeners) {
+        try {
+          listener(message.data);
+        } catch (err) {
+          console.error("[IframeManager] SSE listener error:", err);
+        }
+      }
+      return;
+    }
+    if (message.type === "IFRAME_MSG_IFRAME_READY") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_MSG_IFRAME_READY");
+      this.isReady = true;
+      this.readyResolve();
+      return;
+    }
+    if (message.type === "IFRAME_MSG_WALLET_READY") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_MSG_WALLET_READY", message.data);
+      if (this.onWalletReadyCallback) {
+        this.onWalletReadyCallback(message.data);
+      }
+      return;
+    }
+    if (message.type === "IFRAME_MSG_SHOW_IFRAME") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_MSG_SHOW_IFRAME");
+      this.showIframe();
+      return;
+    }
+    if (message.type === "IFRAME_MSG_HIDE_IFRAME") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_MSG_HIDE_IFRAME");
+      this.hideIframe();
+      return;
+    }
+    if (message.type === "IFRAME_MSG_REQUEST_NEW_TOKEN") {
+      this.log("[IframeManager] \u{1F4E8} Received IFRAME_MSG_REQUEST_NEW_TOKEN");
+      this.handleTokenRefreshRequest(message).catch((error) => {
+        this.log("[IframeManager] \u274C Token refresh error:", error);
+      });
+      return;
+    }
+    if (message.messageId) {
+      const pending = this.pendingRequests.get(message.messageId);
+      if (pending) {
+        this.pendingRequests.delete(message.messageId);
+        if (message.type === "IFRAME_MSG_ERROR") {
+          const passportError = createAccountAbstractionError({
+            message: message.error || "Unknown error",
+            code: message.code
+          });
+          pending.reject(passportError);
+        } else {
+          pending.resolve(message.data || message);
+        }
+      }
+    }
+  }
+  /**
+   * Handle token refresh request from iframe
+   */
+  async handleTokenRefreshRequest(message) {
+    try {
+      const { jwtTokenManager } = await import("./auth-S7VX73GX.js");
+      const refreshSuccess = await jwtTokenManager.refreshAccessToken();
+      if (refreshSuccess) {
+        const newAccessToken = jwtTokenManager.getAccessToken();
+        if (this.iframe && this.iframe.contentWindow) {
+          const iframeOrigin = new URL(this.iframeUrl).origin;
+          this.iframe.contentWindow.postMessage(
+            {
+              type: "IFRAME_MSG_TOKEN_REFRESHED",
+              messageId: message.messageId,
+              accessToken: newAccessToken,
+              timestamp: Date.now()
+            },
+            iframeOrigin
+          );
+        }
+      } else {
+        if (this.iframe && this.iframe.contentWindow) {
+          const iframeOrigin = new URL(this.iframeUrl).origin;
+          this.iframe.contentWindow.postMessage(
+            {
+              type: "IFRAME_MSG_TOKEN_REFRESHED",
+              messageId: message.messageId,
+              error: "Token refresh failed",
+              timestamp: Date.now()
+            },
+            iframeOrigin
+          );
+        }
+      }
+    } catch (error) {
+      if (this.iframe && this.iframe.contentWindow) {
+        const iframeOrigin = new URL(this.iframeUrl).origin;
+        this.iframe.contentWindow.postMessage(
+          {
+            type: "IFRAME_MSG_TOKEN_REFRESHED",
+            messageId: message.messageId,
+            error: error instanceof Error ? error.message : "Unknown error",
+            timestamp: Date.now()
+          },
+          iframeOrigin
+        );
+      }
+    }
+  }
+  /**
+   * Send secure message to iframe
+   */
+  async sendMessage(type, data) {
+    if (this.initPromise && type !== "SDK_AUTH") {
+      await this.initPromise;
+    }
+    if (!this.iframe || !this.iframe.contentWindow) {
+      throw new Error("Iframe not initialized");
+    }
+    if (!this.channelToken && type !== "SDK_AUTH") {
+      throw createAccountAbstractionError({ message: "SDK channel not established. Initialize iframe first." });
+    }
+    const messageId = this.generateMessageId();
+    const nonce = this.generateNonce();
+    const timestamp = Date.now();
+    const message = {
+      type,
+      messageId,
+      timestamp,
+      nonce,
+      projectId: this.projectId,
+      data: {
+        ...data,
+        sessionToken: this.channelToken
+        // named sessionToken for backward compatibility with iframe
+      }
+    };
+    if (this.channelToken) {
+      message.hmac = await this.computeHMAC(message);
+    }
+    const responsePromise = new Promise((resolve, reject) => {
+      this.pendingRequests.set(messageId, {
+        resolve,
+        reject,
+        timestamp
+      });
+      setTimeout(() => {
+        if (this.pendingRequests.has(messageId)) {
+          this.pendingRequests.delete(messageId);
+          reject(new Error(`Request timeout: ${type}`));
+        }
+      }, this.REQUEST_TIMEOUT);
+    });
+    const iframeOrigin = new URL(this.iframeUrl).origin;
+    this.iframe.contentWindow.postMessage(message, iframeOrigin);
+    this.log(`[IframeManager] \u{1F4E4} Sent message: ${type}`, { messageId });
+    return responsePromise;
+  }
+  onSseEvent(listener) {
+    this.sseListeners.add(listener);
+    return () => {
+      this.sseListeners.delete(listener);
+    };
+  }
+  /**
+   * Compute HMAC for message authentication using SDK channel token
+   */
+  async computeHMAC(message) {
+    const encoder = new TextEncoder();
+    const payload = JSON.stringify({
+      type: message.type,
+      messageId: message.messageId,
+      timestamp: message.timestamp,
+      nonce: message.nonce,
+      data: JSON.stringify(message.data)
+    });
+    const data = encoder.encode(payload);
+    const key = encoder.encode(this.channelToken);
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", cryptoKey, data);
+    return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Generate unique message ID
+   */
+  generateMessageId() {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * Generate nonce for replay protection
+   */
+  generateNonce() {
+    const randomBytes = new Uint8Array(16);
+    crypto.getRandomValues(randomBytes);
+    return Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  // ========================================
+  // UI Methods
+  // ========================================
+  /**
+   * Show iframe (for consent/confirmation UI)
+   */
+  showIframe() {
+    if (this.iframe) {
+      if (this.iframeHideTimeout) {
+        clearTimeout(this.iframeHideTimeout);
+        this.iframeHideTimeout = null;
+      }
+      this.hideAllDialogs();
+      this.iframeActive = true;
+      this.enablePointerEventGuards();
+      this.iframe.style.display = "block";
+      this.iframe.style.zIndex = "2147483648";
+      this.iframe.style.pointerEvents = "auto";
+      this.iframe.style.visibility = "visible";
+      this.iframe.style.background = "rgba(0, 0, 0, 0.5)";
+    }
+  }
+  /**
+   * Hide iframe
+   */
+  hideIframe() {
+    if (this.iframe) {
+      this.log("[IframeManager] hideIframe called - making iframe non-blocking");
+      this.iframeActive = false;
+      this.iframe.style.zIndex = "1";
+      this.iframe.style.background = "transparent";
+      this.iframe.style.pointerEvents = "none";
+      this.iframe.style.visibility = "hidden";
+      this.log("[IframeManager] iframe z-index set to 1, transparent, pointer-events: none");
+      this.restoreAllDialogs();
+      this.disablePointerEventGuards();
+      this.iframeHideTimeout = setTimeout(() => {
+        if (this.iframe) {
+          this.log("[IframeManager] Fully hiding iframe with display: none");
+          this.iframe.style.display = "none";
+          this.iframe.style.zIndex = "999999";
+          this.iframe.style.background = "rgba(0, 0, 0, 0.5)";
+          this.iframe.style.pointerEvents = "auto";
+          this.iframe.style.visibility = "visible";
+        }
+        this.iframeHideTimeout = null;
+      }, 200);
+    }
+  }
+  /**
+   * Hide all Radix Dialog modals (SendModal, etc.)
+   */
+  hideAllDialogs() {
+    this.hiddenElements = [];
+    const allElements = document.body.querySelectorAll("*");
+    allElements.forEach((element) => {
+      const htmlElement = element;
+      if (htmlElement.id === "lumia-passport-iframe" || htmlElement.closest("#lumia-passport-iframe")) {
+        return;
+      }
+      if (htmlElement.hasAttribute("data-lumia-auth-modal") || htmlElement.closest("[data-lumia-auth-modal]")) {
+        return;
+      }
+      const computedStyle = window.getComputedStyle(htmlElement);
+      const zIndex = parseInt(computedStyle.zIndex, 10);
+      const isRadixElement = htmlElement.hasAttribute("data-radix-focus-guard") || htmlElement.hasAttribute("data-radix-portal") || htmlElement.hasAttribute("data-radix-popper-content-wrapper");
+      if (!isNaN(zIndex) && zIndex > 1e6 || isRadixElement) {
+        this.hiddenElements.push({
+          element: htmlElement,
+          originalDisplay: htmlElement.style.display || "",
+          originalVisibility: htmlElement.style.visibility || "",
+          originalPointerEvents: htmlElement.style.pointerEvents || "",
+          originalZIndex: htmlElement.style.zIndex || ""
+        });
+        htmlElement.style.display = "none";
+        htmlElement.style.visibility = "hidden";
+        htmlElement.style.pointerEvents = "none";
+        htmlElement.style.zIndex = "-1";
+        const elementType = isRadixElement ? "Radix element" : `z-index ${zIndex}`;
+        this.log(
+          `[IframeManager] Hiding ${elementType}: ${htmlElement.className || "(no class)"} (Tag: ${htmlElement.tagName})`
+        );
+      }
+    });
+    this.log(`[IframeManager] Hidden ${this.hiddenElements.length} elements total`);
+  }
+  /**
+   * Restore all previously hidden Radix Dialog modals
+   */
+  restoreAllDialogs() {
+    this.log(`[IframeManager] Restoring ${this.hiddenElements.length} elements`);
+    this.hiddenElements.forEach(
+      ({ element, originalDisplay, originalVisibility, originalPointerEvents, originalZIndex }) => {
+        element.style.display = originalDisplay;
+        element.style.visibility = originalVisibility;
+        element.style.pointerEvents = originalPointerEvents || "auto";
+        element.style.zIndex = originalZIndex;
+        this.log(
+          `[IframeManager] Restored element: ${element.className} (Tag: ${element.tagName}), pointerEvents set to: ${element.style.pointerEvents}`
+        );
+      }
+    );
+    this.hiddenElements = [];
+    this.log(`[IframeManager] All elements restored`);
+  }
+  /**
+   * Stop Radix dismissable layers from swallowing the first click on the iframe.
+   * Radix attaches pointer event guards at the document level; we intercept at window
+   * capture phase so user clicks flow straight into the consent iframe.
+   */
+  enablePointerEventGuards() {
+    if (this.pointerGuardCleanup) {
+      return;
+    }
+    const handler = (event) => {
+      if (!this.iframeActive || !this.iframe) {
+        return;
+      }
+      const target = event.target;
+      const composedPath = typeof event.composedPath === "function" ? event.composedPath() : [];
+      const hitsIframe = target === this.iframe || Array.isArray(composedPath) && composedPath.includes(this.iframe);
+      if (!hitsIframe) {
+        return;
+      }
+      if (typeof event.stopImmediatePropagation === "function") {
+        ;
+        event.stopImmediatePropagation();
+      }
+      event.stopPropagation();
+    };
+    const options = { capture: true };
+    const eventNames = ["pointerdown", "mousedown", "mouseup", "click", "touchstart", "focusin"];
+    eventNames.forEach((eventName) => {
+      window.addEventListener(eventName, handler, options);
+    });
+    this.pointerGuardCleanup = () => {
+      eventNames.forEach((eventName) => {
+        window.removeEventListener(eventName, handler, options);
+      });
+      this.pointerGuardCleanup = null;
+    };
+    this.log("[IframeManager] Enabled pointer event guards for iframe consent");
+  }
+  /**
+   * Remove pointer interception once iframe is hidden again.
+   */
+  disablePointerEventGuards() {
+    if (this.pointerGuardCleanup) {
+      this.pointerGuardCleanup();
+      this.pointerGuardCleanup = null;
+      this.log("[IframeManager] Disabled pointer event guards for iframe consent");
+    }
+  }
+  // ========================================
+  // Public API Methods
+  // ========================================
+  /**
+   * Authenticate user with application
+   */
+  async authenticate(userId, avatar, displayName) {
+    const response = await this.sendMessage("AUTHENTICATE", {
+      userId,
+      projectId: this.projectId,
+      avatar,
+      displayName
+    });
+    if (response.type === "IFRAME_MSG_AUTH_SUCCESS") {
+      return {
+        userId: response.userId,
+        address: response.address
+      };
+    }
+    throw new Error("Authentication failed");
+  }
+  /**
+   * Start DKG (Distributed Key Generation)
+   */
+  async startDKG(userId, accessToken) {
+    const response = await this.sendMessage("START_DKG", {
+      userId,
+      projectId: this.projectId,
+      accessToken
+      // Pass access token for TSS API authentication
+    });
+    if (response.type === "IFRAME_MSG_DKG_SUCCESS") {
+      return response.ownerAddress;
+    }
+    throw new Error("DKG failed");
+  }
+  /**
+   * Sign transaction
+   */
+  async signTransaction(userId, transaction, accessToken, avatar, displayName) {
+    if (!avatar || !displayName) {
+      const { jwtTokenManager } = await import("@embarkai/core/auth");
+      avatar = avatar || jwtTokenManager.getAvatar();
+      displayName = displayName || jwtTokenManager.getDisplayName();
+    }
+    const response = await this.sendMessage("SIGN_TRANSACTION", {
+      userId,
+      projectId: this.projectId,
+      transaction,
+      accessToken,
+      // Pass access token for TSS API authentication
+      avatar,
+      displayName
+    });
+    if (response.type === "IFRAME_MSG_SIGNATURE") {
+      return response.signature;
+    }
+    throw new Error("Transaction signing failed");
+  }
+  /**
+   * Sign EIP712 typed data
+   */
+  async signTypedData(userId, typedData, digest32, accessToken, avatar, displayName) {
+    console.log("[IframeManager] signTypedData: Sending SIGN_TYPED_DATA message", {
+      userId,
+      primaryType: typedData.primaryType,
+      digest32
+    });
+    if (!avatar || !displayName) {
+      const { jwtTokenManager } = await import("@embarkai/core/auth");
+      avatar = avatar || jwtTokenManager.getAvatar();
+      displayName = displayName || jwtTokenManager.getDisplayName();
+    }
+    const response = await this.sendMessage("SIGN_TYPED_DATA", {
+      userId,
+      projectId: this.projectId,
+      typedData,
+      digest32,
+      accessToken,
+      // Pass access token for TSS API authentication
+      avatar,
+      displayName
+    });
+    console.log("[IframeManager] signTypedData: Response received", {
+      type: response.type,
+      hasSignature: !!response.signature
+    });
+    if (response.type === "IFRAME_MSG_EIP712_SIGNATURE") {
+      return response.signature;
+    }
+    throw new Error("EIP712 signing failed");
+  }
+  /**
+   * Get user's wallet address
+   */
+  async getAddress(userId) {
+    const response = await this.sendMessage("GET_ADDRESS", {
+      userId
+    });
+    if (response.type === "IFRAME_MSG_ADDRESS") {
+      return response.address;
+    }
+    return void 0;
+  }
+  /**
+   * Check if user has a keyshare
+   */
+  async checkKeyshare(userId) {
+    const response = await this.sendMessage("CHECK_KEYSHARE", {
+      userId
+    });
+    if (response.type === "IFRAME_MSG_KEYSHARE_STATUS") {
+      return {
+        hasKeyshare: response.hasKeyshare,
+        address: response.address
+      };
+    }
+    return { hasKeyshare: false };
+  }
+  /**
+   * Open social auth popup (Telegram, Discord, Twitter, etc.)
+   */
+  async openSocialAuthPopup(provider, config) {
+    this.log(`[IframeManager] Opening social auth popup for provider: ${provider}`);
+    return new Promise((resolve, reject) => {
+      const normalizedProviderName = provider.toLowerCase();
+      const providerKey = normalizedProviderName === "twitter" ? "x" : normalizedProviderName;
+      const xMode = config?.mode === "link" ? "link" : "login";
+      const sessionBeforeFlow = providerKey === "x" ? this.getKnownSessionId("x") : null;
+      const connectionBeforeFlow = providerKey === "x" ? this.getKnownProviderConnection("x") : null;
+      let popupUrl;
+      if (providerKey === "telegram") {
+        const iframeOrigin = new URL(this.iframeUrl).origin;
+        const botUsername = config?.botUsername;
+        this.log("[IframeManager] Telegram config:", config);
+        this.log("[IframeManager] Bot username:", botUsername);
+        const url = new URL(`${iframeOrigin}/oauth/telegram.html`);
+        if (botUsername) {
+          url.searchParams.set("bot", botUsername);
+        }
+        popupUrl = url.toString();
+        this.log("[IframeManager] Popup URL:", popupUrl);
+      } else if (providerKey === "x") {
+        const iframeOrigin = new URL(this.iframeUrl).origin;
+        this.log("[IframeManager] X OAuth config:", config);
+        const url = new URL(`${iframeOrigin}/oauth/x.html`);
+        const { getServiceUrls: getServiceUrls2 } = (init_initial(), __toCommonJS(initial_exports));
+        const { tssUrl } = getServiceUrls2();
+        const projectId = typeof window !== "undefined" ? window.__EMBARK_PROJECT_ID__ : void 0;
+        this.log("[IframeManager] TSS URL from config:", tssUrl);
+        this.log("[IframeManager] Project ID:", projectId);
+        url.searchParams.set("tssUrl", tssUrl);
+        url.searchParams.set("mode", xMode);
+        if (projectId) {
+          url.searchParams.set("projectId", projectId);
+        }
+        if (xMode === "link" && config?.token) {
+          url.searchParams.set("token", config.token);
+        }
+        popupUrl = url.toString();
+        this.log("[IframeManager] X OAuth Popup URL:", popupUrl);
+      } else {
+        reject(new Error(`Provider ${provider} not supported yet`));
+        return;
+      }
+      const popup = window.open(
+        popupUrl,
+        `${provider}_auth`,
+        "width=550,height=650,menubar=no,toolbar=no,location=no,status=no"
+      );
+      if (!popup) {
+        reject(new Error("Failed to open popup. Please allow popups for this site."));
+        return;
+      }
+      let checkClosed;
+      let resolved = false;
+      let messageHandler = null;
+      let pendingCancellation = false;
+      const cleanup = (closePopup = true) => {
+        if (messageHandler) {
+          window.removeEventListener("message", messageHandler);
+        }
+        if (checkClosed) {
+          clearInterval(checkClosed);
+          checkClosed = void 0;
+        }
+        if (closePopup && !popup.closed) {
+          popup.close();
+        }
+      };
+      const finalize = (result, closePopup = true) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        cleanup(closePopup);
+        if (result.success && providerKey === "x") {
+          this.updateProviderTrackingFromUser("x", result.user);
+        }
+        resolve({
+          provider,
+          ...result
+        });
+      };
+      messageHandler = (event) => {
+        const iframeOrigin = new URL(this.iframeUrl).origin;
+        if (event.origin !== iframeOrigin) {
+          return;
+        }
+        const eventProvider = event.data.provider?.toLowerCase();
+        if (event.data.type === "TELEGRAM_AUTH_SUCCESS" && eventProvider === "telegram" && providerKey === "telegram") {
+          this.log("[IframeManager] Telegram auth successful from popup:", event.data);
+          finalize({
+            success: true,
+            user: event.data.user
+          });
+        } else if (event.data.type === "X_AUTH_SUCCESS" && eventProvider === "x" && providerKey === "x") {
+          this.log("[IframeManager] X auth successful from popup:", event.data);
+          if (event.data.tokens) {
+            this.log("[IframeManager] Tokens received in postMessage, storing via jwtTokenManager");
+            import("./auth-S7VX73GX.js").then(({ jwtTokenManager }) => {
+              return jwtTokenManager.setTokens({
+                accessToken: event.data.tokens.accessToken,
+                refreshToken: event.data.tokens.refreshToken,
+                userId: event.data.user.userId,
+                expiresIn: event.data.user.expiresIn || 3600,
+                hasKeyshare: event.data.user.hasKeyshare || false,
+                displayName: event.data.user.displayName || null,
+                providers: event.data.user.providers || ["x"]
+              });
+            }).then(() => {
+              this.log("[IframeManager] Tokens stored successfully");
+            }).catch((tokenError) => {
+              this.log("[IframeManager] Warning: Failed to store tokens:", tokenError);
+            });
+          }
+          finalize({
+            success: true,
+            user: event.data.user,
+            mode: event.data.mode
+          });
+        } else if (event.data.type === "TELEGRAM_AUTH_CANCELLED" && eventProvider === "telegram" && providerKey === "telegram") {
+          this.log("[IframeManager] Telegram auth cancelled by user");
+          finalize(
+            {
+              success: false,
+              error: "User cancelled authentication"
+            },
+            false
+          );
+        } else if (event.data.type === "X_AUTH_CANCELLED" && eventProvider === "x" && providerKey === "x") {
+          this.log("[IframeManager] X auth cancelled by user");
+          pendingCancellation = true;
+          this.verifyAuthSession({ provider: "x" }).then((verification) => {
+            const sessionId = verification.sessionId || null;
+            const providers = verification.providers || [];
+            const isConnectedNow = providers.includes("x");
+            const sessionChanged = !!sessionId && sessionId !== sessionBeforeFlow;
+            const connectionGained = connectionBeforeFlow === false && isConnectedNow;
+            if (verification.success) {
+              if (sessionChanged || connectionGained) {
+                this.log(
+                  "[IframeManager] X auth cancellation fallback found active session change, treating as success"
+                );
+                finalize(
+                  {
+                    success: true,
+                    user: verification.user,
+                    mode: xMode
+                  },
+                  true
+                );
+              } else {
+                this.log("[IframeManager] X auth fallback did not detect new session, treating as cancellation");
+                if (popup.closed) {
+                  finalize(
+                    {
+                      success: false,
+                      error: "User cancelled authentication"
+                    },
+                    false
+                  );
+                }
+              }
+            } else {
+              this.log("[IframeManager] X auth fallback verification reported no session, treating as cancellation");
+              if (popup.closed) {
+                finalize(
+                  {
+                    success: false,
+                    error: "User cancelled authentication"
+                  },
+                  false
+                );
+              }
+            }
+          }).catch((error) => {
+            this.log("[IframeManager] X auth fallback verification error:", error);
+            if (popup.closed) {
+              finalize(
+                {
+                  success: false,
+                  error: "User cancelled authentication"
+                },
+                false
+              );
+            }
+          });
+        } else if (event.data.type === "X_AUTH_ERROR" && eventProvider === "x" && providerKey === "x") {
+          this.log("[IframeManager] X auth error from popup:", event.data.error);
+          finalize({
+            success: false,
+            error: event.data.error || "Authentication failed"
+          });
+        }
+      };
+      window.addEventListener("message", messageHandler);
+      checkClosed = setInterval(() => {
+        if (popup.closed) {
+          if (checkClosed) {
+            clearInterval(checkClosed);
+            checkClosed = void 0;
+          }
+          if (!resolved) {
+            if (providerKey === "x" && pendingCancellation) {
+              finalize(
+                {
+                  success: false,
+                  error: "User cancelled authentication"
+                },
+                false
+              );
+            } else {
+              finalize(
+                {
+                  success: false,
+                  error: "Popup was closed"
+                },
+                false
+              );
+            }
+          }
+        }
+      }, 500);
+    });
+  }
+  /**
+   * Verify current auth session with the backend.
+   * Can optionally track session state for a specific provider.
+   * @param options.silent - If true, suppress logging
+   * @param options.provider - Optional provider key to track session state for (e.g., 'x', 'telegram')
+   */
+  async verifyAuthSession(options = {}) {
+    if (typeof window === "undefined" || typeof fetch === "undefined") {
+      return { success: false };
+    }
+    try {
+      const { getServiceUrls: getServiceUrls2 } = (init_initial(), __toCommonJS(initial_exports));
+      const { tssUrl } = getServiceUrls2();
+      const projectId = typeof window !== "undefined" ? window.__EMBARK_PROJECT_ID__ : void 0;
+      if (!tssUrl) {
+        this.log("[IframeManager] Session verify aborted: missing TSS URL");
+        return { success: false };
+      }
+      const verifyUrl = new URL(`${tssUrl}/api/auth/verify`);
+      if (projectId) {
+        verifyUrl.searchParams.set("projectId", projectId);
+      }
+      const { jwtTokenManager, ensureValidToken } = await import("./auth-S7VX73GX.js");
+      const hasValidToken = await ensureValidToken();
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (hasValidToken) {
+        const accessToken = jwtTokenManager.getAccessToken();
+        if (accessToken) {
+          headers["Authorization"] = `Bearer ${accessToken}`;
+        }
+      }
+      let response = await fetch(verifyUrl.toString(), {
+        method: "GET",
+        headers,
+        credentials: "include"
+      });
+      if (response.status === 401) {
+        this.log("[IframeManager] Session verify got 401, attempting token refresh...");
+        const refreshSuccess = await jwtTokenManager.refreshAccessToken();
+        if (refreshSuccess) {
+          const newAccessToken = jwtTokenManager.getAccessToken();
+          if (newAccessToken) {
+            headers["Authorization"] = `Bearer ${newAccessToken}`;
+            this.log("[IframeManager] Token refreshed, retrying verify...");
+            response = await fetch(verifyUrl.toString(), {
+              method: "GET",
+              headers,
+              credentials: "include"
+            });
+          }
+        }
+      }
+      if (!response.ok) {
+        this.log("[IframeManager] Session verify returned status:", response.status);
+        if (options.provider) {
+          this.recordProviderSession(options.provider, null);
+          this.recordProviderConnection(options.provider, false);
+        }
+        return { success: false };
+      }
+      let userData = void 0;
+      try {
+        userData = await response.json();
+      } catch (jsonError) {
+        this.log("[IframeManager] Session verify JSON parse failed:", jsonError);
+      }
+      const sessionId = this.extractSessionId(userData);
+      const providers = this.getProvidersList(userData);
+      if (options.provider) {
+        this.recordProviderSession(options.provider, sessionId);
+        this.recordProviderConnection(options.provider, providers.includes(options.provider));
+      }
+      if (!options.silent) {
+        this.log("[IframeManager] Session verify result:", {
+          sessionId,
+          providers
+        });
+      }
+      return {
+        success: true,
+        user: userData,
+        sessionId,
+        providers
+      };
+    } catch (error) {
+      this.log("[IframeManager] Session verify error:", error);
+      if (options.provider) {
+        this.recordProviderSession(options.provider, null);
+        this.recordProviderConnection(options.provider, false);
+      }
+      return { success: false };
+    }
+  }
+  /**
+   * Prime provider session/cache state to detect future changes.
+   */
+  async primeProviderSessions() {
+    try {
+      await this.verifyAuthSession({ silent: true });
+    } catch (error) {
+      this.log("[IframeManager] Prime provider sessions failed:", error);
+    }
+  }
+  getKnownSessionId(providerKey) {
+    return this.providerSessions.has(providerKey) ? this.providerSessions.get(providerKey) ?? null : null;
+  }
+  getKnownProviderConnection(providerKey) {
+    if (!this.providerConnections.has(providerKey)) {
+      return null;
+    }
+    const value = this.providerConnections.get(providerKey);
+    return typeof value === "boolean" ? value : null;
+  }
+  recordProviderSession(providerKey, sessionId) {
+    this.providerSessions.set(providerKey, sessionId ?? null);
+  }
+  recordProviderConnection(providerKey, connected) {
+    this.providerConnections.set(providerKey, connected);
+  }
+  updateProviderTrackingFromUser(providerKey, user) {
+    if (!user) {
+      return;
+    }
+    if (providerKey === "x") {
+      const sessionId = this.extractSessionId(user);
+      this.recordProviderSession("x", sessionId);
+      const providers = this.getProvidersList(user);
+      this.recordProviderConnection("x", providers.includes("x"));
+    }
+  }
+  extractSessionId(user) {
+    if (!user || typeof user !== "object") {
+      return null;
+    }
+    if (typeof user.sessionId === "string") {
+      return user.sessionId;
+    }
+    if (user.data && typeof user.data.sessionId === "string") {
+      return user.data.sessionId;
+    }
+    return null;
+  }
+  getProvidersList(user) {
+    if (!user || typeof user !== "object") {
+      return [];
+    }
+    const providersRaw = user.providers || user.data?.providers;
+    if (!Array.isArray(providersRaw)) {
+      return [];
+    }
+    return providersRaw.map((provider) => typeof provider === "string" ? provider.toLowerCase() : null).filter((provider) => provider !== null);
+  }
+  /**
+   * Get trusted apps for user
+   */
+  async getTrustedApps(userId) {
+    const response = await this.sendMessage("GET_TRUSTED_APPS", {
+      userId
+    });
+    if (response.type === "IFRAME_MSG_TRUSTED_APPS_LIST") {
+      return response.apps || [];
+    }
+    return [];
+  }
+  /**
+   * Remove app from trusted list
+   */
+  async removeTrustedApp(userId, projectId, origin) {
+    const response = await this.sendMessage("REMOVE_TRUSTED_APP", {
+      userId,
+      projectId,
+      appOrigin: origin
+    });
+    if (response.type === "IFRAME_MSG_TRUSTED_APP_REMOVED") {
+      return response.success;
+    }
+    return false;
+  }
+  /**
+   * Clear all authorizations for current project (for testing consent flow)
+   * This will force the consent modal to appear on next authentication
+   */
+  async clearAuthorizations() {
+    try {
+      const response = await this.sendMessage("CLEAR_AUTHORIZATIONS", {
+        projectId: this.projectId
+      });
+      this.log("[IframeManager] Cleared authorizations for project:", this.projectId);
+      return response.success || true;
+    } catch (error) {
+      this.log("[IframeManager] Failed to clear authorizations:", error);
+      return false;
+    }
+  }
+  /**
+   * Create backup of keyshare
+   */
+  async createBackup(userId, backupRequest, accessToken) {
+    const response = await this.sendMessage("CREATE_BACKUP", {
+      userId,
+      backupRequest,
+      accessToken
+      // Pass access token for TSS API authentication
+    });
+    if (response.type === "IFRAME_MSG_BACKUP_CREATED") {
+      return response.result;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Restore keyshare from server backup
+   */
+  async restoreFromServer(userId, password, accessToken) {
+    const response = await this.sendMessage("RESTORE_BACKUP", {
+      userId,
+      password,
+      accessToken
+      // Pass access token for TSS API authentication
+    });
+    if (response.type === "IFRAME_MSG_BACKUP_RESTORED") {
+      return response.result;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Encrypt backup data without uploading (for cloud/local backups)
+   * Returns encrypted data that parent can upload/download
+   */
+  async encryptBackupData(userId, password) {
+    const response = await this.sendMessage("ENCRYPT_BACKUP_DATA", {
+      userId,
+      password
+    });
+    if (response.type === "IFRAME_MSG_BACKUP_ENCRYPTED") {
+      return response.encryptedData;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Encrypt current keyshare as EnvelopeEncryptedShare (for Guardian backup)
+   */
+  async encryptEnvelopeData(userId, password) {
+    const response = await this.sendMessage("ENCRYPT_ENVELOPE_DATA", { userId, password });
+    if (response.type === "IFRAME_MSG_ENVELOPE_ENCRYPTED") {
+      return response.envelopeJson;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Decrypt EnvelopeEncryptedShare and restore keyshare (for Guardian restore)
+   */
+  async decryptAndRestoreEnvelope(userId, envelopeJson, password) {
+    const response = await this.sendMessage("DECRYPT_AND_RESTORE_ENVELOPE", {
+      userId,
+      envelopeJson,
+      password
+    });
+    if (response.type === "IFRAME_MSG_ENVELOPE_RESTORED") {
+      return response.result;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Restore keyshare from local file backup
+   */
+  async restoreFromLocalFile(userId, fileContent, password) {
+    const response = await this.sendMessage("RESTORE_FROM_FILE", {
+      userId,
+      fileContent,
+      password
+    });
+    if (response.type === "IFRAME_MSG_FILE_RESTORED") {
+      return response.result;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Get backup status for user
+   */
+  async getBackupStatus(userId) {
+    const response = await this.sendMessage("GET_BACKUP_STATUS", {
+      userId
+    });
+    if (response.type === "IFRAME_MSG_BACKUP_STATUS") {
+      return response.status;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Get available cloud providers
+   */
+  async getCloudProviders() {
+    const response = await this.sendMessage("GET_CLOUD_PROVIDERS", {});
+    if (response.type === "IFRAME_MSG_CLOUD_PROVIDERS") {
+      return response.providers;
+    }
+    throw new Error("Unexpected response type");
+  }
+  /**
+   * Cleanup and destroy iframe
+   */
+  destroy() {
+    this.log("[IframeManager] Destroying iframe...");
+    this.stopHeartbeat();
+    this.pendingRequests.forEach((pending) => {
+      pending.reject(new Error("Iframe manager destroyed"));
+    });
+    this.pendingRequests.clear();
+    if (this.messageListener) {
+      window.removeEventListener("message", this.messageListener);
+      this.messageListener = null;
+    }
+    if (this.iframe && this.iframe.parentNode) {
+      this.iframe.parentNode.removeChild(this.iframe);
+    }
+    this.iframe = null;
+    this.isReady = false;
+    this.channelToken = null;
+    this.initPromise = null;
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+    this.log("[IframeManager] \u2705 Destroyed");
+  }
+  /**
+   * Debug logging
+   */
+  log(message, data) {
+    if (this.debug) {
+      if (data) {
+        console.log(message, data);
+      } else {
+        console.log(message);
+      }
+    }
+  }
+};
+var iframeManagerInstance = null;
+function getIframeManager(config) {
+  if (!iframeManagerInstance && config) {
+    iframeManagerInstance = new IframeManager(config);
+  }
+  if (!iframeManagerInstance) {
+    throw new Error(
+      'IframeManager not initialized. This usually means projectId is not configured.\n\nTo fix this:\n1. Get your projectId from https://dashboard.lumiapassport.com/\n2. Add it to Provider:\n   <Provider projectId="your-project-id">\n\nFor more details, see the documentation.'
+    );
+  }
+  return iframeManagerInstance;
+}
+async function waitForIframe() {
+  const manager = getIframeManager();
+  await manager.initialize();
+}
+function destroyIframeManager() {
+  if (iframeManagerInstance) {
+    iframeManagerInstance.destroy();
+    iframeManagerInstance = null;
+  }
+}
+
+export {
+  GoogleIcon,
+  TelegramIcon,
+  TwitterIcon,
+  DiscordIcon,
+  init_assets,
+  DEFAULT_PROVIDER_CONFIG,
+  getServiceUrls,
+  getIframeUrl,
+  getBlockscoutApiUrl,
+  init_initial,
+  AccountAbstractionError,
+  UserRejectedError,
+  ErrorCodes,
+  createAccountAbstractionError,
+  IframeManager,
+  getIframeManager,
+  waitForIframe,
+  destroyIframeManager
+};
+//# sourceMappingURL=chunk-ISXWRCDC.js.map