@explorins/pers-sdk-react-native 2.1.1 → 2.1.3

package/dist/index.js

@@ -6955,6 +6955,10 @@ var AuthStatus;
     AuthStatus["REFRESHING"] = "refreshing";
     /** No authentication present */
     AuthStatus["UNAUTHENTICATED"] = "unauthenticated";
+    /** Session restoration completed (fired once on SDK initialization) */
+    AuthStatus["SESSION_RESTORED"] = "session_restored";
+    /** Session restoration determined no valid session exists */
+    AuthStatus["SESSION_RESTORATION_FAILED"] = "session_restoration_failed";
 })(AuthStatus || (AuthStatus = {}));
 
 /**
@@ -7134,8 +7138,12 @@ class AuthService {
                 await extendedProvider.setProviderToken(providerToken);
             }
             if (authType && extendedProvider.setAuthType) {
+                console.log('[AuthService] Storing auth type:', authType);
                 await extendedProvider.setAuthType(authType);
             }
+            else {
+                console.warn('[AuthService] Auth type not stored - authType:', authType, 'has setAuthType:', !!extendedProvider.setAuthType);
+            }
             // Emit authenticated status on successful token storage
             await this.emitAuthStatus(AuthStatus.AUTHENTICATED);
         }
@@ -7154,8 +7162,15 @@ class TokenRefreshManager {
         this.authService = authService;
         this.authProvider = authProvider;
         this.tokenRefreshMarginSeconds = 120; // 2 minutes
+        this.lastValidationTime = 0;
+        this.validationCacheDurationMs = 30000; // 30 seconds
     }
     async ensureValidToken() {
+        const now = Date.now();
+        // Skip validation if we checked recently (within cache duration)
+        if (now - this.lastValidationTime < this.validationCacheDurationMs) {
+            return;
+        }
         try {
             const token = await this.authProvider.getToken();
             if (!token) {
@@ -7166,6 +7181,14 @@ class TokenRefreshManager {
                 if (!refreshSuccess) {
                     await this.authService.handleAuthFailure();
                 }
+                else {
+                    // Update validation time on successful refresh
+                    this.lastValidationTime = now;
+                }
+            }
+            else {
+                // Token is valid, update validation time
+                this.lastValidationTime = now;
             }
         }
         catch (error) {
@@ -7249,42 +7272,77 @@ class MemoryTokenStorage {
     }
 }
 /**
- * Token manager for authentication tokens
+ * Token manager for authentication tokens with memory caching
  */
 class AuthTokenManager {
     constructor(storage = new LocalStorageTokenStorage()) {
         this.storage = storage;
+        this.cache = {};
     }
     async getAccessToken() {
+        // Return cached value if available
+        if (this.cache.accessToken !== undefined) {
+            return this.cache.accessToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
         // Ensure we return string for tokens
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.accessToken = token;
+        return token;
     }
     async setAccessToken(token) {
+        this.cache.accessToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
     }
     async getRefreshToken() {
+        // Return cached value if available
+        if (this.cache.refreshToken !== undefined) {
+            return this.cache.refreshToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.refreshToken = token;
+        return token;
     }
     async setRefreshToken(token) {
+        this.cache.refreshToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
     }
     async getProviderToken() {
+        // Return cached value if available
+        if (this.cache.providerToken !== undefined) {
+            return this.cache.providerToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.providerToken = token;
+        return token;
     }
     async setProviderToken(token) {
+        this.cache.providerToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
     }
     async getAuthType() {
+        // Return cached value if available
+        if (this.cache.authType !== undefined) {
+            return this.cache.authType;
+        }
         const authType = await this.storage.get(AUTH_STORAGE_KEYS.AUTH_TYPE);
-        return typeof authType === 'string' ? authType : null;
+        const type = typeof authType === 'string' ? authType : null;
+        this.cache.authType = type;
+        return type;
     }
     async setAuthType(authType) {
+        this.cache.authType = authType;
         await this.storage.set(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
     }
     async setTokens(accessToken, refreshToken, providerToken) {
+        // Update cache for all tokens
+        this.cache.accessToken = accessToken;
+        if (refreshToken)
+            this.cache.refreshToken = refreshToken;
+        if (providerToken)
+            this.cache.providerToken = providerToken;
         await this.setAccessToken(accessToken);
         if (refreshToken)
             await this.setRefreshToken(refreshToken);
@@ -7292,13 +7350,23 @@ class AuthTokenManager {
             await this.setProviderToken(providerToken);
     }
     async clearAllTokens() {
+        // Clear cache
+        this.cache = {};
         await this.storage.clear();
     }
     async hasAccessToken() {
+        // Use cached value if available to avoid storage read
+        if (this.cache.accessToken !== undefined) {
+            return !!this.cache.accessToken;
+        }
         const token = await this.getAccessToken();
         return !!token;
     }
     async hasRefreshToken() {
+        // Use cached value if available to avoid storage read
+        if (this.cache.refreshToken !== undefined) {
+            return !!this.cache.refreshToken;
+        }
         const token = await this.getRefreshToken();
         return !!token;
     }
@@ -7526,6 +7594,7 @@ class DPoPManager {
 class DefaultAuthProvider {
     constructor(config = {}) {
         this.config = config;
+        this.authTypeCache = null;
         this.authType = config.authType || exports.AccountOwnerType.USER;
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
@@ -7586,6 +7655,15 @@ class DefaultAuthProvider {
     }
     async setAccessToken(token) {
         await this.tokenManager.setAccessToken(token);
+        // Invalidate cache when token changes
+        this.authTypeCache = null;
+        // Eager DPoP key generation after login
+        if (this.dpopManager) {
+            // Fire and forget - generate keys in background
+            this.dpopManager.ensureKeyPair().catch(err => {
+                console.warn('[DefaultAuthProvider] DPoP key generation failed:', err);
+            });
+        }
     }
     async setRefreshToken(token) {
         await this.tokenManager.setRefreshToken(token);
@@ -7595,16 +7673,51 @@ class DefaultAuthProvider {
     }
     async clearTokens() {
         await this.tokenManager.clearAllTokens();
+        // Invalidate cache on clear
+        this.authTypeCache = null;
         if (this.dpopManager) {
             await this.dpopManager.clearKeys();
         }
     }
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.tokenManager.setTokens(accessToken, refreshToken, providerToken);
+        // Invalidate cache when tokens change
+        this.authTypeCache = null;
     }
     async hasValidToken() {
         return this.tokenManager.hasAccessToken();
     }
+    async getAuthType() {
+        // Read from JWT instead of separate storage for single source of truth
+        const token = await this.tokenManager.getAccessToken();
+        if (!token) {
+            this.authTypeCache = null;
+            return null;
+        }
+        // Return cached result if token hasn't changed
+        if (this.authTypeCache && this.authTypeCache.token === token) {
+            return this.authTypeCache.type;
+        }
+        try {
+            // Decode JWT payload (without verification - we just need to read the claim)
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                console.warn('[DefaultAuthProvider] Invalid JWT format');
+                return null;
+            }
+            const payloadJson = atob(parts[1]);
+            const payload = JSON.parse(payloadJson);
+            // Use accountOwnerType from AuthJWTPayload interface
+            const authType = payload.accountType || null;
+            // Cache result with token signature
+            this.authTypeCache = { token, type: authType };
+            return authType;
+        }
+        catch (error) {
+            console.warn('[DefaultAuthProvider] Failed to parse auth type from JWT:', error);
+            return null;
+        }
+    }
 }
 
 /**
@@ -7618,7 +7731,7 @@ class DefaultAuthProvider {
 /** SDK package name */
 const SDK_NAME = '@explorins/pers-sdk';
 /** SDK version - TODO: Load dynamically from package.json */
-const SDK_VERSION = '2.1.0';
+const SDK_VERSION = '2.1.1';
 /** Full SDK identifier for headers */
 const SDK_USER_AGENT = `${SDK_NAME}/${SDK_VERSION}`;
 
@@ -13346,21 +13459,72 @@ class PersSDK {
         // Initialize event emitter and wire to API client for error events
         this._events = new PersEventEmitter();
         this.apiClient.setEvents(this._events);
-        // Initialize domain managers (pass events to managers that emit success events)
-        this._auth = new AuthManager(this.apiClient, this._events);
-        this._users = new UserManager(this.apiClient, this._events);
-        this._userStatus = new UserStatusManager(this.apiClient);
-        this._tokens = new TokenManager(this.apiClient);
-        this._businesses = new BusinessManager(this.apiClient, this._events);
-        this._campaigns = new CampaignManager(this.apiClient, this._events);
-        this._redemptions = new RedemptionManager(this.apiClient, this._events);
-        this._transactions = new TransactionManager(this.apiClient, this._events);
-        this._purchases = new PurchaseManager(this.apiClient);
-        this._files = new FileManager(this.apiClient);
-        this._tenants = new TenantManager(this.apiClient);
-        this._apiKeys = new ApiKeyManager(this.apiClient);
-        this._analytics = new AnalyticsManager(this.apiClient);
-        this._donations = new DonationManager(this.apiClient);
+    }
+    /**
+     * Restore user session from stored tokens
+     *
+     * Call this method after SDK initialization to restore the user's session
+     * if valid tokens exist. This is useful for maintaining login state across
+     * app restarts.
+     *
+     * **Important:** Only works for USER and BUSINESS accounts. Admin/tenant
+     * accounts don't support user data fetching, so this will return null for them
+     * (though their tokens remain valid for API calls).
+     *
+     * Emits auth domain success event when session is restored.
+     *
+     * @returns Promise resolving to User data if session restored, null if no session or admin account
+     * @throws {PersError} If token validation or user fetch fails
+     *
+     * @example
+     * ```typescript
+     * // Call after initial render for better perceived performance
+     * const user = await sdk.restoreSession();
+     * if (user) {
+     *   console.log('Welcome back,', user.name);
+     * }
+     * ```
+     */
+    async restoreSession() {
+        const hasToken = await this.auth.hasValidAuth();
+        if (!hasToken) {
+            return null;
+        }
+        // Check auth type - only restore session for user and business accounts
+        const authProvider = this.apiClient.getConfig().authProvider;
+        if (authProvider?.getAuthType) {
+            const authType = await authProvider.getAuthType();
+            if (authType === exports.AccountOwnerType.TENANT) {
+                // Admin sessions don't support getCurrentUser(), skip restoration
+                // Tokens are valid and will be used for API calls
+                return null;
+            }
+        }
+        try {
+            // Fetch user data to validate tokens and restore session
+            const userData = await this.auth.getCurrentUser();
+            // Emit event through proper event emitter
+            this._events.emitSuccess({
+                type: 'session_restored',
+                domain: 'authentication',
+                userMessage: 'Session restored successfully',
+                details: { userId: userData.id }
+            });
+            return userData;
+        }
+        catch (error) {
+            // Tokens exist but are invalid (expired, revoked, etc.)
+            await this.auth.clearAuth();
+            // Emit restoration failed event
+            this._events.emitError({
+                type: 'session_restoration_failed',
+                domain: 'authentication',
+                userMessage: 'Session restoration failed',
+                code: 'SESSION_INVALID',
+                details: { error }
+            });
+            throw error;
+        }
     }
     /**
      * Event emitter - Subscribe to SDK-wide events
@@ -13448,6 +13612,9 @@ class PersSDK {
      * @see {@link AuthManager} for detailed documentation
      */
     get auth() {
+        if (!this._auth) {
+            this._auth = new AuthManager(this.apiClient, this._events);
+        }
         return this._auth;
     }
     /**
@@ -13461,6 +13628,9 @@ class PersSDK {
      * ```
      */
     get users() {
+        if (!this._users) {
+            this._users = new UserManager(this.apiClient, this._events);
+        }
         return this._users;
     }
     /**
@@ -13474,6 +13644,9 @@ class PersSDK {
      * ```
      */
     get userStatus() {
+        if (!this._userStatus) {
+            this._userStatus = new UserStatusManager(this.apiClient);
+        }
         return this._userStatus;
     }
     /**
@@ -13487,6 +13660,9 @@ class PersSDK {
      * ```
      */
     get tokens() {
+        if (!this._tokens) {
+            this._tokens = new TokenManager(this.apiClient);
+        }
         return this._tokens;
     }
     /**
@@ -13500,6 +13676,9 @@ class PersSDK {
      * ```
      */
     get businesses() {
+        if (!this._businesses) {
+            this._businesses = new BusinessManager(this.apiClient, this._events);
+        }
         return this._businesses;
     }
     /**
@@ -13513,6 +13692,9 @@ class PersSDK {
      * ```
      */
     get campaigns() {
+        if (!this._campaigns) {
+            this._campaigns = new CampaignManager(this.apiClient, this._events);
+        }
         return this._campaigns;
     }
     /**
@@ -13526,6 +13708,9 @@ class PersSDK {
      * ```
      */
     get redemptions() {
+        if (!this._redemptions) {
+            this._redemptions = new RedemptionManager(this.apiClient, this._events);
+        }
         return this._redemptions;
     }
     /**
@@ -13539,6 +13724,9 @@ class PersSDK {
      * ```
      */
     get transactions() {
+        if (!this._transactions) {
+            this._transactions = new TransactionManager(this.apiClient, this._events);
+        }
         return this._transactions;
     }
     /**
@@ -13552,6 +13740,9 @@ class PersSDK {
      * ```
      */
     get purchases() {
+        if (!this._purchases) {
+            this._purchases = new PurchaseManager(this.apiClient);
+        }
         return this._purchases;
     }
     /**
@@ -13565,6 +13756,9 @@ class PersSDK {
      * ```
      */
     get files() {
+        if (!this._files) {
+            this._files = new FileManager(this.apiClient);
+        }
         return this._files;
     }
     /**
@@ -13578,6 +13772,9 @@ class PersSDK {
      * ```
      */
     get tenants() {
+        if (!this._tenants) {
+            this._tenants = new TenantManager(this.apiClient);
+        }
         return this._tenants;
     }
     /**
@@ -13602,6 +13799,9 @@ class PersSDK {
      * ```
      */
     get apiKeys() {
+        if (!this._apiKeys) {
+            this._apiKeys = new ApiKeyManager(this.apiClient);
+        }
         return this._apiKeys;
     }
     /**
@@ -13613,6 +13813,9 @@ class PersSDK {
      * ```
      */
     get analytics() {
+        if (!this._analytics) {
+            this._analytics = new AnalyticsManager(this.apiClient);
+        }
         return this._analytics;
     }
     /**
@@ -13624,6 +13827,9 @@ class PersSDK {
      * ```
      */
     get donations() {
+        if (!this._donations) {
+            this._donations = new DonationManager(this.apiClient);
+        }
         return this._donations;
     }
     /**
@@ -14518,11 +14724,19 @@ const SDKContext = react.createContext(null);
 // Provider component
 const PersSDKProvider = ({ children, config }) => {
     const initializingRef = react.useRef(false);
+    // State refs for stable functions to read current values
+    const sdkRef = react.useRef(null);
+    const isInitializedRef = react.useRef(false);
+    const isAuthenticatedRef = react.useRef(false);
     const [sdk, setSdk] = react.useState(null);
     const [authProvider, setAuthProvider] = react.useState(null);
     const [isInitialized, setIsInitialized] = react.useState(false);
     const [isAuthenticated, setIsAuthenticated] = react.useState(false);
     const [user, setUser] = react.useState(null);
+    // Keep state refs in sync immediately (not in useEffect to avoid race conditions)
+    sdkRef.current = sdk;
+    isInitializedRef.current = isInitialized;
+    isAuthenticatedRef.current = isAuthenticated;
     const initialize = react.useCallback(async (config) => {
         // Prevent multiple initializations
         if (isInitialized || initializingRef.current) {
@@ -14583,89 +14797,81 @@ const PersSDKProvider = ({ children, config }) => {
     // Auto-initialize if config is provided
     react.useEffect(() => {
         if (config && !isInitialized && !initializingRef.current) {
-            initialize(config).then(async () => {
-                // Validate stored tokens on startup
-                // SDK's initialize() already calls ensureValidToken() which handles expired tokens
-                // This provides an additional safety layer for missing/corrupted tokens
-                if (authProvider && sdk) {
-                    try {
-                        const hasToken = await sdk.auth.hasValidAuth();
-                        if (!hasToken) {
-                            console.log('[PersSDK] No tokens found on startup, ensuring clean state');
-                            await authProvider.clearTokens();
-                            setAuthenticationState(null, false);
-                        }
-                        // Note: Token expiration validation happens automatically in SDK's initialize()
-                        // which calls ensureValidToken() → checks expiration → triggers AUTH_FAILED if needed
-                    }
-                    catch (error) {
-                        console.warn('[PersSDK] Token validation on startup failed:', error);
-                    }
-                }
-            }).catch(err => {
+            initialize(config).catch(err => {
                 console.error('Auto-initialization failed:', err);
             });
         }
-    }, [config, isInitialized, initialize, authProvider, sdk, setAuthenticationState]);
+    }, [config, isInitialized, initialize]);
     const refreshUserData = react.useCallback(async () => {
-        if (!sdk || !isAuthenticated || !isInitialized) {
-            throw new Error('SDK not initialized or not authenticated. Cannot refresh user data.');
+        // Read from refs to get current values
+        const currentSdk = sdkRef.current;
+        const currentIsInitialized = isInitializedRef.current;
+        if (!currentSdk || !currentIsInitialized) {
+            throw new Error('SDK not initialized. Cannot refresh user data.');
         }
         try {
-            const freshUserData = await sdk.users.getCurrentUser();
+            const freshUserData = await currentSdk.users.getCurrentUser();
             setUser(freshUserData);
         }
         catch (error) {
             console.error('Failed to refresh user data:', error);
             throw error;
         }
-    }, [sdk, isAuthenticated, isInitialized]);
-    // Listen for authentication status changes and refresh user data when tokens are renewed
+    }, []); // No dependencies - reads from refs
+    const restoreSession = react.useCallback(async () => {
+        // Read from refs to get current values
+        const currentSdk = sdkRef.current;
+        const currentIsInitialized = isInitializedRef.current;
+        if (!currentSdk || !currentIsInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const userData = await currentSdk.restoreSession();
+            if (userData) {
+                setAuthenticationState(userData, true);
+            }
+            return userData;
+        }
+        catch (error) {
+            console.error('[PersSDK] Failed to restore session:', error);
+            throw error;
+        }
+    }, [setAuthenticationState]); // Depends on setAuthenticationState
+    // Listen for authentication events from core SDK
+    // Set up immediately when SDK is created (don't wait for isInitialized)
+    // to catch session_restored events that fire during SDK initialization
     react.useEffect(() => {
-        if (!authProvider || !isInitialized)
-            return;
-        // Access the config object with proper type safety
-        const providerConfig = authProvider.config;
-        if (!providerConfig)
+        if (!sdk)
             return;
-        // Set up auth status change handler
-        const originalHandler = providerConfig.onAuthStatusChange;
-        const authStatusHandler = async (status) => {
-            console.log('[PersSDK] Auth status changed:', status);
-            // Call original handler first if it exists
-            if (originalHandler) {
-                await originalHandler(status);
-            }
-            // If token was refreshed successfully and user is authenticated, reload user data
-            if (status === 'authenticated' && isAuthenticated && sdk) {
-                try {
-                    console.log('[PersSDK] Token refreshed, reloading user data...');
-                    await refreshUserData();
-                }
-                catch (error) {
-                    console.error('[PersSDK] Failed to refresh user data after token renewal:', error);
+        const unsubscribe = sdk.events.subscribe((event) => {
+            if (event.domain !== 'authentication')
+                return;
+            // Session restored successfully - sync React state
+            if (event.type === 'session_restored') {
+                console.log('[PersSDK] Session restoration event received, syncing state...');
+                // Read user from event details if available, otherwise fetch
+                const userId = event.details?.userId;
+                if (userId) {
+                    // User ID available, fetch user data
+                    sdk.users.getCurrentUser()
+                        .then(userData => {
+                        setAuthenticationState(userData, true);
+                    })
+                        .catch(error => {
+                        console.error('[PersSDK] Failed to sync restored session:', error);
+                    });
                 }
             }
-            // If authentication failed, clear state
-            // Frontend app can observe isAuthenticated state change to show custom UI
-            if (status === 'auth_failed') {
-                console.log('[PersSDK] Authentication failed - session expired');
-                // Note: Token clearing already handled by SDK's handleAuthFailure()
-                // which calls authProvider.clearTokens() with robust retry logic
-                // Clear React state to sync with SDK
-                // This triggers re-render, allowing app to show login screen
+            // Session restoration failed or auth error - clear React state
+            if (event.type === 'session_restoration_failed' || event.code === 'AUTH_FAILED') {
+                console.log('[PersSDK] Authentication failed - clearing session');
                 setAuthenticationState(null, false);
             }
-        };
-        // Inject our handler into the auth provider config
-        providerConfig.onAuthStatusChange = authStatusHandler;
-        // Cleanup
+        }, { domains: ['authentication'] });
         return () => {
-            if (originalHandler) {
-                providerConfig.onAuthStatusChange = originalHandler;
-            }
+            unsubscribe();
         };
-    }, [authProvider, isInitialized, isAuthenticated, sdk, refreshUserData, setAuthenticationState]);
+    }, [sdk, setAuthenticationState]);
     // iOS/Android: Monitor app state and validate tokens when app becomes active
     react.useEffect(() => {
         if (!sdk || reactNative.Platform.OS === 'web') {
@@ -14692,28 +14898,17 @@ const PersSDKProvider = ({ children, config }) => {
     const contextValue = react.useMemo(() => ({
         // Main SDK instance
         sdk,
-        // Manager shortcuts for convenience
-        auth: sdk?.auth || null,
-        users: sdk?.users || null,
-        tokens: sdk?.tokens || null,
-        businesses: sdk?.businesses || null,
-        campaigns: sdk?.campaigns || null,
-        redemptions: sdk?.redemptions || null,
-        transactions: sdk?.transactions || null,
-        purchases: sdk?.purchases || null,
-        tenants: sdk?.tenants || null,
-        analytics: sdk?.analytics || null,
-        donations: sdk?.donations || null,
         // Platform-specific providers
         authProvider,
         // State
         isInitialized,
         isAuthenticated,
         user,
-        // Methods
+        // Methods - expose functions directly, not through refs
         initialize,
         setAuthenticationState,
         refreshUserData,
+        restoreSession,
     }), [
         sdk,
         authProvider,
@@ -14722,7 +14917,8 @@ const PersSDKProvider = ({ children, config }) => {
         user,
         initialize,
         setAuthenticationState,
-        refreshUserData
+        refreshUserData,
+        restoreSession
     ]);
     return (jsxRuntime.jsx(SDKContext.Provider, { value: contextValue, children: children }));
 };
@@ -36063,7 +36259,7 @@ const useWeb3 = () => {
  */
 function useTokenBalances(options) {
     const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0 } = options;
-    const { isAuthenticated } = usePersSDK();
+    const { isAuthenticated, sdk } = usePersSDK();
     const web3 = useWeb3();
     const [tokenBalances, setTokenBalances] = react.useState([]);
     const [isLoading, setIsLoading] = react.useState(false);
@@ -36165,15 +36361,28 @@ function useTokenBalances(options) {
             loadBalances();
         }
     }, [autoLoad, isAvailable, availableTokens.length, loadBalances]);
-    // Optional auto-refresh interval
+    // Event-driven refresh: listen for transaction events instead of polling
     react.useEffect(() => {
-        if (refreshInterval > 0 && isAvailable && availableTokens.length > 0) {
-            const intervalId = setInterval(() => {
+        if (!sdk || refreshInterval <= 0 || !isAvailable)
+            return;
+        // Subscribe to transaction domain events
+        const unsubscribe = sdk.events.subscribe((event) => {
+            if (event.domain === 'transaction' && event.type === 'transaction_completed') {
+                console.log('[useTokenBalances] Transaction completed, refreshing balances...');
                 loadBalances();
-            }, refreshInterval);
-            return () => clearInterval(intervalId);
-        }
-    }, [refreshInterval, isAvailable, availableTokens.length, loadBalances]);
+            }
+        }, { domains: ['transaction'] });
+        // Also set up a fallback polling interval (much longer than before)
+        // This handles cases where events might be missed
+        const fallbackInterval = Math.max(refreshInterval, 60000); // Minimum 1 minute
+        const intervalId = setInterval(() => {
+            loadBalances();
+        }, fallbackInterval);
+        return () => {
+            unsubscribe();
+            clearInterval(intervalId);
+        };
+    }, [sdk, refreshInterval, isAvailable, loadBalances]);
     return {
         tokenBalances,
         isLoading,