@imtbl/auth 2.10.7-alpha.2

package/src/config.ts

@@ -0,0 +1,70 @@
+import {
+  OidcConfiguration,
+  AuthModuleConfiguration,
+  PopupOverlayOptions,
+} from './types';
+import { PassportError, PassportErrorType } from './errors';
+
+const validateConfiguration = <T>(
+  configuration: T,
+  requiredKeys: Array<keyof T>,
+  prefix?: string,
+) => {
+  const missingKeys = requiredKeys
+    .map((key) => !configuration[key] && key)
+    .filter((n) => n)
+    .join(', ');
+  if (missingKeys !== '') {
+    const errorMessage = prefix
+      ? `${prefix} - ${missingKeys} cannot be null`
+      : `${missingKeys} cannot be null`;
+    throw new PassportError(
+      errorMessage,
+      PassportErrorType.INVALID_CONFIGURATION,
+    );
+  }
+};
+
+/**
+ * Interface that any configuration must implement to work with AuthManager
+ */
+export interface IAuthConfiguration {
+  readonly authenticationDomain: string;
+  readonly passportDomain: string;
+  readonly oidcConfiguration: OidcConfiguration;
+  readonly crossSdkBridgeEnabled: boolean;
+  readonly popupOverlayOptions?: PopupOverlayOptions;
+}
+
+export class AuthConfiguration implements IAuthConfiguration {
+  readonly authenticationDomain: string;
+
+  readonly passportDomain: string;
+
+  readonly oidcConfiguration: OidcConfiguration;
+
+  readonly crossSdkBridgeEnabled: boolean;
+
+  readonly popupOverlayOptions?: PopupOverlayOptions;
+
+  constructor({
+    authenticationDomain,
+    passportDomain,
+    crossSdkBridgeEnabled,
+    popupOverlayOptions,
+    ...oidcConfiguration
+  }: AuthModuleConfiguration) {
+    validateConfiguration(oidcConfiguration, [
+      'clientId',
+      'redirectUri',
+    ]);
+
+    this.oidcConfiguration = oidcConfiguration;
+    this.crossSdkBridgeEnabled = crossSdkBridgeEnabled || false;
+    this.popupOverlayOptions = popupOverlayOptions;
+
+    // Default to production auth domain if not provided
+    this.authenticationDomain = authenticationDomain || 'https://auth.immutable.com';
+    this.passportDomain = passportDomain || 'https://passport.immutable.com';
+  }
+}

package/src/confirmation/confirmation.ts

@@ -0,0 +1,275 @@
+import * as GeneratedClients from '@imtbl/generated-clients';
+import { trackError } from '@imtbl/metrics';
+
+import {
+  ConfirmationResult,
+  PASSPORT_CONFIRMATION_EVENT_TYPE,
+  ConfirmationReceiveMessage,
+  ConfirmationSendMessage,
+} from './types';
+import { openPopupCenter } from './popup';
+import { IAuthConfiguration } from '../config';
+import ConfirmationOverlay from '../overlay/confirmationOverlay';
+
+const CONFIRMATION_WINDOW_TITLE = 'Confirm this transaction';
+const CONFIRMATION_WINDOW_HEIGHT = 720;
+const CONFIRMATION_WINDOW_WIDTH = 480;
+const CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION = 1000;
+
+export const CONFIRMATION_IFRAME_ID = 'passport-confirm';
+export const CONFIRMATION_IFRAME_STYLE = 'display: none; position: absolute;width:0px;height:0px;border:0;';
+
+type MessageHandler = (arg0: MessageEvent) => void;
+
+type MessageType = 'erc191' | 'eip712';
+
+export default class ConfirmationScreen {
+  private config: IAuthConfiguration;
+
+  private confirmationWindow: Window | undefined;
+
+  private popupOptions: { width: number; height: number } | undefined;
+
+  private overlay: ConfirmationOverlay | undefined;
+
+  private overlayClosed: boolean;
+
+  private timer: NodeJS.Timeout | undefined;
+
+  constructor(config: IAuthConfiguration) {
+    this.config = config;
+    this.overlayClosed = false;
+  }
+
+  private getHref(relativePath: string, queryStringParams?: { [key: string]: any }) {
+    let href = `${this.config.passportDomain}/transaction-confirmation/${relativePath}`;
+
+    if (queryStringParams) {
+      const queryString = queryStringParams
+        ? Object.keys(queryStringParams)
+          .map((key) => `${key}=${queryStringParams[key]}`)
+          .join('&')
+        : '';
+
+      href = `${href}?${queryString}`;
+    }
+
+    return href;
+  }
+
+  requestConfirmation(
+    transactionId: string,
+    etherAddress: string,
+    chainType: GeneratedClients.mr.TransactionApprovalRequestChainTypeEnum,
+    chainId?: string,
+  ): Promise<ConfirmationResult> {
+    return new Promise((resolve, reject) => {
+      const messageHandler = ({ data, origin }: MessageEvent) => {
+        if (
+          origin !== this.config.passportDomain
+          || data.eventType !== PASSPORT_CONFIRMATION_EVENT_TYPE
+        ) {
+          return;
+        }
+
+        switch (data.messageType as ConfirmationReceiveMessage) {
+          case ConfirmationReceiveMessage.CONFIRMATION_WINDOW_READY: {
+            this.confirmationWindow?.postMessage({
+              eventType: PASSPORT_CONFIRMATION_EVENT_TYPE,
+              messageType: ConfirmationSendMessage.CONFIRMATION_START,
+            }, this.config.passportDomain);
+            break;
+          }
+          case ConfirmationReceiveMessage.TRANSACTION_CONFIRMED: {
+            this.closeWindow();
+            resolve({ confirmed: true });
+            break;
+          }
+          case ConfirmationReceiveMessage.TRANSACTION_REJECTED: {
+            this.closeWindow();
+            resolve({ confirmed: false });
+            break;
+          }
+          case ConfirmationReceiveMessage.TRANSACTION_ERROR: {
+            this.closeWindow();
+            reject(new Error('Error during transaction confirmation'));
+            break;
+          }
+          default:
+            this.closeWindow();
+            reject(new Error('Unsupported message type'));
+        }
+      };
+
+      let href = '';
+      if (chainType === GeneratedClients.mr.TransactionApprovalRequestChainTypeEnum.Starkex) {
+        href = this.getHref('transaction', { transactionId, etherAddress, chainType });
+      } else {
+        href = this.getHref('zkevm/transaction', {
+          transactionID: transactionId, etherAddress, chainType, chainID: chainId,
+        });
+      }
+      window.addEventListener('message', messageHandler);
+      this.showConfirmationScreen(href, messageHandler, resolve);
+    });
+  }
+
+  requestMessageConfirmation(
+    messageID: string,
+    etherAddress: string,
+    messageType?: MessageType,
+  ): Promise<ConfirmationResult> {
+    return new Promise((resolve, reject) => {
+      const messageHandler = ({ data, origin }: MessageEvent) => {
+        if (
+          origin !== this.config.passportDomain
+          || data.eventType !== PASSPORT_CONFIRMATION_EVENT_TYPE
+        ) {
+          return;
+        }
+        switch (data.messageType as ConfirmationReceiveMessage) {
+          case ConfirmationReceiveMessage.CONFIRMATION_WINDOW_READY: {
+            this.confirmationWindow?.postMessage({
+              eventType: PASSPORT_CONFIRMATION_EVENT_TYPE,
+              messageType: ConfirmationSendMessage.CONFIRMATION_START,
+            }, this.config.passportDomain);
+            break;
+          }
+          case ConfirmationReceiveMessage.MESSAGE_CONFIRMED: {
+            this.closeWindow();
+            resolve({ confirmed: true });
+            break;
+          }
+          case ConfirmationReceiveMessage.MESSAGE_REJECTED: {
+            this.closeWindow();
+            resolve({ confirmed: false });
+            break;
+          }
+          case ConfirmationReceiveMessage.MESSAGE_ERROR: {
+            this.closeWindow();
+            reject(new Error('Error during message confirmation'));
+            break;
+          }
+          default:
+            this.closeWindow();
+            reject(new Error('Unsupported message type'));
+        }
+      };
+
+      window.addEventListener('message', messageHandler);
+      const href = this.getHref('zkevm/message', {
+        messageID,
+        etherAddress,
+        ...(messageType ? { messageType } : {}),
+      });
+      this.showConfirmationScreen(href, messageHandler, resolve);
+    });
+  }
+
+  showServiceUnavailable(): Promise<void> {
+    return new Promise((_, reject) => {
+      this.showConfirmationScreen(
+        this.getHref('unavailable'),
+        () => {},
+        () => {
+          this.closeWindow();
+          reject(new Error('Service unavailable'));
+        },
+      );
+    });
+  }
+
+  loading(popupOptions?: { width: number; height: number }) {
+    if (this.config.crossSdkBridgeEnabled) {
+      // There is no need to open a confirmation window if cross-sdk bridge is enabled
+      return;
+    }
+
+    this.popupOptions = popupOptions;
+
+    try {
+      this.confirmationWindow = openPopupCenter({
+        url: this.getHref('loading'),
+        title: CONFIRMATION_WINDOW_TITLE,
+        width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+        height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+      });
+      this.overlay = new ConfirmationOverlay(this.config.popupOverlayOptions || {});
+    } catch (error) {
+      // If an error is thrown here then the popup is blocked
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      trackError('passport', 'confirmationPopupDenied', new Error(errorMessage));
+      this.overlay = new ConfirmationOverlay(this.config.popupOverlayOptions || {}, true);
+    }
+
+    this.overlay.append(
+      () => {
+        try {
+          this.confirmationWindow?.close();
+          this.confirmationWindow = openPopupCenter({
+            url: this.getHref('loading'),
+            title: CONFIRMATION_WINDOW_TITLE,
+            width: this.popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+            height: this.popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+          });
+        } catch { /* Empty */ }
+      },
+      () => {
+        this.overlayClosed = true;
+        this.closeWindow();
+      },
+    );
+  }
+
+  closeWindow() {
+    this.confirmationWindow?.close();
+    this.overlay?.remove();
+    this.overlay = undefined;
+  }
+
+  showConfirmationScreen(href: string, messageHandler: MessageHandler, resolve: Function) {
+    // If popup blocked, the confirmation window will not exist
+    if (this.confirmationWindow) {
+      this.confirmationWindow.location.href = href;
+    }
+
+    // This indicates the user closed the overlay so the transaction should be rejected
+    if (!this.overlay) {
+      this.overlayClosed = false;
+      resolve({ confirmed: false });
+      return;
+    }
+
+    // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+    const timerCallback = () => {
+      if (this.confirmationWindow?.closed || this.overlayClosed) {
+        clearInterval(this.timer);
+        window.removeEventListener('message', messageHandler);
+        resolve({ confirmed: false });
+        this.overlayClosed = false;
+        this.confirmationWindow = undefined;
+      }
+    };
+    this.timer = setInterval(
+      timerCallback,
+      CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION,
+    );
+    this.overlay.update(() => this.recreateConfirmationWindow(href, timerCallback));
+  }
+
+  private recreateConfirmationWindow(href: string, timerCallback: () => void) {
+    try {
+      // Clears and recreates the timer to ensure when the confirmation window
+      // is closed and recreated the transaction is not rejected.
+      clearInterval(this.timer);
+      this.confirmationWindow?.close();
+      this.confirmationWindow = openPopupCenter({
+        url: href,
+        title: CONFIRMATION_WINDOW_TITLE,
+        width: this.popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+        height: this.popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+      });
+      this.timer = setInterval(timerCallback, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+    } catch { /* Empty */ }
+  }
+}

package/src/confirmation/embeddedLoginPrompt.ts

@@ -0,0 +1,146 @@
+import { Detail, getDetail } from '@imtbl/metrics';
+import {
+  EMBEDDED_LOGIN_PROMPT_EVENT_TYPE,
+  EmbeddedLoginPromptResult,
+  EmbeddedLoginPromptReceiveMessage,
+} from './types';
+import { IAuthConfiguration } from '../config';
+import EmbeddedLoginPromptOverlay from '../overlay/embeddedLoginPromptOverlay';
+
+const LOGIN_PROMPT_WINDOW_HEIGHT = 660;
+const LOGIN_PROMPT_WINDOW_WIDTH = 440;
+const LOGIN_PROMPT_WINDOW_BORDER_RADIUS = '16px';
+const LOGIN_PROMPT_KEYFRAME_STYLES_ID = 'passport-embedded-login-keyframes';
+const LOGIN_PROMPT_IFRAME_ID = 'passport-embedded-login-iframe';
+
+export default class EmbeddedLoginPrompt {
+  private config: IAuthConfiguration;
+
+  constructor(config: IAuthConfiguration) {
+    this.config = config;
+  }
+
+  private getHref = (anonymousId?: string) => {
+    let href = `${this.config.authenticationDomain}/im-embedded-login-prompt`
+    + `?client_id=${this.config.oidcConfiguration.clientId}`
+    + `&rid=${getDetail(Detail.RUNTIME_ID)}`;
+
+    if (anonymousId) {
+      href += `&third_party_a_id=${anonymousId}`;
+    }
+
+    return href;
+  };
+
+  private static appendIFrameStylesIfNeeded = () => {
+    if (document.getElementById(LOGIN_PROMPT_KEYFRAME_STYLES_ID)) {
+      return;
+    }
+
+    const style = document.createElement('style');
+    style.id = LOGIN_PROMPT_KEYFRAME_STYLES_ID;
+    style.textContent = `
+      @keyframes passportEmbeddedLoginPromptPopBounceIn {
+        0% {
+          opacity: 0.5;
+        }
+        50% {
+          opacity: 1;
+          transform: scale(1.05);
+        }
+        75% {
+          transform: scale(0.98);
+        }
+        100% {
+          opacity: 1;
+          transform: scale(1);
+        }
+      }
+
+      @media (max-height: 400px) {
+        #${LOGIN_PROMPT_IFRAME_ID} {
+          width: 100% !important;
+          max-width: none !important;
+        }
+      }
+
+      @keyframes passportEmbeddedLoginPromptOverlayFadeIn {
+        from {
+          opacity: 0;
+        }
+        to {
+          opacity: 1;
+        }
+      }
+    `;
+
+    document.head.appendChild(style);
+  };
+
+  private getEmbeddedLoginIFrame = (anonymousId?: string) => {
+    const embeddedLoginPrompt = document.createElement('iframe');
+    embeddedLoginPrompt.id = LOGIN_PROMPT_IFRAME_ID;
+    embeddedLoginPrompt.src = this.getHref(anonymousId);
+    embeddedLoginPrompt.style.height = '100vh';
+    embeddedLoginPrompt.style.width = '100vw';
+    embeddedLoginPrompt.style.maxHeight = `${LOGIN_PROMPT_WINDOW_HEIGHT}px`;
+    embeddedLoginPrompt.style.maxWidth = `${LOGIN_PROMPT_WINDOW_WIDTH}px`;
+    embeddedLoginPrompt.style.borderRadius = LOGIN_PROMPT_WINDOW_BORDER_RADIUS;
+
+    // Animation styles
+    embeddedLoginPrompt.style.opacity = '0';
+    embeddedLoginPrompt.style.transform = 'scale(0.6)';
+    embeddedLoginPrompt.style.animation = 'passportEmbeddedLoginPromptPopBounceIn 1s ease forwards';
+    EmbeddedLoginPrompt.appendIFrameStylesIfNeeded();
+
+    return embeddedLoginPrompt;
+  };
+
+  public displayEmbeddedLoginPrompt(anonymousId?: string): Promise<EmbeddedLoginPromptResult> {
+    return new Promise((resolve, reject) => {
+      const embeddedLoginPrompt = this.getEmbeddedLoginIFrame(anonymousId);
+      const messageHandler = ({ data, origin }: MessageEvent) => {
+        if (
+          origin !== this.config.authenticationDomain
+          || data.eventType !== EMBEDDED_LOGIN_PROMPT_EVENT_TYPE
+        ) {
+          return;
+        }
+
+        switch (data.messageType as EmbeddedLoginPromptReceiveMessage) {
+          case EmbeddedLoginPromptReceiveMessage.LOGIN_METHOD_SELECTED: {
+            const result = data.payload as EmbeddedLoginPromptResult;
+            window.removeEventListener('message', messageHandler);
+            EmbeddedLoginPromptOverlay.remove();
+            resolve(result);
+            break;
+          }
+          case EmbeddedLoginPromptReceiveMessage.LOGIN_PROMPT_ERROR: {
+            window.removeEventListener('message', messageHandler);
+            EmbeddedLoginPromptOverlay.remove();
+            reject(new Error('Error during embedded login prompt', { cause: data.payload }));
+            break;
+          }
+          case EmbeddedLoginPromptReceiveMessage.LOGIN_PROMPT_CLOSED: {
+            window.removeEventListener('message', messageHandler);
+            EmbeddedLoginPromptOverlay.remove();
+            reject(new Error('Popup closed by user'));
+            break;
+          }
+          default:
+            window.removeEventListener('message', messageHandler);
+            EmbeddedLoginPromptOverlay.remove();
+            reject(new Error(`Unsupported message type: ${data.messageType}`));
+            break;
+        }
+      };
+
+      window.addEventListener('message', messageHandler);
+      EmbeddedLoginPromptOverlay.appendOverlay(embeddedLoginPrompt, () => {
+        window.removeEventListener('message', messageHandler);
+        EmbeddedLoginPromptOverlay.remove();
+        reject(new Error('Popup closed by user'));
+      });
+    });
+  }
+}

package/src/confirmation/index.ts

@@ -0,0 +1,3 @@
+export { default as ConfirmationScreen } from './confirmation';
+export { default as EmbeddedLoginPrompt } from './embeddedLoginPrompt';
+export * from './types';

package/src/confirmation/popup.ts

@@ -0,0 +1,41 @@
+export type PopUpProps = {
+  url: string;
+  title: string;
+  width: number;
+  height: number;
+  query?: string;
+};
+
+export const openPopupCenter = ({
+  url,
+  title,
+  width,
+  height,
+}: PopUpProps): Window => {
+  const left = Math.max(
+    0,
+    Math.round(window.screenX + (window.outerWidth - width) / 2),
+  );
+  const top = Math.max(
+    0,
+    Math.round(window.screenY + (window.outerHeight - height) / 2),
+  );
+
+  const newWindow = window.open(
+    url,
+    title,
+    `
+      scrollbars=yes,
+      width=${width}, 
+      height=${height}, 
+      top=${top}, 
+      left=${left}
+     `,
+  );
+  if (!newWindow) {
+    throw new Error('Failed to open confirmation screen');
+  }
+
+  newWindow.focus();
+  return newWindow;
+};

package/src/confirmation/types.ts

@@ -0,0 +1,36 @@
+import { DirectLoginMethod, MarketingConsentStatus } from '../types';
+
+export enum ConfirmationSendMessage {
+  CONFIRMATION_START = 'confirmation_start',
+}
+
+export enum ConfirmationReceiveMessage {
+  CONFIRMATION_WINDOW_READY = 'confirmation_window_ready',
+  TRANSACTION_CONFIRMED = 'transaction_confirmed',
+  TRANSACTION_ERROR = 'transaction_error',
+  TRANSACTION_REJECTED = 'transaction_rejected',
+  MESSAGE_CONFIRMED = 'message_confirmed',
+  MESSAGE_ERROR = 'message_error',
+  MESSAGE_REJECTED = 'message_rejected',
+}
+
+export enum EmbeddedLoginPromptReceiveMessage {
+  LOGIN_METHOD_SELECTED = 'login_method_selected',
+  LOGIN_PROMPT_ERROR = 'login_prompt_error',
+  LOGIN_PROMPT_CLOSED = 'login_prompt_closed',
+}
+
+export type ConfirmationResult = {
+  confirmed: boolean;
+};
+
+export type EmbeddedLoginPromptResult = {
+  marketingConsentStatus: MarketingConsentStatus;
+  imPassportTraceId: string;
+} & (
+  | { directLoginMethod: 'email'; email: string }
+  | { directLoginMethod: Exclude<DirectLoginMethod, 'email'>; email?: never }
+);
+
+export const PASSPORT_CONFIRMATION_EVENT_TYPE = 'imx_passport_confirmation';
+export const EMBEDDED_LOGIN_PROMPT_EVENT_TYPE = 'im_passport_embedded_login_prompt';

package/src/errors.ts

@@ -0,0 +1,62 @@
+import { isAxiosError } from 'axios';
+import { imx } from '@imtbl/generated-clients';
+
+export enum PassportErrorType {
+  AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR',
+  INVALID_CONFIGURATION = 'INVALID_CONFIGURATION',
+  WALLET_CONNECTION_ERROR = 'WALLET_CONNECTION_ERROR',
+  NOT_LOGGED_IN_ERROR = 'NOT_LOGGED_IN_ERROR',
+  SILENT_LOGIN_ERROR = 'SILENT_LOGIN_ERROR',
+  REFRESH_TOKEN_ERROR = 'REFRESH_TOKEN_ERROR',
+  USER_REGISTRATION_ERROR = 'USER_REGISTRATION_ERROR',
+  USER_NOT_REGISTERED_ERROR = 'USER_NOT_REGISTERED_ERROR',
+  LOGOUT_ERROR = 'LOGOUT_ERROR',
+  TRANSFER_ERROR = 'TRANSFER_ERROR',
+  CREATE_ORDER_ERROR = 'CREATE_ORDER_ERROR',
+  CANCEL_ORDER_ERROR = 'CANCEL_ORDER_ERROR',
+  EXCHANGE_TRANSFER_ERROR = 'EXCHANGE_TRANSFER_ERROR',
+  CREATE_TRADE_ERROR = 'CREATE_TRADE_ERROR',
+  OPERATION_NOT_SUPPORTED_ERROR = 'OPERATION_NOT_SUPPORTED_ERROR',
+  LINK_WALLET_ALREADY_LINKED_ERROR = 'LINK_WALLET_ALREADY_LINKED_ERROR',
+  LINK_WALLET_MAX_WALLETS_LINKED_ERROR = 'LINK_WALLET_MAX_WALLETS_LINKED_ERROR',
+  LINK_WALLET_VALIDATION_ERROR = 'LINK_WALLET_VALIDATION_ERROR',
+  LINK_WALLET_DUPLICATE_NONCE_ERROR = 'LINK_WALLET_DUPLICATE_NONCE_ERROR',
+  LINK_WALLET_GENERIC_ERROR = 'LINK_WALLET_GENERIC_ERROR',
+  SERVICE_UNAVAILABLE_ERROR = 'SERVICE_UNAVAILABLE_ERROR',
+}
+
+export function isAPIError(error: any): error is imx.APIError {
+  return 'code' in error && 'message' in error;
+}
+
+export class PassportError extends Error {
+  public type: PassportErrorType;
+
+  constructor(message: string, type: PassportErrorType) {
+    super(message);
+    this.type = type;
+  }
+}
+
+export const withPassportError = async <T>(
+  fn: () => Promise<T>,
+  customErrorType: PassportErrorType,
+): Promise<T> => {
+  try {
+    return await fn();
+  } catch (error) {
+    let errorMessage: string;
+
+    if (error instanceof PassportError && error.type === PassportErrorType.SERVICE_UNAVAILABLE_ERROR) {
+      throw new PassportError(error.message, error.type);
+    }
+
+    if (isAxiosError(error) && error.response?.data && isAPIError(error.response.data)) {
+      errorMessage = error.response.data.message;
+    } else {
+      errorMessage = (error as Error).message;
+    }
+
+    throw new PassportError(errorMessage, customErrorType);
+  }
+};

package/src/index.ts

@@ -0,0 +1,33 @@
+// Export AuthManager for use by other packages
+export { default as AuthManager } from './authManager';
+
+// Export configuration
+export { AuthConfiguration, type IAuthConfiguration } from './config';
+
+// Export types
+export type {
+  User,
+  UserProfile,
+  UserImx,
+  UserZkEvm,
+  DirectLoginMethod,
+  DirectLoginOptions,
+  DeviceTokenResponse,
+  OidcConfiguration,
+  AuthModuleConfiguration,
+  PopupOverlayOptions,
+  PassportMetadata,
+  IdTokenPayload,
+  PKCEData,
+} from './types';
+export {
+  isUserZkEvm, isUserImx, RollupType, MarketingConsentStatus,
+} from './types';
+
+// Export errors
+export { PassportError, PassportErrorType, withPassportError } from './errors';
+
+// Export confirmation and overlay classes
+export { default as ConfirmationScreen } from './confirmation/confirmation';
+export { default as EmbeddedLoginPrompt } from './confirmation/embeddedLoginPrompt';
+export { default as ConfirmationOverlay } from './overlay/confirmationOverlay';