@imtbl/passport 2.10.7-alpha.5 → 2.10.7-alpha.7

package/dist/types/Passport.d.ts

@@ -1,25 +1,38 @@
 import { IMXProvider } from '@imtbl/x-provider';
-import { Environment } from '@imtbl/config';
-import { Auth, UserProfile, DeviceTokenResponse } from '@imtbl/auth';
-import type { DirectLoginOptions } from '@imtbl/auth';
-import { ZkEvmProvider, WalletConfiguration } from '@imtbl/wallet';
-import type { LinkWalletParams, LinkedWallet } from '@imtbl/wallet';
-import { PassportModuleConfiguration, ConnectEvmArguments, LoginArguments } from './types';
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import { IMXClient } from '@imtbl/x-client';
+import AuthManager from './authManager';
+import MagicTEESigner from './magic/magicTEESigner';
 import { PassportImxProviderFactory } from './starkEx';
 import { PassportConfiguration } from './config';
+import { DirectLoginOptions, DeviceTokenResponse, LinkedWallet, LinkWalletParams, PassportEventMap, PassportModuleConfiguration, UserProfile, ConnectEvmArguments, LoginArguments } from './types';
+import { ConfirmationScreen, EmbeddedLoginPrompt } from './confirmation';
+import { Provider } from './zkEvm/types';
+import TypedEventEmitter from './utils/typedEventEmitter';
+import GuardianClient from './guardian';
 export declare const buildPrivateVars: (passportModuleConfiguration: PassportModuleConfiguration) => {
-    passportConfig: PassportConfiguration;
-    auth: Auth;
+    config: PassportConfiguration;
+    authManager: AuthManager;
+    magicTEESigner: MagicTEESigner;
+    confirmationScreen: ConfirmationScreen;
+    embeddedLoginPrompt: EmbeddedLoginPrompt;
+    immutableXClient: IMXClient;
+    multiRollupApiClients: MultiRollupApiClients;
+    passportEventEmitter: TypedEventEmitter<PassportEventMap>;
     passportImxProviderFactory: PassportImxProviderFactory;
-    environment: Environment;
-    walletConfig: WalletConfiguration;
+    guardianClient: GuardianClient;
 };
 export declare class Passport {
-    private readonly auth;
-    private readonly passportImxProviderFactory;
+    private readonly authManager;
+    private readonly config;
+    private readonly confirmationScreen;
+    private readonly embeddedLoginPrompt;
+    private readonly immutableXClient;
+    private readonly magicTEESigner;
     private readonly multiRollupApiClients;
-    private readonly environment;
-    private readonly passportConfig;
+    private readonly passportImxProviderFactory;
+    private readonly passportEventEmitter;
+    private readonly guardianClient;
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
     /**
      * Attempts to connect to IMX silently without user interaction.
@@ -34,17 +47,16 @@ export declare class Passport {
     connectImx(): Promise<IMXProvider>;
     /**
      * Connects to EVM and optionally announces the provider.
-     * Uses: Auth + Wallet packages
      * @param {Object} options - Configuration options
      * @param {boolean} options.announceProvider - Whether to announce the provider via EIP-6963 for wallet discovery (defaults to true)
      * @returns {Promise<Provider>} The EVM provider instance
      */
-    connectEvm(options?: ConnectEvmArguments): Promise<ZkEvmProvider>;
+    connectEvm(options?: ConnectEvmArguments): Promise<Provider>;
     /**
-     * Logs in the user (works for both zkEVM and IMX).
-     * Uses: Auth class
-     * @param {Object} [options] - Login options
-     * @param {boolean} [options.useCachedSession] - If true, attempts to use a cached session without user interaction.
+     * Initiates the login process.
+     * @param {Object} options - Login options
+     * @param {boolean} [options.useCachedSession] - If true, and no active session exists, the user won't be prompted to log in
+     * @param {string} [options.anonymousId] - ID used to enrich Passport internal metrics
      * @param {boolean} [options.useSilentLogin] - If true, attempts silent authentication without user interaction.
      *                                            Note: This takes precedence over useCachedSession if both are true
      * @param {boolean} [options.useRedirectFlow] - If true, uses redirect flow instead of popup flow
@@ -58,80 +70,70 @@ export declare class Passport {
      */
     login(options?: LoginArguments): Promise<UserProfile | null>;
     /**
-     * Handles the login callback from the authentication service.
-     * Uses: Auth class
-     * @returns {Promise<void>} A promise that resolves when the login callback is handled
+     * Handles the login callback.
+     * @returns {Promise<void>} A promise that resolves when the callback is processed
      */
     loginCallback(): Promise<void>;
     /**
-     * Logs out the user (works for both zkEVM and IMX).
-     * Uses: Auth class
-     * @returns {Promise<void>} A promise that resolves when the user is logged out
+     * Initiates a PKCE flow login.
+     * @param {DirectLoginOptions} [directLoginOptions] - If provided, directly redirects to the specified login method
+     * @param {string} [imPassportTraceId] - The trace ID for the PKCE flow
+     * @returns {string} The authorization URL for the PKCE flow
+     */
+    loginWithPKCEFlow(directLoginOptions?: DirectLoginOptions, imPassportTraceId?: string): Promise<string>;
+    /**
+     * Handles the PKCE flow login callback.
+     * @param {string} authorizationCode - The authorization code received from the OAuth provider
+     * @param {string} state - The state parameter for CSRF protection
+     * @returns {Promise<UserProfile>} A promise that resolves to the user profile
+     */
+    loginWithPKCEFlowCallback(authorizationCode: string, state: string): Promise<UserProfile>;
+    storeTokens(tokenResponse: DeviceTokenResponse): Promise<UserProfile>;
+    /**
+     * Logs out the current user.
+     * @returns {Promise<void>} A promise that resolves when the logout is complete
      */
     logout(): Promise<void>;
+    /**
+     * Returns the logout URL for the current user.
+     * @returns {Promise<string>} The logout URL
+     */
+    getLogoutUrl(): Promise<string | null>;
+    /**
+     * Handles the silent logout callback.
+     * @param {string} url - The callback URL to process
+     * @returns {Promise<void>} A promise that resolves when the silent logout is complete
+     */
+    logoutSilentCallback(url: string): Promise<void>;
     /**
      * Retrieves the current user's information.
-     * Uses: Auth class
      * @returns {Promise<UserProfile | undefined>} A promise that resolves to the user profile if logged in, undefined otherwise
      */
     getUserInfo(): Promise<UserProfile | undefined>;
     /**
-     * Retrieves the ID token.
+     * Retrieves the current user's ID token.
      * @returns {Promise<string | undefined>} A promise that resolves to the ID token if available, undefined otherwise
      */
     getIdToken(): Promise<string | undefined>;
     /**
-     * Retrieves the access token.
+     * Retrieves the current user's access token.
      * @returns {Promise<string | undefined>} A promise that resolves to the access token if available, undefined otherwise
      */
     getAccessToken(): Promise<string | undefined>;
-    /**
-     * Retrieves the PKCE authorization URL for the login flow.
-     * Uses: Auth class
-     * @param {DirectLoginOptions} [directLoginOptions] - Optional direct login options
-     * @param {string} [imPassportTraceId] - Optional trace ID
-     * @returns {Promise<string>} A promise that resolves to the authorization URL
-     */
-    loginWithPKCEFlow(directLoginOptions?: DirectLoginOptions, imPassportTraceId?: string): Promise<string>;
-    /**
-       * Handles the PKCE login callback.
-       * Uses: Auth class
-       * @param {string} authorizationCode - The authorization code from the OAuth provider
-       * @param {string} state - The state parameter for CSRF protection
-       * @returns {Promise<UserProfile>} A promise that resolves to the user profile
-       */
-    loginWithPKCEFlowCallback(authorizationCode: string, state: string): Promise<UserProfile>;
-    /**
-       * Stores the provided tokens and retrieves the user profile.
-       * Uses: Auth class
-       * @param {DeviceTokenResponse} tokenResponse - The token response from device flow
-       * @returns {Promise<UserProfile>} A promise that resolves to the user profile
-       */
-    storeTokens(tokenResponse: DeviceTokenResponse): Promise<UserProfile>;
-    /**
-     * Retrieves the logout URL.
-     * @returns {Promise<string | undefined>} A promise that resolves to the logout URL, or undefined if not available
-     */
-    getLogoutUrl(): Promise<string | undefined>;
-    /**
-     * Handles the silent logout callback.
-     * @param {string} url - The URL containing the logout information
-     * @returns {Promise<void>} A promise that resolves when the silent logout callback is handled
-     */
-    logoutSilentCallback(url: string): Promise<void>;
     /**
      * Retrieves the addresses linked to the current user's account.
      * @returns {Promise<string[]>} A promise that resolves to an array of linked addresses
      */
     getLinkedAddresses(): Promise<string[]>;
     /**
-     * Links an external wallet to the user's Passport account.
+     * Links an external wallet to the current user's account.
      * @param {LinkWalletParams} params - Parameters for linking the wallet
      * @returns {Promise<LinkedWallet>} A promise that resolves to the linked wallet information
-     * @throws {PassportError} If the user is not logged in (NOT_LOGGED_IN_ERROR)
-     *  - If the user is not registered with StarkEx (USER_NOT_REGISTERED_ERROR)
-     *  - If the wallet is already linked (LINK_WALLET_ALREADY_LINKED_ERROR)
-     *  - If the maximum number of wallets are linked (LINK_WALLET_MAX_WALLETS_LINKED_ERROR)
+     * @throws {PassportError} When:
+     *  - User is not logged in (NOT_LOGGED_IN_ERROR)
+     *  - User is not registered (USER_NOT_REGISTERED_ERROR)
+     *  - Wallet is already linked (LINK_WALLET_ALREADY_LINKED_ERROR)
+     *  - Maximum number of wallets reached (LINK_WALLET_MAX_WALLETS_LINKED_ERROR)
      *  - Duplicate nonce used (LINK_WALLET_DUPLICATE_NONCE_ERROR)
      *  - Validation fails (LINK_WALLET_VALIDATION_ERROR)
      *  - Other generic errors (LINK_WALLET_GENERIC_ERROR)

package/dist/types/Passport.int.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Passport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/authManager.d.ts

@@ -0,0 +1,61 @@
+import { DirectLoginOptions, User, DeviceTokenResponse, UserZkEvm, UserImx } from './types';
+import { PassportConfiguration } from './config';
+import { EmbeddedLoginPrompt } from './confirmation';
+export default class AuthManager {
+    private userManager;
+    private deviceCredentialsManager;
+    private readonly config;
+    private readonly embeddedLoginPrompt;
+    private readonly logoutMode;
+    /**
+     * Promise that is used to prevent multiple concurrent calls to the refresh token endpoint.
+     */
+    private refreshingPromise;
+    constructor(config: PassportConfiguration, embeddedLoginPrompt: EmbeddedLoginPrompt);
+    private static mapOidcUserToDomainModel;
+    private static mapDeviceTokenResponseToOidcUser;
+    private buildExtraQueryParams;
+    loginWithRedirect(anonymousId?: string, directLoginOptions?: DirectLoginOptions): Promise<void>;
+    /**
+     * login
+     * @param anonymousId Caller can pass an anonymousId if they want to associate their user's identity with immutable's internal instrumentation.
+     * @param directLoginOptions If provided, contains login method and marketing consent options
+     * @param directLoginOptions.directLoginMethod The login method to use (e.g., 'google', 'apple', 'email')
+     * @param directLoginOptions.marketingConsentStatus Marketing consent status ('opted_in' or 'unsubscribed')
+     * @param directLoginOptions.email Required when directLoginMethod is 'email'
+     */
+    login(anonymousId?: string, directLoginOptions?: DirectLoginOptions): Promise<User>;
+    getUserOrLogin(): Promise<User>;
+    loginCallback(): Promise<undefined | User>;
+    getPKCEAuthorizationUrl(directLoginOptions?: DirectLoginOptions, imPassportTraceId?: string): Promise<string>;
+    loginWithPKCEFlowCallback(authorizationCode: string, state: string): Promise<User>;
+    private getPKCEToken;
+    storeTokens(tokenResponse: DeviceTokenResponse): Promise<User>;
+    logout(): Promise<void>;
+    logoutSilentCallback(url: string): Promise<void>;
+    removeUser(): Promise<void>;
+    getLogoutUrl(): Promise<string | null>;
+    forceUserRefreshInBackground(): void;
+    forceUserRefresh(): Promise<User | null>;
+    /**
+     * Refreshes the token and returns the user.
+     * If the token is already being refreshed, returns the existing promise.
+     */
+    private refreshTokenAndUpdatePromise;
+    /**
+     *
+     * @param typeAssertion {(user: User) => boolean} - Optional. If provided, then the User will be checked against
+     * the typeAssertion. If the user meets the requirements, then it will be typed as T and returned. If the User
+     * does NOT meet the type assertion, then execution will continue, and we will attempt to obtain a User that does
+     * meet the type assertion.
+     *
+     * This function will attempt to obtain a User in the following order:
+     * 1. If the User is currently refreshing, wait for the refresh to complete.
+     * 2. Attempt to obtain a User from storage that has not expired.
+     * 3. Attempt to refresh the User if a refresh token is present.
+     * 4. Return null if no valid User can be obtained.
+     */
+    getUser<T extends User>(typeAssertion?: (user: User) => user is T): Promise<T | null>;
+    getUserZkEvm(): Promise<UserZkEvm>;
+    getUserImx(): Promise<UserImx>;
+}

package/dist/types/authManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/config/config.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableConfiguration } from '@imtbl/config';
 import { MultiRollupAPIConfiguration } from '@imtbl/generated-clients';
-import { OidcConfiguration, PassportModuleConfiguration, PopupOverlayOptions, PassportOverrides } from '../types';
+import { OidcConfiguration, PassportModuleConfiguration, PopupOverlayOptions } from '../types';
 export declare class PassportConfiguration {
     readonly authenticationDomain: string;
     readonly passportDomain: string;
@@ -16,8 +16,6 @@ export declare class PassportConfiguration {
     readonly multiRollupConfig: MultiRollupAPIConfiguration;
     readonly crossSdkBridgeEnabled: boolean;
     readonly forceScwDeployBeforeMessageSignature: boolean;
-    readonly jsonRpcReferrer?: string;
     readonly popupOverlayOptions: PopupOverlayOptions;
-    readonly overrides?: PassportOverrides;
     constructor({ baseConfig, overrides, crossSdkBridgeEnabled, jsonRpcReferrer, forceScwDeployBeforeMessageSignature, popupOverlayOptions, ...oidcConfiguration }: PassportModuleConfiguration);
 }

package/dist/types/confirmation/confirmation.d.ts

@@ -0,0 +1,28 @@
+import * as GeneratedClients from '@imtbl/generated-clients';
+import { ConfirmationResult } from './types';
+import { PassportConfiguration } from '../config';
+export declare const CONFIRMATION_IFRAME_ID = "passport-confirm";
+export declare 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;
+    private confirmationWindow;
+    private popupOptions;
+    private overlay;
+    private overlayClosed;
+    private timer;
+    constructor(config: PassportConfiguration);
+    private getHref;
+    requestConfirmation(transactionId: string, etherAddress: string, chainType: GeneratedClients.mr.TransactionApprovalRequestChainTypeEnum, chainId?: string): Promise<ConfirmationResult>;
+    requestMessageConfirmation(messageID: string, etherAddress: string, messageType?: MessageType): Promise<ConfirmationResult>;
+    showServiceUnavailable(): Promise<void>;
+    loading(popupOptions?: {
+        width: number;
+        height: number;
+    }): void;
+    closeWindow(): void;
+    showConfirmationScreen(href: string, messageHandler: MessageHandler, resolve: Function): void;
+    private recreateConfirmationWindow;
+}
+export {};

package/dist/types/confirmation/confirmation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/confirmation/embeddedLoginPrompt.d.ts

@@ -0,0 +1,10 @@
+import { EmbeddedLoginPromptResult } from './types';
+import { PassportConfiguration } from '../config';
+export default class EmbeddedLoginPrompt {
+    private config;
+    constructor(config: PassportConfiguration);
+    private getHref;
+    private static appendIFrameStylesIfNeeded;
+    private getEmbeddedLoginIFrame;
+    displayEmbeddedLoginPrompt(anonymousId?: string): Promise<EmbeddedLoginPromptResult>;
+}

package/dist/types/confirmation/embeddedLoginPrompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/confirmation/index.d.ts

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

package/dist/types/confirmation/popup.d.ts

@@ -0,0 +1,8 @@
+export type PopUpProps = {
+    url: string;
+    title: string;
+    width: number;
+    height: number;
+    query?: string;
+};
+export declare const openPopupCenter: ({ url, title, width, height, }: PopUpProps) => Window;

package/dist/types/confirmation/popup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/confirmation/types.d.ts

@@ -0,0 +1,33 @@
+import { DirectLoginMethod, MarketingConsentStatus } from '../types';
+export declare enum ConfirmationSendMessage {
+    CONFIRMATION_START = "confirmation_start"
+}
+export declare 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 declare 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 declare const PASSPORT_CONFIRMATION_EVENT_TYPE = "imx_passport_confirmation";
+export declare const EMBEDDED_LOGIN_PROMPT_EVENT_TYPE = "im_passport_embedded_login_prompt";

package/dist/types/errors/passportError.d.ts

@@ -20,8 +20,7 @@ export declare enum PassportErrorType {
     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",
-    TRANSACTION_REJECTED = "TRANSACTION_REJECTED"
+    SERVICE_UNAVAILABLE_ERROR = "SERVICE_UNAVAILABLE_ERROR"
 }
 export declare function isAPIError(error: any): error is imx.APIError;
 export declare class PassportError extends Error {

package/dist/types/guardian/index.d.ts

@@ -0,0 +1,58 @@
+import * as GeneratedClients from '@imtbl/generated-clients';
+import { BigNumberish } from 'ethers';
+import AuthManager from '../authManager';
+import { ConfirmationScreen } from '../confirmation';
+import { MetaTransaction, TypedDataPayload } from '../zkEvm/types';
+import { PassportConfiguration } from '../config';
+export type GuardianClientParams = {
+    confirmationScreen: ConfirmationScreen;
+    config: PassportConfiguration;
+    authManager: AuthManager;
+    guardianApi: GeneratedClients.mr.GuardianApi;
+};
+export type GuardianEvaluateImxTransactionParams = {
+    payloadHash: string;
+};
+type GuardianEVMTxnEvaluationParams = {
+    chainId: string;
+    nonce: string;
+    metaTransactions: MetaTransaction[];
+    isBackgroundTransaction?: boolean;
+};
+type GuardianEIP712MessageEvaluationParams = {
+    chainID: string;
+    payload: TypedDataPayload;
+};
+type GuardianERC191MessageEvaluationParams = {
+    chainID: bigint;
+    payload: string;
+};
+export declare const convertBigNumberishToString: (value: BigNumberish) => string;
+export default class GuardianClient {
+    private readonly guardianApi;
+    private readonly confirmationScreen;
+    private readonly crossSdkBridgeEnabled;
+    private readonly authManager;
+    constructor({ confirmationScreen, config, authManager, guardianApi, }: GuardianClientParams);
+    /**
+     * Open confirmation screen and close it automatically if the
+     * underlying task fails.
+     */
+    withConfirmationScreen(popupWindowSize?: {
+        width: number;
+        height: number;
+    }): <T>(task: () => Promise<T>) => Promise<T>;
+    withConfirmationScreenTask(popupWindowSize?: {
+        width: number;
+        height: number;
+    }): <T>(task: () => Promise<T>) => (() => Promise<T>);
+    withDefaultConfirmationScreenTask<T>(task: () => Promise<T>): (() => Promise<T>);
+    evaluateImxTransaction({ payloadHash }: GuardianEvaluateImxTransactionParams): Promise<void>;
+    private evaluateEVMTransaction;
+    validateEVMTransaction({ chainId, nonce, metaTransactions, isBackgroundTransaction, }: GuardianEVMTxnEvaluationParams): Promise<void>;
+    private handleEIP712MessageEvaluation;
+    evaluateEIP712Message({ chainID, payload }: GuardianEIP712MessageEvaluationParams): Promise<void>;
+    private handleERC191MessageEvaluation;
+    evaluateERC191Message({ chainID, payload }: GuardianERC191MessageEvaluationParams): Promise<void>;
+}
+export {};

package/dist/types/guardian/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { PassportError } from './errors/passportError';
 export { Passport } from './Passport';
-export { ProviderEvent, JsonRpcError, ProviderErrorCode, RpcErrorCode, } from '@imtbl/wallet';
-export type { RequestArguments, Provider, AccountsChangedEvent, TypedDataPayload, EIP6963ProviderInfo, EIP6963ProviderDetail, } from '@imtbl/wallet';
-export type { User, } from '@imtbl/auth';
-export type { LinkWalletParams, LinkedWallet, ConnectEvmArguments, LoginArguments, UserProfile, PassportOverrides, PassportModuleConfiguration, DeviceTokenResponse, DirectLoginOptions, DirectLoginMethod, ZkEvmProvider, } from './types';
+export { ProviderEvent, } from './zkEvm/types';
+export type { RequestArguments, JsonRpcRequestPayload, JsonRpcResponsePayload, JsonRpcRequestCallback, Provider, AccountsChangedEvent, TypedDataPayload, } from './zkEvm/types';
+export { JsonRpcError, ProviderErrorCode, RpcErrorCode, } from './zkEvm/JsonRpcError';
+export type { LinkWalletParams, LinkedWallet, ConnectEvmArguments, LoginArguments, UserProfile, PassportOverrides, PassportModuleConfiguration, DeviceTokenResponse, DirectLoginOptions, DirectLoginMethod, } from './types';
 export { MarketingConsentStatus, } from './types';

package/dist/types/magic/index.d.ts

@@ -0,0 +1 @@
+export { default as MagicTEESigner } from './magicTEESigner';

package/dist/types/magic/magicTEESigner.d.ts

@@ -0,0 +1,24 @@
+import { AbstractSigner, Signer } from 'ethers';
+import { MagicTeeApiClients } from '@imtbl/generated-clients';
+import AuthManager from '../authManager';
+export default class MagicTEESigner extends AbstractSigner {
+    private readonly authManager;
+    private readonly magicTeeApiClient;
+    private userWallet;
+    private createWalletPromise;
+    constructor(authManager: AuthManager, magicTeeApiClient: MagicTeeApiClients);
+    private getUserWallet;
+    /**
+     * This method calls the createWallet endpoint. The user's wallet must be created before it can be used to sign messages.
+     * The createWallet endpoint is idempotent, so it can be called multiple times without causing an error.
+     * If a createWallet request is already in flight, return the existing promise.
+     */
+    private createWallet;
+    private getUserOrThrow;
+    private static getHeaders;
+    getAddress(): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    connect(): Signer;
+    signTransaction(): Promise<string>;
+    signTypedData(): Promise<string>;
+}

package/dist/types/magic/magicTEESigner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/mocks/zkEvm/msw.d.ts

@@ -0,0 +1,39 @@
+import 'cross-fetch/polyfill';
+import { MockedRequest, RequestHandler } from 'msw';
+export declare const relayerId = "0x745";
+export declare const transactionHash = "0x867";
+export declare const mswHandlers: {
+    magicTEE: {
+        createWallet: {
+            success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+            internalServerError: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+        };
+        personalSign: {
+            success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+            internalServerError: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+        };
+    };
+    counterfactualAddress: {
+        success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+        internalServerError: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+    };
+    rpcProvider: {
+        success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+    };
+    relayer: {
+        success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+    };
+    guardian: {
+        evaluateTransaction: {
+            success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+        };
+    };
+    api: {
+        chains: {
+            success: import("msw").RestHandler<MockedRequest<import("msw").DefaultBodyType>>;
+        };
+    };
+};
+export declare const resetMswHandlers: () => void;
+export declare const useMswHandlers: (handlers: RequestHandler[]) => void;
+export declare const closeMswWorker: () => void;

package/dist/types/network/chains.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Enum representing different chain IDs.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain ID for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain ID for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain ID for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain ID for Ethereum.
+ * @property {number} SEPOLIA - The chain ID for Sepolia.
+ */
+export declare enum ChainId {
+    IMTBL_ZKEVM_MAINNET = 13371,
+    IMTBL_ZKEVM_TESTNET = 13473,
+    IMTBL_ZKEVM_DEVNET = 15003,
+    ETHEREUM = 1,
+    SEPOLIA = 11155111
+}
+/**
+ * Enum representing different chain names.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain name for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain name for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain name for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain name for Ethereum.
+ * @property {number} SEPOLIA - The chain name for Sepolia.
+ */
+export declare enum ChainName {
+    ETHEREUM = "Ethereum",
+    SEPOLIA = "Sepolia",
+    IMTBL_ZKEVM_TESTNET = "Immutable zkEVM Test",
+    IMTBL_ZKEVM_DEVNET = "Immutable zkEVM Dev",
+    IMTBL_ZKEVM_MAINNET = "Immutable zkEVM"
+}

package/dist/types/network/constants.d.ts

@@ -0,0 +1,3 @@
+import { ChainId, ChainName } from './chains';
+export type ChainMap = Map<ChainId, ChainName>;
+export declare const CHAIN_NAME_MAP: ChainMap;

package/dist/types/network/retry.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_RETRIES = 3;
+export type RetryOption = {
+    retries?: number;
+    interval?: number;
+    finalErr?: Error;
+    finallyFn?: () => void;
+};
+export declare const retryWithDelay: <T>(fn: () => Promise<T>, options?: RetryOption) => Promise<T>;

package/dist/types/network/retry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/overlay/confirmationOverlay.d.ts

@@ -0,0 +1,17 @@
+import { PopupOverlayOptions } from '../types';
+export default class ConfirmationOverlay {
+    private disableGenericPopupOverlay;
+    private disableBlockedPopupOverlay;
+    private overlay;
+    private isBlockedOverlay;
+    private tryAgainListener;
+    private onCloseListener;
+    constructor(popupOverlayOptions: PopupOverlayOptions, isBlockedOverlay?: boolean);
+    append(tryAgainOnClick: () => void, onCloseClick: () => void): void;
+    update(tryAgainOnClick: () => void): void;
+    remove(): void;
+    private shouldAppendOverlay;
+    private appendOverlay;
+    private updateTryAgainButton;
+    private updateCloseButton;
+}

package/dist/types/overlay/confirmationOverlay.test.d.ts

@@ -0,0 +1 @@
+export {};