fix(predict): race condition

Author: matallui

app/components/UI/Predict/hooks/usePredictEligibility.test.ts

@@ -463,4 +463,144 @@ describe('usePredictEligibility', () => {
       expect(mockRefreshEligibility).toHaveBeenCalledTimes(2);
     });
   });
+
+  describe('race condition prevention', () => {
+    it('reuses in-flight promise when refresh is already in progress', async () => {
+      let resolveRefresh: (() => void) | undefined;
+      const refreshPromise = new Promise<void>((resolve) => {
+        resolveRefresh = resolve;
+      });
+      mockRefreshEligibility.mockReturnValueOnce(refreshPromise);
+
+      renderHook(() => usePredictEligibility({ providerId: 'polymarket' }));
+
+      const handleAppStateChange = mockAppStateAddEventListener.mock
+        .calls[0][1] as (nextState: AppStateStatus) => void;
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(1);
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(1);
+      expect(mockDevLogger).toHaveBeenCalledWith(
+        'PredictController: Refresh already in progress, reusing promise',
+        expect.objectContaining({
+          providerId: 'polymarket',
+        }),
+      );
+
+      resolveRefresh?.();
+    });
+
+    it('prevents concurrent API calls when multiple state changes occur rapidly', async () => {
+      let resolveRefresh: (() => void) | undefined;
+      const refreshPromise = new Promise<void>((resolve) => {
+        resolveRefresh = resolve;
+      });
+      mockRefreshEligibility.mockReturnValueOnce(refreshPromise);
+
+      renderHook(() => usePredictEligibility({ providerId: 'polymarket' }));
+
+      const handleAppStateChange = mockAppStateAddEventListener.mock
+        .calls[0][1] as (nextState: AppStateStatus) => void;
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(1);
+
+      resolveRefresh?.();
+      await act(async () => {
+        await refreshPromise;
+      });
+    });
+
+    it('allows new refresh after previous one completes', async () => {
+      let resolveFirstRefresh: (() => void) | undefined;
+      const firstRefreshPromise = new Promise<void>((resolve) => {
+        resolveFirstRefresh = resolve;
+      });
+      mockRefreshEligibility.mockReturnValueOnce(firstRefreshPromise);
+
+      renderHook(() => usePredictEligibility({ providerId: 'polymarket' }));
+
+      const handleAppStateChange = mockAppStateAddEventListener.mock
+        .calls[0][1] as (nextState: AppStateStatus) => void;
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(1);
+
+      resolveFirstRefresh?.();
+      await act(async () => {
+        await firstRefreshPromise;
+      });
+
+      mockRefreshEligibility.mockResolvedValueOnce(undefined);
+      jest.advanceTimersByTime(60000);
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(2);
+    });
+
+    it('clears in-flight promise after error', async () => {
+      let rejectRefresh: ((error: Error) => void) | undefined;
+      const refreshPromise = new Promise<void>((_resolve, reject) => {
+        rejectRefresh = reject;
+      });
+      mockRefreshEligibility.mockReturnValueOnce(refreshPromise);
+
+      renderHook(() => usePredictEligibility({ providerId: 'polymarket' }));
+
+      const handleAppStateChange = mockAppStateAddEventListener.mock
+        .calls[0][1] as (nextState: AppStateStatus) => void;
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(1);
+
+      rejectRefresh?.(new Error('Network error'));
+      await act(async () => {
+        try {
+          await refreshPromise;
+        } catch {
+          // Expected error
+        }
+      });
+
+      mockRefreshEligibility.mockResolvedValueOnce(undefined);
+      jest.advanceTimersByTime(60000);
+
+      await act(async () => {
+        handleAppStateChange('background');
+        handleAppStateChange('active');
+      });
+
+      expect(mockRefreshEligibility).toHaveBeenCalledTimes(2);
+    });
+  });
 });

app/components/UI/Predict/hooks/usePredictEligibility.ts

@@ -29,6 +29,7 @@ export const usePredictEligibility = ({
 }) => {
   const eligibility = useSelector(selectPredictEligibility);
   const lastRefreshTimeRef = useRef<number>(0);
+  const refreshPromiseRef = useRef<Promise<void> | null>(null);
 
   // Manual refresh - bypasses debounce and updates timestamp
   const refreshEligibility = useCallback(async () => {
@@ -38,7 +39,19 @@ export const usePredictEligibility = ({
   }, []);
 
   // Auto-refresh with debouncing - used by AppState listener
+  // Prevents race conditions by reusing in-flight promises
   const autoRefreshEligibility = useCallback(async () => {
+    // If a refresh is already in progress, reuse that promise
+    if (refreshPromiseRef.current) {
+      DevLogger.log(
+        'PredictController: Refresh already in progress, reusing promise',
+        {
+          providerId,
+        },
+      );
+      return refreshPromiseRef.current;
+    }
+
     const now = Date.now();
     const timeSinceLastRefresh = now - lastRefreshTimeRef.current;
 
@@ -56,12 +69,15 @@ export const usePredictEligibility = ({
       DevLogger.log('PredictController: Auto-refreshing eligibility', {
         providerId,
       });
-      await refreshEligibility();
+      refreshPromiseRef.current = refreshEligibility();
+      await refreshPromiseRef.current;
     } catch (error) {
       DevLogger.log('PredictController: Auto-refresh failed', {
         providerId,
         error: error instanceof Error ? error.message : 'Unknown',
       });
+    } finally {
+      refreshPromiseRef.current = null;
     }
   }, [providerId, refreshEligibility]);