@explorins/pers-sdk-react-native 2.1.7 → 2.1.8

package/dist/hooks/useTokenBalances.d.ts

@@ -29,7 +29,11 @@ export interface UseTokenBalancesOptions {
     availableTokens?: TokenDTO[];
     /** Whether to automatically load balances on mount/auth/token changes */
     autoLoad?: boolean;
-    /** Optional refresh interval in milliseconds (0 = disabled) */
+    /**
+     * Fallback polling interval in milliseconds (0 = disabled)
+     * @deprecated Use wallet events instead (refreshOnWalletEvents). Polling kept as fallback only.
+     * @default 0
+     */
     refreshInterval?: number;
     /**
      * Auto-refresh balances when wallet events are received (Transfer, Approval, etc.)
@@ -120,18 +124,7 @@ export interface UseTokenBalancesResult {
  * ```
  *
  * @example
- * **With Auto-Refresh:**
- * ```typescript
- * const { tokenBalances, isLoading } = useTokenBalances({
- *   accountAddress: walletAddress!,
- *   availableTokens,
- *   autoLoad: true,
- *   refreshInterval: 30000 // Refresh every 30 seconds
- * });
- * ```
- *
- * @example
- * **With Wallet Events (Real-time):**
+ * **With Wallet Events (Real-time):
  * ```typescript
  * // Auto-refresh on Transfer, Approval, and other blockchain events
  * const { tokenBalances } = useTokenBalances({

package/dist/hooks/useTokenBalances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTokenBalances.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokenBalances.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,YAAY,EAAE,YAAY,CAAC;IAC3B,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC;IAChB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,sFAAsF;IACtF,WAAW,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CAgMzF"}
+{"version":3,"file":"useTokenBalances.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokenBalances.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,YAAY,EAAE,YAAY,CAAC;IAC3B,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC;IAChB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,sFAAsF;IACtF,WAAW,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CAqLzF"}

package/dist/hooks/useTokenBalances.js

@@ -61,18 +61,7 @@ import { NativeTokenTypes } from '@explorins/pers-shared';
  * ```
  *
  * @example
- * **With Auto-Refresh:**
- * ```typescript
- * const { tokenBalances, isLoading } = useTokenBalances({
- *   accountAddress: walletAddress!,
- *   availableTokens,
- *   autoLoad: true,
- *   refreshInterval: 30000 // Refresh every 30 seconds
- * });
- * ```
- *
- * @example
- * **With Wallet Events (Real-time):**
+ * **With Wallet Events (Real-time):
  * ```typescript
  * // Auto-refresh on Transfer, Approval, and other blockchain events
  * const { tokenBalances } = useTokenBalances({
@@ -207,28 +196,18 @@ export function useTokenBalances(options) {
             loadBalances();
         }
     }, [autoLoad, isAvailable, availableTokens.length, loadBalances]);
-    // Event-driven refresh: listen for transaction events instead of polling
+    // Deprecated: Fallback polling interval (prefer wallet events)
+    // Kept for backward compatibility and edge cases where events might not work
     useEffect(() => {
-        if (!sdk || refreshInterval <= 0 || !isAvailable)
+        if (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();
-            }
-        }, { 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);
+        }, refreshInterval);
         return () => {
-            unsubscribe();
             clearInterval(intervalId);
         };
-    }, [sdk, refreshInterval, isAvailable, loadBalances]);
+    }, [refreshInterval, isAvailable, loadBalances]);
     // Wallet events refresh: listen for real-time blockchain events
     // Refreshes on ANY wallet domain event (Transfer, TransferSingle, etc.)
     // Debouncing prevents excessive API calls during rapid events

package/dist/index.js

@@ -9602,6 +9602,12 @@ class PersApiClient {
                     try {
                         const refreshSuccessful = await this.refreshManager.attemptInternalRefresh();
                         if (refreshSuccessful) {
+                            // Emit TOKEN_REFRESHED event so WS clients can retry if they gave up
+                            this._events?.emitSuccess({
+                                type: 'token_refreshed',
+                                domain: 'authentication',
+                                userMessage: 'Authentication token refreshed',
+                            });
                             return await this.request(method, endpoint, body, { ...options, retryCount: 1 });
                         }
                     }
@@ -9886,7 +9892,7 @@ class PersEventEmitter {
      * ```typescript
      * sdk.events.emitSuccess({
      *   domain: 'transaction',  // Only business domains allowed
-     *   type: 'CONFIRMED',
+     *   type: 'transaction_confirmed',
      *   userMessage: 'Transaction confirmed!'
      * });
      * ```
@@ -9913,7 +9919,7 @@ class PersEventEmitter {
      * ```typescript
      * sdk.events.emitError({
      *   domain: 'validation',  // Technical domains allowed
-     *   type: 'INVALID_INPUT',
+     *   type: 'validation_failed',
      *   userMessage: 'Please check your input'
      * });
      * ```
@@ -10047,7 +10053,7 @@ class AuthManager {
             : await authService.loginUser(jwtToken);
         this.events?.emitSuccess({
             domain: 'authentication',
-            type: 'LOGIN_SUCCESS',
+            type: 'login_success',
             userMessage: 'Successfully logged in'
         });
         return result;
@@ -10420,7 +10426,7 @@ class UserManager {
         const result = await this.userService.updateRemoteUser(userData);
         this.events?.emitSuccess({
             domain: 'user',
-            type: 'PROFILE_UPDATED',
+            type: 'profile_updated',
             userMessage: 'Profile updated successfully',
             details: { userId: result.id }
         });
@@ -10700,7 +10706,7 @@ class UserManager {
         const result = await this.userService.deleteUser(identifier);
         this.events?.emitSuccess({
             domain: 'user',
-            type: 'USER_DELETED',
+            type: 'user_deleted',
             userMessage: 'User deleted successfully',
             details: { identifier }
         });
@@ -10733,7 +10739,7 @@ class UserManager {
         const result = await this.userService.restoreUser(identifier);
         this.events?.emitSuccess({
             domain: 'user',
-            type: 'USER_RESTORED',
+            type: 'user_restored',
             userMessage: 'User restored successfully',
             details: { identifier, userId: result.id }
         });
@@ -11423,7 +11429,7 @@ class BusinessManager {
         const result = await this.businessService.createBusinessByDisplayName(displayName);
         this.events?.emitSuccess({
             domain: 'business',
-            type: 'BUSINESS_CREATED',
+            type: 'business_created',
             userMessage: 'Business created successfully',
             details: { businessId: result.id, displayName: result.displayName }
         });
@@ -11458,7 +11464,7 @@ class BusinessManager {
         const result = await this.businessService.updateBusiness(businessId, businessData);
         this.events?.emitSuccess({
             domain: 'business',
-            type: 'BUSINESS_UPDATED',
+            type: 'business_updated',
             userMessage: 'Business updated successfully',
             details: { businessId: result.id, displayName: result.displayName }
         });
@@ -11630,7 +11636,7 @@ class BusinessManager {
         const result = await this.membershipService.updateMemberRole(businessId, userId, newRole);
         this.events?.emitSuccess({
             domain: 'business',
-            type: 'MEMBERSHIP_UPDATED',
+            type: 'membership_updated',
             userMessage: 'Membership role updated',
             details: { businessId, userId, role: newRole }
         });
@@ -11908,7 +11914,7 @@ class CampaignManager {
         const result = await this.campaignService.claimCampaign(claimRequest);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CLAIM_SUCCESS',
+            type: 'claim_success',
             userMessage: 'Campaign reward claimed successfully',
             details: { campaignId: claimRequest.campaignId }
         });
@@ -12176,7 +12182,7 @@ class CampaignManager {
         const result = await this.campaignService.createCampaignTrigger(data);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CAMPAIGN_TRIGGER_CREATED',
+            type: 'campaign_trigger_created',
             userMessage: `Trigger "${data.name}" created successfully`,
             details: { triggerId: result.id, name: data.name }
         });
@@ -12201,7 +12207,7 @@ class CampaignManager {
         const result = await this.campaignService.updateCampaignTrigger(triggerId, data);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CAMPAIGN_TRIGGER_UPDATED',
+            type: 'campaign_trigger_updated',
             userMessage: 'Trigger updated successfully',
             details: { triggerId, updates: Object.keys(data) }
         });
@@ -12222,7 +12228,7 @@ class CampaignManager {
         const result = await this.campaignService.deleteCampaignTrigger(triggerId);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CAMPAIGN_TRIGGER_DELETED',
+            type: 'campaign_trigger_deleted',
             userMessage: 'Trigger deleted successfully',
             details: { triggerId }
         });
@@ -12251,7 +12257,7 @@ class CampaignManager {
         const result = await this.campaignService.setCampaignTrigger(campaignId, triggerId);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CAMPAIGN_TRIGGER_ASSIGNED',
+            type: 'campaign_trigger_assigned',
             userMessage: 'Trigger assigned to campaign',
             details: { campaignId, triggerId }
         });
@@ -12280,7 +12286,7 @@ class CampaignManager {
         const result = await this.campaignService.removeCampaignTrigger(campaignId, triggerId);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'CAMPAIGN_TRIGGER_REMOVED',
+            type: 'campaign_trigger_removed',
             userMessage: 'Trigger removed from campaign',
             details: { campaignId, triggerId }
         });
@@ -12616,7 +12622,7 @@ class CampaignManager {
         const result = await this.campaignService.assignTriggerSourceToCampaign(campaignId, triggerSourceId);
         this.events?.emitSuccess({
             domain: 'campaign',
-            type: 'TRIGGER_SOURCE_ASSIGNED',
+            type: 'trigger_source_assigned',
             userMessage: 'Trigger source assigned to campaign',
             details: { campaignId, triggerSourceId }
         });
@@ -12964,7 +12970,7 @@ class RedemptionManager {
         const result = await this.redemptionService.redeemRedemption(redemptionId);
         this.events?.emitSuccess({
             domain: 'redemption',
-            type: 'REDEEM_SUCCESS',
+            type: 'redeem_success',
             userMessage: 'Reward redeemed successfully',
             details: { redemptionId }
         });
@@ -13482,7 +13488,7 @@ class TransactionManager {
         const result = await this.transactionService.createTransaction(transactionData);
         this.events?.emitSuccess({
             domain: 'transaction',
-            type: 'TRANSACTION_CREATED',
+            type: 'transaction_created',
             userMessage: 'Transaction created successfully',
             details: { transactionId: result.transaction?.id }
         });
@@ -13721,7 +13727,7 @@ class TransactionManager {
         const result = await this.transactionService.submitSignedTransaction(signedTxData);
         this.events?.emitSuccess({
             domain: 'transaction',
-            type: 'TRANSACTION_SUBMITTED',
+            type: 'transaction_submitted',
             userMessage: 'Transaction submitted successfully',
             details: { transactionId: result.transaction?.id }
         });
@@ -15645,7 +15651,7 @@ class TriggerSourceManager {
         const result = await this.triggerSourceService.createTriggerSource(triggerSource);
         this.events?.emitSuccess({
             domain: 'trigger-source',
-            type: 'TRIGGER_SOURCE_CREATED',
+            type: 'trigger_source_created',
             userMessage: 'Trigger source created successfully',
             details: { triggerSourceId: result.id, type: result.type }
         });
@@ -15677,7 +15683,7 @@ class TriggerSourceManager {
         const result = await this.triggerSourceService.updateTriggerSource(triggerSourceId, triggerSource);
         this.events?.emitSuccess({
             domain: 'trigger-source',
-            type: 'TRIGGER_SOURCE_UPDATED',
+            type: 'trigger_source_updated',
             userMessage: 'Trigger source updated successfully',
             details: { triggerSourceId }
         });
@@ -15704,7 +15710,7 @@ class TriggerSourceManager {
         const result = await this.triggerSourceService.deleteTriggerSource(triggerSourceId);
         this.events?.emitSuccess({
             domain: 'trigger-source',
-            type: 'TRIGGER_SOURCE_DELETED',
+            type: 'trigger_source_deleted',
             userMessage: 'Trigger source deleted successfully',
             details: { triggerSourceId }
         });
@@ -16178,7 +16184,7 @@ class WebhookManager {
         const result = await this.webhookService.createWebhook(webhook);
         this.events?.emitSuccess({
             domain: 'webhook',
-            type: 'WEBHOOK_CREATED',
+            type: 'webhook_created',
             userMessage: 'Webhook created successfully',
             details: { webhookId: result.id, name: result.name }
         });
@@ -16195,7 +16201,7 @@ class WebhookManager {
         const result = await this.webhookService.updateWebhook(webhookId, webhook);
         this.events?.emitSuccess({
             domain: 'webhook',
-            type: 'WEBHOOK_UPDATED',
+            type: 'webhook_updated',
             userMessage: 'Webhook updated successfully',
             details: { webhookId }
         });
@@ -16223,7 +16229,7 @@ class WebhookManager {
         const result = await this.webhookService.deleteWebhook(webhookId);
         this.events?.emitSuccess({
             domain: 'webhook',
-            type: 'WEBHOOK_DELETED',
+            type: 'webhook_deleted',
             userMessage: 'Webhook deleted successfully',
             details: { webhookId }
         });
@@ -16280,7 +16286,7 @@ class WebhookManager {
         const result = await this.webhookService.post(hookId, body);
         this.events?.emitSuccess({
             domain: 'webhook',
-            type: 'WEBHOOK_TRIGGERED',
+            type: 'webhook_triggered',
             userMessage: 'Webhook triggered',
             details: { hookId, executionId: result.executionId }
         });
@@ -16844,12 +16850,22 @@ class WalletEventsManager {
         this.client = null;
         this.pendingHandlers = [];
         this.unsubscribes = [];
+        // Track if WS gave up reconnecting (so we can retry on token refresh)
+        this.reconnectGaveUp = false;
+        this.lastSubscriptions = { wallets: [], chains: [] };
         this.config = {
             autoReconnect: true,
             connectionTimeout: 30000,
             debug: false,
             ...config,
         };
+        // Subscribe to auth events to retry WS connection when tokens are refreshed
+        this.authEventUnsubscribe = this.eventEmitter.subscribe((event) => {
+            if (event.type === 'token_refreshed' && this.reconnectGaveUp) {
+                // Tokens were refreshed and WS had given up - retry connection
+                this.retryAfterTokenRefresh();
+            }
+        }, { domains: ['authentication'], levels: ['success'] });
     }
     /**
      * Connect to real-time wallet events
@@ -16878,8 +16894,11 @@ class WalletEventsManager {
         const wsUrl = this.config.wsUrl
             || sdkConfig.walletEventsWsUrl
             || buildWalletEventsWsUrl(sdkConfig.environment);
-        // Create token refresher that fetches fresh token from auth provider
+        // Create token refresher that ensures valid token before reconnecting
+        // This triggers actual token refresh if expired, not just retrieval
         const tokenRefresher = async () => {
+            // Ensure token is refreshed if expired (calls refresh API if needed)
+            await this.apiClient.ensureValidToken();
             const freshToken = await authProvider.getToken();
             if (!freshToken) {
                 throw new Error('Failed to refresh token');
@@ -16894,6 +16913,32 @@ class WalletEventsManager {
             tokenRefresher,
         });
         await this.client.connect(token);
+        // Reset gave-up flag on successful connection
+        this.reconnectGaveUp = false;
+        // Track previous state to detect reconnections and give-ups
+        let previousState = 'connected';
+        // Clean up previous state change listener (prevent duplicate listeners)
+        this.stateChangeUnsubscribe?.();
+        // Listen for state changes
+        this.stateChangeUnsubscribe = this.client.onStateChange((state) => {
+            if (state === 'disconnected' && previousState === 'reconnecting') {
+                // Transitioned from reconnecting to disconnected = exhausted all attempts
+                this.reconnectGaveUp = true;
+            }
+            else if (state === 'connected') {
+                this.reconnectGaveUp = false;
+                // Emit reconnected event so apps can refresh state (catch missed events)
+                if (previousState === 'reconnecting') {
+                    this.eventEmitter.emitSuccess({
+                        type: 'wallet_reconnected',
+                        domain: 'wallet',
+                        userMessage: 'Wallet events reconnected',
+                        details: { previousState }
+                    });
+                }
+            }
+            previousState = state;
+        });
         // Clear previous unsubscribes on new connection (prevent memory leak)
         this.unsubscribes.forEach(unsub => unsub());
         this.unsubscribes = [];
@@ -16910,11 +16955,26 @@ class WalletEventsManager {
      * Disconnect from real-time events
      */
     disconnect() {
+        // Clear gave-up flag to prevent auto-reconnect after intentional disconnect
+        this.reconnectGaveUp = false;
+        this.stateChangeUnsubscribe?.();
+        this.stateChangeUnsubscribe = undefined;
         this.unsubscribes.forEach(unsub => unsub());
         this.unsubscribes = [];
         this.client?.disconnect();
         this.client = null;
     }
+    /**
+     * Full cleanup - disconnect and remove all subscriptions including auth listener
+     * Call this when completely done with the manager (e.g., SDK disposal)
+     */
+    destroy() {
+        this.disconnect();
+        this.authEventUnsubscribe?.();
+        this.authEventUnsubscribe = undefined;
+        this.reconnectGaveUp = false;
+        this.lastSubscriptions = { wallets: [], chains: [] };
+    }
     // ─────────────────────────────────────────────────────────────────────────────
     // Subscription Methods (v1.2.0)
     // ─────────────────────────────────────────────────────────────────────────────
@@ -16939,6 +16999,8 @@ class WalletEventsManager {
         if (!this.client) {
             throw new Error('Not connected. Call connect() first.');
         }
+        // Save subscriptions for auto-resubscribe on reconnect
+        this.lastSubscriptions.wallets = wallets;
         return this.client.subscribeWallets(wallets);
     }
     /**
@@ -16960,6 +17022,8 @@ class WalletEventsManager {
         if (!this.client) {
             throw new Error('Not connected. Call connect() first.');
         }
+        // Save subscriptions for auto-resubscribe on reconnect
+        this.lastSubscriptions.chains = chains;
         return this.client.subscribeChains(chains);
     }
     /**
@@ -17049,6 +17113,36 @@ class WalletEventsManager {
     isConnected() {
         return this.getState() === 'connected';
     }
+    /**
+     * Check if WS reconnection gave up (exhausted all attempts)
+     * Used to determine if we should retry on token refresh
+     */
+    hasReconnectGivenUp() {
+        return this.reconnectGaveUp;
+    }
+    /**
+     * Retry connection after token refresh
+     * Called when auth tokens are refreshed and WS had previously given up
+     * Automatically resubscribes to previous subscriptions
+     */
+    async retryAfterTokenRefresh() {
+        if (!this.reconnectGaveUp) {
+            return; // Not in gave-up state, nothing to retry
+        }
+        try {
+            await this.connect();
+            // Restore previous subscriptions
+            if (this.lastSubscriptions.wallets.length > 0) {
+                await this.subscribeWallets(this.lastSubscriptions.wallets);
+            }
+            if (this.lastSubscriptions.chains.length > 0) {
+                await this.subscribeChains(this.lastSubscriptions.chains);
+            }
+        }
+        catch (error) {
+            console.warn('[WalletEventsManager] Retry after token refresh failed:', error);
+        }
+    }
     /**
      * Get connection info (wallets, active chains)
      */
@@ -17253,7 +17347,7 @@ class PersSDK {
         }
         // Listen for login success events (both fresh login and session restoration)
         this._events.subscribe((event) => {
-            if (event.level === 'success' && (event.type === 'LOGIN_SUCCESS' || event.type === 'session_restored')) {
+            if (event.level === 'success' && (event.type === 'login_success' || event.type === 'session_restored')) {
                 // Auto-connect and subscribe to wallet events (fire and forget, log errors)
                 this.connectWalletEvents().catch((err) => {
                     console.warn('[PersSDK] Failed to auto-connect wallet events:', err.message);
@@ -39975,18 +40069,7 @@ const useWeb3 = () => {
  * ```
  *
  * @example
- * **With Auto-Refresh:**
- * ```typescript
- * const { tokenBalances, isLoading } = useTokenBalances({
- *   accountAddress: walletAddress!,
- *   availableTokens,
- *   autoLoad: true,
- *   refreshInterval: 30000 // Refresh every 30 seconds
- * });
- * ```
- *
- * @example
- * **With Wallet Events (Real-time):**
+ * **With Wallet Events (Real-time):
  * ```typescript
  * // Auto-refresh on Transfer, Approval, and other blockchain events
  * const { tokenBalances } = useTokenBalances({
@@ -40121,28 +40204,18 @@ function useTokenBalances(options) {
             loadBalances();
         }
     }, [autoLoad, isAvailable, availableTokens.length, loadBalances]);
-    // Event-driven refresh: listen for transaction events instead of polling
+    // Deprecated: Fallback polling interval (prefer wallet events)
+    // Kept for backward compatibility and edge cases where events might not work
     react.useEffect(() => {
-        if (!sdk || refreshInterval <= 0 || !isAvailable)
+        if (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();
-            }
-        }, { 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);
+        }, refreshInterval);
         return () => {
-            unsubscribe();
             clearInterval(intervalId);
         };
-    }, [sdk, refreshInterval, isAvailable, loadBalances]);
+    }, [refreshInterval, isAvailable, loadBalances]);
     // Wallet events refresh: listen for real-time blockchain events
     // Refreshes on ANY wallet domain event (Transfer, TransferSingle, etc.)
     // Debouncing prevents excessive API calls during rapid events