@imtbl/wallet 2.12.6 → 2.12.7-alpha.1

package/src/types.ts

@@ -1,7 +1,5 @@
 import { Flow } from '@imtbl/metrics';
-import {
-  Auth, TypedEventEmitter, type AuthEventMap,
-} from '@imtbl/auth';
+import { TypedEventEmitter, User } from '@imtbl/auth';
 import { JsonRpcError } from './zkEvm/JsonRpcError';
 
 export enum EvmChain {
@@ -22,15 +20,15 @@ export interface WalletSigner {
 
 // Re-export auth types for convenience
 export type {
-  User, UserProfile, UserZkEvm, DirectLoginMethod, AuthEventMap,
+  User, UserProfile, UserZkEvm, DirectLoginMethod,
 } from '@imtbl/auth';
 export { isUserZkEvm } from '@imtbl/auth';
 export type { RollupType } from '@imtbl/auth';
-export { AuthEvents } from '@imtbl/auth';
 
-// Wallet-specific event (in addition to AuthEvents)
+// Wallet events
 export enum WalletEvents {
   ACCOUNTS_REQUESTED = 'accountsRequested',
+  LOGGED_OUT = 'loggedOut',
 }
 
 export type AccountsRequestedEvent = {
@@ -41,11 +39,15 @@ export type AccountsRequestedEvent = {
   flow?: Flow;
 };
 
-// PassportEventMap combines auth events and wallet-specific events
-export interface PassportEventMap extends AuthEventMap {
+// WalletEventMap for internal wallet events
+export interface WalletEventMap extends Record<string, any> {
   [WalletEvents.ACCOUNTS_REQUESTED]: [AccountsRequestedEvent];
+  [WalletEvents.LOGGED_OUT]: [];
 }
 
+// Legacy alias for backwards compatibility with Passport
+export type PassportEventMap = WalletEventMap;
+
 /**
  * EIP-1193 Provider Interface
  * Standard Ethereum provider interface for all chain types
@@ -228,16 +230,46 @@ export interface PopupOverlayOptions {
   disableBlockedPopupOverlay?: boolean;
 }
 
+/**
+ * Function type for getting the current user.
+ * Used as an alternative to passing an Auth instance.
+ * This function should return fresh tokens from the session manager.
+ *
+ * @param forceRefresh - When true, the auth layer should trigger a server-side
+ *   token refresh to get updated claims (e.g., after zkEVM registration).
+ *   This ensures the returned user has the latest data from the identity provider.
+ */
+export type GetUserFunction = (forceRefresh?: boolean) => Promise<User | null>;
+
 /**
  * Options for connecting a wallet via connectWallet()
  * High-level configuration that gets transformed into internal WalletConfiguration
  */
 export interface ConnectWalletOptions {
   /**
-   * Auth instance. Optional – if omitted, a default Auth instance
-   * configured with Immutable hosted defaults will be created.
+   * Function that returns the current user with fresh tokens.
+   * This is the primary way to provide authentication to the wallet.
+   *
+   * For NextAuth integration:
+   * @example
+   * ```typescript
+   * import { connectWallet } from '@imtbl/wallet';
+   * import { useImmutableSession } from '@imtbl/auth-next-client';
+   *
+   * const { getUser } = useImmutableSession();
+   * const provider = await connectWallet({ getUser });
+   * ```
+   *
+   * If not provided, a default implementation using @imtbl/auth will be created.
+   */
+  getUser?: GetUserFunction;
+
+  /**
+   * Client ID for Immutable authentication.
+   * Required when getUser is not provided (for default auth).
+   * Also used for session activity tracking.
    */
-  auth?: Auth;
+  clientId?: string;
 
   /**
    * Chain configurations (supports multi-chain)
@@ -272,5 +304,5 @@ export interface ConnectWalletOptions {
   /**
    * @internal - Only used by Passport for internal event communication
    */
-  passportEventEmitter?: TypedEventEmitter<PassportEventMap>;
+  passportEventEmitter?: TypedEventEmitter<WalletEventMap>;
 }

package/src/zkEvm/relayerClient.ts

@@ -1,13 +1,14 @@
 import type { PublicClient, Hex } from 'viem';
-import { Auth } from '@imtbl/auth';
+import { isUserZkEvm, type UserZkEvm } from '@imtbl/auth';
 import { WalletConfiguration } from '../config';
 import { FeeOption, RelayerTransaction, TypedDataPayload } from './types';
+import type { GetUserFunction } from '../types';
 import { getEip155ChainId } from './walletHelpers';
 
 export type RelayerClientInput = {
   config: WalletConfiguration,
   rpcProvider: PublicClient,
-  auth: Auth
+  getUser: GetUserFunction,
 };
 
 // JsonRpc base Types
@@ -94,12 +95,14 @@ export class RelayerClient {
 
   private readonly rpcProvider: PublicClient;
 
-  private readonly auth: Auth;
+  private readonly getUser: GetUserFunction;
 
-  constructor({ config, rpcProvider, auth }: RelayerClientInput) {
+  constructor({
+    config, rpcProvider, getUser,
+  }: RelayerClientInput) {
     this.config = config;
     this.rpcProvider = rpcProvider;
-    this.auth = auth;
+    this.getUser = getUser;
   }
 
   private static getResponsePreview(text: string): string {
@@ -108,6 +111,19 @@ export class RelayerClient {
       : text;
   }
 
+  /**
+   * Get zkEvm user using getUser function.
+   */
+  private async getUserZkEvm(): Promise<UserZkEvm> {
+    const user = await this.getUser();
+
+    if (!user || !isUserZkEvm(user)) {
+      throw new Error('User not authenticated or missing zkEvm data');
+    }
+
+    return user;
+  }
+
   private async postToRelayer<T>(request: RelayerTransactionRequest): Promise<T> {
     const body: RelayerTransactionRequest & JsonRpc = {
       id: 1,
@@ -115,7 +131,7 @@ export class RelayerClient {
       ...request,
     };
 
-    const user = await this.auth.getUserZkEvm();
+    const user = await this.getUserZkEvm();
 
     const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
       method: 'POST',

package/src/zkEvm/user/registerZkEvmUser.ts

@@ -2,13 +2,16 @@ import { MultiRollupApiClients } from '@imtbl/generated-clients';
 import { Flow } from '@imtbl/metrics';
 import type { PublicClient } from 'viem';
 import { getEip155ChainId } from '../walletHelpers';
-import { Auth } from '@imtbl/auth';
 import { JsonRpcError, RpcErrorCode } from '../JsonRpcError';
 import { signRaw } from '../../utils/crypto';
-import type { WalletSigner } from '../../types';
+import type { WalletSigner, GetUserFunction } from '../../types';
 
 export type RegisterZkEvmUserInput = {
-  auth: Auth;
+  /**
+   * Function to get fresh user tokens. Used for triggering background refresh after registration.
+   * If not provided, no background refresh is performed.
+   */
+  getUser?: GetUserFunction;
   ethSigner: WalletSigner,
   multiRollupApiClients: MultiRollupApiClients,
   accessToken: string;
@@ -19,7 +22,7 @@ export type RegisterZkEvmUserInput = {
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
 
 export async function registerZkEvmUser({
-  auth,
+  getUser,
   ethSigner,
   multiRollupApiClients,
   accessToken,
@@ -67,7 +70,15 @@ export async function registerZkEvmUser({
     });
     flow.addEvent('endCreateCounterfactualAddress');
 
-    auth.forceUserRefreshInBackground();
+    // Trigger a background refresh to get the updated user with zkEvm info.
+    // This is a best-effort operation - the caller will need to get updated
+    // user data from their session manager (e.g., NextAuth session callback
+    // will refresh tokens and return updated user).
+    if (getUser) {
+      getUser().catch(() => {
+        // Ignore errors - this is a best-effort refresh
+      });
+    }
 
     return registrationResponse.data.counterfactual_address;
   } catch (error) {

package/src/zkEvm/zkEvmProvider.ts

@@ -14,10 +14,10 @@ import {
   ProviderEventMap,
   RequestArguments,
 } from './types';
-import { Auth, TypedEventEmitter } from '@imtbl/auth';
+import { TypedEventEmitter } from '@imtbl/auth';
 import { WalletConfiguration } from '../config';
 import {
-  PassportEventMap, AuthEvents, WalletEvents, User, UserZkEvm, WalletSigner,
+  WalletEventMap, WalletEvents, User, UserZkEvm, WalletSigner, GetUserFunction,
 } from '../types';
 import { RelayerClient } from './relayerClient';
 import { JsonRpcError, ProviderErrorCode, RpcErrorCode } from './JsonRpcError';
@@ -32,20 +32,28 @@ import { sendDeployTransactionAndPersonalSign } from './sendDeployTransactionAnd
 import { signEjectionTransaction } from './signEjectionTransaction';
 
 export type ZkEvmProviderInput = {
-  auth: Auth;
+  /**
+   * Function that returns the current user with fresh tokens.
+   * This is the primary way to provide authentication to the wallet.
+   */
+  getUser: GetUserFunction;
+  /**
+   * Client ID for session activity tracking.
+   */
+  clientId: string;
   config: WalletConfiguration;
   multiRollupApiClients: MultiRollupApiClients;
-  passportEventEmitter: TypedEventEmitter<PassportEventMap>;
+  walletEventEmitter: TypedEventEmitter<WalletEventMap>;
   guardianClient: GuardianClient;
   ethSigner: WalletSigner;
   user: User | null;
   sessionActivityApiUrl: string | null;
 };
 
-const isZkEvmUser = (user: User): user is UserZkEvm => 'zkEvm' in user;
+const isZkEvmUser = (user: User): user is UserZkEvm => !!user.zkEvm;
 
 export class ZkEvmProvider implements Provider {
-  readonly #auth: Auth;
+  readonly #getUser: GetUserFunction;
 
   readonly #config: WalletConfiguration;
 
@@ -57,9 +65,9 @@ export class ZkEvmProvider implements Provider {
   readonly #providerEventEmitter: TypedEventEmitter<ProviderEventMap>;
 
   /**
-   * intended to emit internal Passport events
+   * intended to emit internal wallet events
    */
-  readonly #passportEventEmitter: TypedEventEmitter<ProviderEventMap>;
+  readonly #walletEventEmitter: TypedEventEmitter<WalletEventMap>;
 
   readonly #guardianClient: GuardianClient;
 
@@ -71,22 +79,26 @@ export class ZkEvmProvider implements Provider {
 
   readonly #ethSigner: WalletSigner;
 
+  readonly #clientId: string;
+
   public readonly isPassport: boolean = true;
 
   constructor({
-    auth,
+    getUser,
+    clientId,
     config,
     multiRollupApiClients,
-    passportEventEmitter,
+    walletEventEmitter,
     guardianClient,
     ethSigner,
     user,
     sessionActivityApiUrl,
   }: ZkEvmProviderInput) {
-    this.#auth = auth;
+    this.#getUser = getUser;
+    this.#clientId = clientId;
     this.#config = config;
     this.#guardianClient = guardianClient;
-    this.#passportEventEmitter = passportEventEmitter;
+    this.#walletEventEmitter = walletEventEmitter;
     this.#sessionActivityApiUrl = sessionActivityApiUrl;
     this.#ethSigner = ethSigner;
 
@@ -99,7 +111,7 @@ export class ZkEvmProvider implements Provider {
     this.#relayerClient = new RelayerClient({
       config: this.#config,
       rpcProvider: this.#rpcProvider,
-      auth: this.#auth,
+      getUser: this.#getUser,
     });
 
     this.#multiRollupApiClients = multiRollupApiClients;
@@ -109,13 +121,9 @@ export class ZkEvmProvider implements Provider {
       this.#callSessionActivity(user.zkEvm.ethAddress);
     }
 
-    passportEventEmitter.on(AuthEvents.LOGGED_IN, (loggedInUser: User) => {
-      if (isZkEvmUser(loggedInUser)) {
-        this.#callSessionActivity(loggedInUser.zkEvm.ethAddress);
-      }
-    });
-    passportEventEmitter.on(AuthEvents.LOGGED_OUT, this.#handleLogout);
-    passportEventEmitter.on(
+    // Listen for logout events
+    walletEventEmitter.on(WalletEvents.LOGGED_OUT, this.#handleLogout);
+    walletEventEmitter.on(
       WalletEvents.ACCOUNTS_REQUESTED,
       trackSessionActivity,
     );
@@ -125,7 +133,14 @@ export class ZkEvmProvider implements Provider {
     this.#providerEventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
   };
 
-  async #callSessionActivity(zkEvmAddress: string, clientId?: string) {
+  /**
+   * Get the current user using getUser function.
+   */
+  async #getCurrentUser(): Promise<User | null> {
+    return this.#getUser();
+  }
+
+  async #callSessionActivity(zkEvmAddress: string) {
     // Only emit session activity event for supported chains (mainnet, testnet, devnet)
     if (!this.#sessionActivityApiUrl) {
       return;
@@ -147,18 +162,19 @@ export class ZkEvmProvider implements Provider {
       nonceSpace,
       isBackgroundTransaction: true,
     });
-    this.#passportEventEmitter.emit(WalletEvents.ACCOUNTS_REQUESTED, {
+
+    this.#walletEventEmitter.emit(WalletEvents.ACCOUNTS_REQUESTED, {
       sessionActivityApiUrl: this.#sessionActivityApiUrl,
       sendTransaction: sendTransactionClosure,
       walletAddress: zkEvmAddress,
-      passportClient: clientId || await this.#auth.getClientId(),
+      passportClient: this.#clientId,
     });
   }
 
   // Used to get the registered zkEvm address from the User session
   async #getZkEvmAddress() {
     try {
-      const user = await this.#auth.getUser();
+      const user = await this.#getCurrentUser();
       if (user && isZkEvmUser(user)) {
         return user.zkEvm.ethAddress;
       }
@@ -179,8 +195,15 @@ export class ZkEvmProvider implements Provider {
         const flow = trackFlow('passport', 'ethRequestAccounts');
 
         try {
-          const user = await this.#auth.getUserOrLogin();
-          flow.addEvent('endGetUserOrLogin');
+          // Get user via getUser function
+          const user = await this.#getUser();
+          if (!user) {
+            throw new JsonRpcError(
+              ProviderErrorCode.UNAUTHORIZED,
+              'User not authenticated. Please log in first.',
+            );
+          }
+          flow.addEvent('endGetUser');
 
           let userZkEvmEthAddress: string | undefined;
 
@@ -189,13 +212,18 @@ export class ZkEvmProvider implements Provider {
 
             userZkEvmEthAddress = await registerZkEvmUser({
               ethSigner: this.#ethSigner,
-              auth: this.#auth,
+              getUser: this.#getUser,
               multiRollupApiClients: this.#multiRollupApiClients,
               accessToken: user.accessToken,
               rpcProvider: this.#rpcProvider,
               flow,
             });
             flow.addEvent('endUserRegistration');
+
+            // Force refresh to update session with zkEvm claims from IDP
+            // This ensures subsequent getUser() calls return the updated user
+            await this.#getUser(true);
+            flow.addEvent('endForceRefresh');
           } else {
             userZkEvmEthAddress = user.zkEvm.ethAddress;
           }
@@ -420,10 +448,9 @@ export class ZkEvmProvider implements Provider {
         }
       }
       case 'im_addSessionActivity': {
-        const [clientId] = request.params || [];
         const zkEvmAddress = await this.#getZkEvmAddress();
         if (zkEvmAddress) {
-          this.#callSessionActivity(zkEvmAddress, clientId);
+          this.#callSessionActivity(zkEvmAddress);
         }
         return null;
       }