@imtbl/passport 2.11.0 → 2.11.1-alpha.1

package/dist/types/Passport.d.ts

@@ -1,38 +1,25 @@
 import { IMXProvider } from '@imtbl/x-provider';
-import { MultiRollupApiClients } from '@imtbl/generated-clients';
-import { IMXClient } from '@imtbl/x-client';
-import AuthManager from './authManager';
-import MagicTEESigner from './magic/magicTEESigner';
+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 { 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) => {
-    config: PassportConfiguration;
-    authManager: AuthManager;
-    magicTEESigner: MagicTEESigner;
-    confirmationScreen: ConfirmationScreen;
-    embeddedLoginPrompt: EmbeddedLoginPrompt;
-    immutableXClient: IMXClient;
-    multiRollupApiClients: MultiRollupApiClients;
-    passportEventEmitter: TypedEventEmitter<PassportEventMap>;
+    passportConfig: PassportConfiguration;
+    auth: Auth;
     passportImxProviderFactory: PassportImxProviderFactory;
-    guardianClient: GuardianClient;
+    environment: Environment;
+    walletConfig: WalletConfiguration;
 };
 export declare class Passport {
-    private readonly authManager;
-    private readonly config;
-    private readonly confirmationScreen;
-    private readonly embeddedLoginPrompt;
-    private readonly immutableXClient;
-    private readonly magicTEESigner;
-    private readonly multiRollupApiClients;
+    private readonly auth;
     private readonly passportImxProviderFactory;
-    private readonly passportEventEmitter;
-    private readonly guardianClient;
+    private readonly multiRollupApiClients;
+    private readonly environment;
+    private readonly passportConfig;
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
     /**
      * Attempts to connect to IMX silently without user interaction.
@@ -47,16 +34,17 @@ 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<Provider>;
+    connectEvm(options?: ConnectEvmArguments): Promise<ZkEvmProvider>;
     /**
-     * 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
+     * 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.
      * @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
@@ -70,70 +58,80 @@ export declare class Passport {
      */
     login(options?: LoginArguments): Promise<UserProfile | null>;
     /**
-     * Handles the login callback.
-     * @returns {Promise<void>} A promise that resolves when the callback is processed
+     * Handles the login callback from the authentication service.
+     * Uses: Auth class
+     * @returns {Promise<void>} A promise that resolves when the login callback is handled
      */
     loginCallback(): Promise<void>;
     /**
-     * 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
+     * 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
      */
     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 current user's ID token.
+     * Retrieves the ID token.
      * @returns {Promise<string | undefined>} A promise that resolves to the ID token if available, undefined otherwise
      */
     getIdToken(): Promise<string | undefined>;
     /**
-     * Retrieves the current user's access token.
+     * Retrieves the 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 current user's account.
+     * Links an external wallet to the user's Passport account.
      * @param {LinkWalletParams} params - Parameters for linking the wallet
      * @returns {Promise<LinkedWallet>} A promise that resolves to the linked wallet information
-     * @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)
+     * @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)
      *  - Duplicate nonce used (LINK_WALLET_DUPLICATE_NONCE_ERROR)
      *  - Validation fails (LINK_WALLET_VALIDATION_ERROR)
      *  - Other generic errors (LINK_WALLET_GENERIC_ERROR)

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 } from '../types';
+import { OidcConfiguration, PassportModuleConfiguration, PopupOverlayOptions, PassportOverrides } from '../types';
 export declare class PassportConfiguration {
     readonly authenticationDomain: string;
     readonly passportDomain: string;
@@ -16,6 +16,8 @@ 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/errors/passportError.d.ts

@@ -1,30 +1 @@
-import { imx } from '@imtbl/generated-clients';
-export declare 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 declare function isAPIError(error: any): error is imx.APIError;
-export declare class PassportError extends Error {
-    type: PassportErrorType;
-    constructor(message: string, type: PassportErrorType);
-}
-export declare const withPassportError: <T>(fn: () => Promise<T>, customErrorType: PassportErrorType) => Promise<T>;
+export { PassportError, PassportErrorType, withPassportError, isAPIError, } from '@imtbl/auth';

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { PassportError } from './errors/passportError';
 export { Passport } from './Passport';
-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 { 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 { MarketingConsentStatus, } from './types';

package/dist/types/starkEx/imxGuardianClient.d.ts

@@ -0,0 +1,18 @@
+import { Auth } from '@imtbl/auth';
+import { mr as MultiRollup } from '@imtbl/generated-clients';
+import { ConfirmationScreen } from '@imtbl/wallet';
+type ImxGuardianClientParams = {
+    auth: Auth;
+    guardianApi: MultiRollup.GuardianApi;
+    confirmationScreen: ConfirmationScreen;
+    crossSdkBridgeEnabled?: boolean;
+};
+export declare class ImxGuardianClient {
+    private readonly auth;
+    private readonly guardianApi;
+    private readonly confirmationScreen;
+    private readonly crossSdkBridgeEnabled;
+    constructor({ auth, guardianApi, confirmationScreen, crossSdkBridgeEnabled, }: ImxGuardianClientParams);
+    evaluateTransaction(payloadHash: string): Promise<void>;
+}
+export {};

package/dist/types/starkEx/passportImxProvider.d.ts

@@ -2,26 +2,26 @@ import { AnyToken, IMXClient, NftTransferDetails, TokenAmount, UnsignedExchangeT
 import { IMXProvider } from '@imtbl/x-provider';
 import { imx, ImxApiClients } from '@imtbl/generated-clients';
 import { TransactionResponse } from 'ethers';
-import AuthManager from '../authManager';
-import GuardianClient from '../guardian';
-import { PassportEventMap } from '../types';
-import MagicTEESigner from '../magic/magicTEESigner';
-import TypedEventEmitter from '../utils/typedEventEmitter';
+import { Auth, AuthEventMap, TypedEventEmitter } from '@imtbl/auth';
+import { GuardianClient, MagicTEESigner } from '@imtbl/wallet';
+import { ImxGuardianClient } from './imxGuardianClient';
 export interface PassportImxProviderOptions {
-    authManager: AuthManager;
+    auth: Auth;
     immutableXClient: IMXClient;
-    passportEventEmitter: TypedEventEmitter<PassportEventMap>;
+    passportEventEmitter: TypedEventEmitter<AuthEventMap>;
     magicTEESigner: MagicTEESigner;
     imxApiClients: ImxApiClients;
     guardianClient: GuardianClient;
+    imxGuardianClient: ImxGuardianClient;
 }
 export declare class PassportImxProvider implements IMXProvider {
     #private;
-    protected readonly authManager: AuthManager;
+    protected readonly auth: Auth;
     private readonly immutableXClient;
     protected readonly guardianClient: GuardianClient;
     protected readonly imxApiClients: ImxApiClients;
     protected magicTEESigner: MagicTEESigner;
+    private readonly imxGuardianClient;
     /**
      * This property is set during initialisation and stores the signers in a promise.
      * This property is not meant to be accessed directly, but through the
@@ -30,7 +30,7 @@ export declare class PassportImxProvider implements IMXProvider {
      */
     private starkSigner;
     private signerInitialisationError;
-    constructor({ authManager, immutableXClient, passportEventEmitter, magicTEESigner, imxApiClients, guardianClient, }: PassportImxProviderOptions);
+    constructor({ auth, immutableXClient, passportEventEmitter, magicTEESigner, imxApiClients, guardianClient, imxGuardianClient, }: PassportImxProviderOptions);
     private handleLogout;
     transfer(request: UnsignedTransferRequest): Promise<imx.CreateTransferResponseV1>;
     registerOffchain(): Promise<imx.RegisterUserResponse>;

package/dist/types/starkEx/passportImxProviderFactory.d.ts

@@ -1,27 +1,27 @@
 import { IMXClient } from '@imtbl/x-client';
 import { IMXProvider } from '@imtbl/x-provider';
 import { ImxApiClients } from '@imtbl/generated-clients';
-import AuthManager from '../authManager';
-import { PassportEventMap } from '../types';
-import GuardianClient from '../guardian';
-import MagicTEESigner from '../magic/magicTEESigner';
-import TypedEventEmitter from '../utils/typedEventEmitter';
+import { Auth, AuthEventMap, TypedEventEmitter } from '@imtbl/auth';
+import { GuardianClient, MagicTEESigner } from '@imtbl/wallet';
+import { ImxGuardianClient } from './imxGuardianClient';
 export type PassportImxProviderFactoryInput = {
-    authManager: AuthManager;
+    auth: Auth;
     immutableXClient: IMXClient;
     magicTEESigner: MagicTEESigner;
-    passportEventEmitter: TypedEventEmitter<PassportEventMap>;
+    passportEventEmitter: TypedEventEmitter<AuthEventMap>;
     imxApiClients: ImxApiClients;
     guardianClient: GuardianClient;
+    imxGuardianClient: ImxGuardianClient;
 };
 export declare class PassportImxProviderFactory {
-    private readonly authManager;
+    private readonly auth;
     private readonly immutableXClient;
     private readonly magicTEESigner;
     private readonly passportEventEmitter;
     readonly imxApiClients: ImxApiClients;
     private readonly guardianClient;
-    constructor({ authManager, immutableXClient, magicTEESigner, passportEventEmitter, imxApiClients, guardianClient, }: PassportImxProviderFactoryInput);
+    private readonly imxGuardianClient;
+    constructor({ auth, immutableXClient, magicTEESigner, passportEventEmitter, imxApiClients, guardianClient, imxGuardianClient, }: PassportImxProviderFactoryInput);
     getProvider(): Promise<IMXProvider>;
     getProviderSilent(): Promise<IMXProvider | null>;
     private createProviderInstance;

package/dist/types/starkEx/workflows/order.d.ts

@@ -1,20 +1,20 @@
 import { imx } from '@imtbl/generated-clients';
 import { StarkSigner, UnsignedOrderRequest } from '@imtbl/x-client';
+import { ImxGuardianClient } from '../imxGuardianClient';
 import { UserImx } from '../../types';
-import GuardianClient from '../../guardian';
 type CancelOrderParams = {
     request: imx.GetSignableCancelOrderRequest;
     ordersApi: imx.OrdersApi;
     user: UserImx;
     starkSigner: StarkSigner;
-    guardianClient: GuardianClient;
+    guardianClient: ImxGuardianClient;
 };
 type CreateOrderParams = {
     request: UnsignedOrderRequest;
     ordersApi: imx.OrdersApi;
     user: UserImx;
     starkSigner: StarkSigner;
-    guardianClient: GuardianClient;
+    guardianClient: ImxGuardianClient;
 };
 export declare function createOrder({ starkSigner, user, request, ordersApi, guardianClient, }: CreateOrderParams): Promise<imx.CreateOrderResponse>;
 export declare function cancelOrder({ user, starkSigner, request, ordersApi, guardianClient, }: CancelOrderParams): Promise<imx.CancelOrderResponse>;

package/dist/types/starkEx/workflows/registerOffchain.d.ts

@@ -1,5 +1,4 @@
 import { ImxApiClients, imx } from '@imtbl/generated-clients';
 import { EthSigner, StarkSigner } from '@imtbl/x-client';
-import AuthManager from '../../authManager';
-import { User } from '../../types';
-export default function registerOffchain(userAdminKeySigner: EthSigner, starkSigner: StarkSigner, unregisteredUser: User, authManager: AuthManager, imxApiClients: ImxApiClients): Promise<imx.RegisterUserResponse>;
+import { Auth, User } from '@imtbl/auth';
+export default function registerOffchain(userAdminKeySigner: EthSigner, starkSigner: StarkSigner, unregisteredUser: User, auth: Auth, imxApiClients: ImxApiClients): Promise<imx.RegisterUserResponse>;

package/dist/types/starkEx/workflows/trades.d.ts

@@ -1,13 +1,13 @@
 import { imx } from '@imtbl/generated-clients';
 import { StarkSigner } from '@imtbl/x-client';
+import { ImxGuardianClient } from '../imxGuardianClient';
 import { UserImx } from '../../types';
-import GuardianClient from '../../guardian';
 type CreateTradeParams = {
     request: imx.GetSignableTradeRequest;
     tradesApi: imx.TradesApi;
     user: UserImx;
     starkSigner: StarkSigner;
-    guardianClient: GuardianClient;
+    guardianClient: ImxGuardianClient;
 };
 export declare function createTrade({ request, tradesApi, user, starkSigner, guardianClient, }: CreateTradeParams): Promise<imx.CreateTradeResponse>;
 export {};

package/dist/types/starkEx/workflows/transfer.d.ts

@@ -1,20 +1,20 @@
 import { imx } from '@imtbl/generated-clients';
 import { StarkSigner, NftTransferDetails, UnsignedTransferRequest } from '@imtbl/x-client';
+import { ImxGuardianClient } from '../imxGuardianClient';
 import { UserImx } from '../../types';
-import GuardianClient from '../../guardian';
 type TransferRequest = {
     request: UnsignedTransferRequest;
     user: UserImx;
     starkSigner: StarkSigner;
     transfersApi: imx.TransfersApi;
-    guardianClient: GuardianClient;
+    guardianClient: ImxGuardianClient;
 };
 type BatchTransfersParams = {
     request: Array<NftTransferDetails>;
     user: UserImx;
     starkSigner: StarkSigner;
     transfersApi: imx.TransfersApi;
-    guardianClient: GuardianClient;
+    guardianClient: ImxGuardianClient;
 };
 export declare function transfer({ request, transfersApi, starkSigner, user, guardianClient, }: TransferRequest): Promise<imx.CreateTransferResponseV1>;
 export declare function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }: BatchTransfersParams): Promise<imx.CreateTransferResponse>;

package/dist/types/types.d.ts

@@ -8,11 +8,8 @@ import { Flow } from '@imtbl/metrics';
  * Additional providers may be supported server-side
  */
 export type DirectLoginMethod = string;
-export declare enum PassportEvents {
-    LOGGED_OUT = "loggedOut",
-    LOGGED_IN = "loggedIn",
-    ACCOUNTS_REQUESTED = "accountsRequested"
-}
+export { AuthEvents } from '@imtbl/auth';
+export { WalletEvents } from '@imtbl/wallet';
 export type AccountsRequestedEvent = {
     environment: Environment;
     sendTransaction: (params: Array<any>, flow: Flow) => Promise<string>;
@@ -20,44 +17,9 @@ export type AccountsRequestedEvent = {
     passportClient: string;
     flow?: Flow;
 };
-export interface PassportEventMap extends Record<string, any> {
-    [PassportEvents.LOGGED_OUT]: [];
-    [PassportEvents.LOGGED_IN]: [User];
-    [PassportEvents.ACCOUNTS_REQUESTED]: [AccountsRequestedEvent];
-}
-export type UserProfile = {
-    email?: string;
-    nickname?: string;
-    sub: string;
-    username?: string;
-};
-export declare enum RollupType {
-    IMX = "imx",
-    ZKEVM = "zkEvm"
-}
-export type User = {
-    idToken?: string;
-    accessToken: string;
-    refreshToken?: string;
-    profile: UserProfile;
-    expired?: boolean;
-    [RollupType.IMX]?: {
-        ethAddress: string;
-        starkAddress: string;
-        userAdminAddress: string;
-    };
-    [RollupType.ZKEVM]?: {
-        ethAddress: string;
-        userAdminAddress: string;
-    };
-};
-export type PassportMetadata = {
-    imx_eth_address: string;
-    imx_stark_address: string;
-    imx_user_admin_address: string;
-    zkevm_eth_address: string;
-    zkevm_user_admin_address: string;
-};
+export type { User, UserProfile, DeviceTokenResponse, IdTokenPayload, } from '@imtbl/auth';
+export { isUserZkEvm } from '@imtbl/auth';
+export type { UserImx } from './utils/imxUser';
 export interface OidcConfiguration {
     clientId: string;
     logoutRedirectUri?: string;
@@ -80,6 +42,21 @@ export interface PassportOverrides {
     orderBookMrBasePath: string;
     passportMrBasePath: string;
     imxApiClients?: ImxApiClients;
+    /**
+     * Custom chain ID for dev environments (optional)
+     * If provided, overrides the default chainId based on environment
+     */
+    zkEvmChainId?: number;
+    /**
+     * Custom chain name for dev environments (optional)
+     * Used when zkEvmChainId is provided
+     */
+    zkEvmChainName?: string;
+    /**
+     * Magic TEE base path (optional, for dev/custom environments)
+     * Defaults to 'https://tee.express.magiclabs.com'
+     */
+    magicTeeBasePath?: string;
 }
 export interface PopupOverlayOptions {
     disableGenericPopupOverlay?: boolean;
@@ -109,55 +86,18 @@ export interface PassportModuleConfiguration extends ModuleConfiguration<Passpor
      */
     forceScwDeployBeforeMessageSignature?: boolean;
 }
-type WithRequired<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
-export type UserImx = WithRequired<User, RollupType.IMX>;
-export type UserZkEvm = WithRequired<User, RollupType.ZKEVM>;
-export declare const isUserZkEvm: (user: User) => user is UserZkEvm;
-export declare const isUserImx: (user: User) => user is UserImx;
-export type DeviceTokenResponse = {
-    access_token: string;
-    refresh_token?: string;
-    id_token: string;
-    token_type: string;
-    expires_in: number;
-};
 export type TokenPayload = {
     exp?: number;
 };
-export type IdTokenPayload = {
-    passport?: PassportMetadata;
-    email: string;
-    nickname: string;
-    username?: string;
-    aud: string;
-    sub: string;
-    exp: number;
-    iss: string;
-    iat: number;
-};
 export type PKCEData = {
     state: string;
     verifier: string;
 };
-export type LinkWalletParams = {
-    type: string;
-    walletAddress: string;
-    signature: string;
-    nonce: string;
-};
-export type LinkedWallet = {
-    address: string;
-    type: string;
-    created_at: string;
-    updated_at: string;
-    name?: string;
-    clientName: string;
-};
+export type { LinkWalletParams, LinkedWallet } from '@imtbl/wallet';
 export type ConnectEvmArguments = {
     announceProvider: boolean;
 };
+export type { ZkEvmProvider } from '@imtbl/wallet';
 export type LoginArguments = {
     useCachedSession?: boolean;
     anonymousId?: string;
@@ -178,4 +118,3 @@ export type DirectLoginOptions = {
     directLoginMethod: Exclude<DirectLoginMethod, 'email'>;
     email?: never;
 });
-export {};

package/dist/types/utils/httpError.d.ts

@@ -0,0 +1,8 @@
+type HttpErrorResponse = {
+    status?: number;
+    data?: unknown;
+};
+export declare const getHttpErrorResponse: (error: unknown) => HttpErrorResponse | undefined;
+export declare const getHttpStatus: (error: unknown) => number | undefined;
+export declare const getHttpResponseData: <T>(error: unknown) => T | undefined;
+export {};

package/dist/types/utils/imxUser.d.ts

@@ -0,0 +1,9 @@
+import type { User } from '@imtbl/auth';
+export type UserImx = User & {
+    imx: {
+        ethAddress: string;
+        starkAddress: string;
+        userAdminAddress: string;
+    };
+};
+export declare const toUserImx: (user: User) => UserImx;

package/dist/types/utils/metrics.d.ts

@@ -1,3 +1,2 @@
 import { Flow } from '@imtbl/metrics';
-export declare const withMetrics: <T>(fn: (flow: Flow) => T, flowName: string, trackStartEvent?: boolean, trackEndEvent?: boolean) => T;
 export declare const withMetricsAsync: <T>(fn: (flow: Flow) => Promise<T>, flowName: string, trackStartEvent?: boolean, trackEndEvent?: boolean) => Promise<T>;