test(perps): add PerpsAlwaysOnProvider tests and fix Wallet visibility tests

- Add PerpsAlwaysOnProvider.test.tsx covering connect/disconnect lifecycle,
  AppState foreground/background handling, timer cancellation, and unmount cleanup
- Update Wallet/index.test.tsx to reflect removal of isVisible/onVisibilityChange
  props from PerpsTabView (lifecycle now owned by PerpsAlwaysOnProvider)

New code coverage: 81% on changed lines

Author: abretonc7s

app/components/UI/Perps/providers/PerpsAlwaysOnProvider.test.tsx

@@ -0,0 +1,233 @@
+import React from 'react';
+import { render, act } from '@testing-library/react-native';
+import { Text, AppState } from 'react-native';
+import { useSelector } from 'react-redux';
+import { PerpsAlwaysOnProvider } from './PerpsAlwaysOnProvider';
+import { PerpsConnectionManager } from '../services/PerpsConnectionManager';
+
+jest.mock('react-redux', () => ({
+  useSelector: jest.fn(),
+}));
+
+jest.mock('../services/PerpsConnectionManager');
+
+// Prevent PerpsStreamManager singleton from instantiating PERFORMANCE_CONFIG
+jest.mock('../providers/PerpsStreamManager', () => ({
+  PerpsStreamProvider: ({ children }: { children: React.ReactNode }) =>
+    children,
+}));
+
+jest.mock('@metamask/perps-controller', () => ({
+  PERPS_CONSTANTS: {
+    FeatureName: 'perps',
+    ReconnectionDelayAndroidMs: 500,
+  },
+}));
+
+jest.mock('../../../../util/Logger', () => ({
+  error: jest.fn(),
+}));
+
+jest.mock('../../../../util/errorUtils', () => ({
+  ensureError: jest.fn((err) =>
+    err instanceof Error ? err : new Error(String(err)),
+  ),
+}));
+
+jest.mock('../index', () => ({
+  selectPerpsEnabledFlag: jest.fn(),
+}));
+
+const mockUseSelector = useSelector as jest.MockedFunction<typeof useSelector>;
+const mockConnect = PerpsConnectionManager.connect as jest.Mock;
+const mockDisconnect = PerpsConnectionManager.disconnect as jest.Mock;
+
+describe('PerpsAlwaysOnProvider', () => {
+  let mockAppStateListener: ((state: string) => void) | null = null;
+  let mockSubscriptionRemove: jest.Mock;
+  let addEventListenerSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+
+    mockConnect.mockResolvedValue(undefined);
+    mockDisconnect.mockResolvedValue(undefined);
+
+    mockSubscriptionRemove = jest.fn();
+    addEventListenerSpy = jest
+      .spyOn(AppState, 'addEventListener')
+      .mockImplementation((event, handler) => {
+        if (event === 'change') {
+          mockAppStateListener = handler as (state: string) => void;
+        }
+        return { remove: mockSubscriptionRemove };
+      });
+
+    // Default: perps enabled
+    mockUseSelector.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    act(() => {
+      jest.runOnlyPendingTimers();
+    });
+    jest.useRealTimers();
+    addEventListenerSpy.mockRestore();
+    mockAppStateListener = null;
+  });
+
+  it('renders children', () => {
+    const { getByText } = render(
+      <PerpsAlwaysOnProvider>
+        <Text>child content</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+    expect(getByText('child content')).toBeTruthy();
+  });
+
+  it('calls connect on mount when perps is enabled', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+    expect(mockConnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call connect on mount when perps is disabled', () => {
+    mockUseSelector.mockReturnValue(false);
+
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    expect(mockConnect).not.toHaveBeenCalled();
+  });
+
+  it('registers AppState listener when perps is enabled', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+    expect(addEventListenerSpy).toHaveBeenCalledWith(
+      'change',
+      expect.any(Function),
+    );
+  });
+
+  it('does not register AppState listener when perps is disabled', () => {
+    mockUseSelector.mockReturnValue(false);
+
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    expect(addEventListenerSpy).not.toHaveBeenCalled();
+  });
+
+  it('calls disconnect when app goes to background', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    act(() => {
+      mockAppStateListener?.('background');
+    });
+
+    expect(mockDisconnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls disconnect when app goes inactive', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    act(() => {
+      mockAppStateListener?.('inactive');
+    });
+
+    expect(mockDisconnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls connect after delay when app returns to foreground', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    // Clear the initial mount connect call
+    mockConnect.mockClear();
+
+    act(() => {
+      mockAppStateListener?.('background');
+    });
+    act(() => {
+      mockAppStateListener?.('active');
+    });
+
+    // Should not reconnect immediately — uses a timer delay
+    expect(mockConnect).not.toHaveBeenCalled();
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    expect(mockConnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('cancels pending reconnect timer if app goes background before timer fires', () => {
+    render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    mockConnect.mockClear();
+
+    // Goes active — schedules reconnect timer
+    act(() => {
+      mockAppStateListener?.('active');
+    });
+
+    // Goes background before timer fires — cancels the pending reconnect
+    act(() => {
+      mockAppStateListener?.('background');
+    });
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    // connect should NOT have been called (timer was cancelled)
+    expect(mockConnect).not.toHaveBeenCalled();
+    expect(mockDisconnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls disconnect and removes AppState subscription on unmount', () => {
+    const { unmount } = render(
+      <PerpsAlwaysOnProvider>
+        <Text>child</Text>
+      </PerpsAlwaysOnProvider>,
+    );
+
+    mockDisconnect.mockClear();
+
+    act(() => {
+      unmount();
+    });
+
+    expect(mockDisconnect).toHaveBeenCalledTimes(1);
+    expect(mockSubscriptionRemove).toHaveBeenCalledTimes(1);
+  });
+});

app/components/Views/Wallet/index.test.tsx

@@ -1083,7 +1083,7 @@ describe('Wallet', () => {
       mockPredictGTMModalEnabled = false; // Reset to default
     });
 
-    it('should register visibility callback when Perps is enabled', () => {
+    it('should render PerpsTabView without visibility props when Perps is enabled', () => {
       const state = {
         ...mockInitialState,
         engine: {
@@ -1109,20 +1109,17 @@ describe('Wallet', () => {
         { state },
       );
 
-      // Debug: Check if TabsList was rendered
       expect(mockTabsListComponent).toHaveBeenCalled();
-
-      // Check that PerpsTabView was rendered
       expect(mockPerpsTabView).toHaveBeenCalled();
 
-      // Check the props it was called with
+      // With PerpsAlwaysOnProvider managing lifecycle, PerpsTabView no longer
+      // receives visibility props — lifecycle is centralized at the wallet root.
       const perpsTabViewProps = mockPerpsTabView.mock.calls[0][0];
-      expect(perpsTabViewProps.onVisibilityChange).toBeDefined();
-      expect(typeof perpsTabViewProps.onVisibilityChange).toBe('function');
-      expect(perpsTabViewProps.isVisible).toBe(false); // Initially not visible (tab 0 is selected)
+      expect(perpsTabViewProps.onVisibilityChange).toBeUndefined();
+      expect(perpsTabViewProps.isVisible).toBeUndefined();
     });
 
-    it('should calculate correct perpsTabIndex when Perps is enabled', () => {
+    it('should render PerpsTabView with only tab-related props when Perps is enabled', () => {
       const state = {
         ...mockInitialState,
         engine: {
@@ -1148,9 +1145,10 @@ describe('Wallet', () => {
         { state },
       );
 
-      // Perps should be at index 1 when enabled (after Tokens at index 0)
+      expect(mockPerpsTabView).toHaveBeenCalled();
+      // tabLabel and key are the only props passed — no isVisible or onVisibilityChange
       const perpsTabViewProps = mockPerpsTabView.mock.calls[0][0];
-      expect(perpsTabViewProps.isVisible).toBe(false); // Initially not visible (tab 0 is selected)
+      expect(perpsTabViewProps.tabLabel).toBeDefined();
     });
 
     it('should not render PerpsTabView when Perps is disabled', () => {