MetaMask
diff --git a/‎app/components/Views/Wallet/index.test.tsx‎
Lines changed: 120 additions & 3 deletions b/‎app/components/Views/Wallet/index.test.tsx‎
Lines changed: 120 additions & 3 deletions
diff --git a/‎app/components/Views/Wallet/index.tsx‎
Lines changed: 87 additions & 48 deletions b/‎app/components/Views/Wallet/index.tsx‎
Lines changed: 87 additions & 48 deletions
diff --git a/‎app/core/DeeplinkManager/handlers/legacy/__tests__/handleHomeUrl.test.ts‎
Lines changed: 19 additions & 4 deletions b/‎app/core/DeeplinkManager/handlers/legacy/__tests__/handleHomeUrl.test.ts‎
Lines changed: 19 additions & 4 deletions
@@ -91,11 +91,11 @@ jest.mock('../../../component-library/components-temp/Tabs', () => {
   };
 });
 
-import Wallet from './';
+import Wallet, { useHomeDeepLinkEffects } from './';
 import renderWithProvider, {
   renderScreen,
 } from '../../../util/test/renderWithProvider';
-import { screen as RNScreen } from '@testing-library/react-native';
+import { screen as RNScreen, renderHook } from '@testing-library/react-native';
 import Routes from '../../../constants/navigation/Routes';
 import { backgroundState } from '../../../util/test/initial-root-state';
 import { MOCK_ACCOUNTS_CONTROLLER_STATE } from '../../../util/test/accountsControllerTestUtils';
@@ -104,11 +104,17 @@ import Engine from '../../../core/Engine';
 import { useSelector } from 'react-redux';
 import { mockedPerpsFeatureFlagsEnabledState } from '../../UI/Perps/mocks/remoteFeatureFlagMocks';
 import { initialState as cardInitialState } from '../../../core/redux/slices/card';
-import { NavigationProp, ParamListBase } from '@react-navigation/native';
+import {
+  NavigationProp,
+  ParamListBase,
+  useFocusEffect,
+  useRoute,
+} from '@react-navigation/native';
 import {
   IconColor,
   IconName,
 } from '../../../component-library/components/Icons/Icon';
+import { PERFORMANCE_CONFIG } from '../../UI/Perps/constants/perpsConfig';
 
 const MOCK_ADDRESS = '0xc4955c0d639d99699bfd7ec54d9fafee40e4d272';
 
@@ -1679,3 +1685,114 @@ describe('Wallet', () => {
     });
   });
 });
+
+describe('useHomeDeepLinkEffects', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  const arrangeMocks = () => {
+    const mockSetParams = jest.fn();
+    const mockOnPerpsTabsSelected = jest.fn();
+    const mockOnNetworkSelectorSelected = jest.fn();
+    const mockUseRoute = jest
+      .mocked(useRoute)
+      .mockReturnValue({ key: 'route', name: 'route', params: {} });
+    return {
+      mockNavigate,
+      mockSetParams,
+      navigation: {
+        setParams: mockSetParams,
+      } as unknown as NavigationProp<ParamListBase>,
+      mockUseRoute,
+      mockOnPerpsTabsSelected,
+      mockOnNetworkSelectorSelected,
+    };
+  };
+
+  interface DeepLinkTestCase {
+    testName: string;
+    params: Record<string, unknown>;
+    isPerpsEnabled: boolean;
+    assertCase: (mocks: ReturnType<typeof arrangeMocks>) => void;
+  }
+
+  const testCases: DeepLinkTestCase[] = [
+    {
+      testName: 'navigates to perps tab when shouldSelectPerpsTab is true',
+      params: { shouldSelectPerpsTab: true },
+      isPerpsEnabled: true,
+      assertCase: (mocks) => {
+        expect(mocks.mockOnPerpsTabsSelected).toHaveBeenCalled();
+        expect(mocks.mockSetParams).toHaveBeenCalledWith({
+          shouldSelectPerpsTab: null,
+        });
+      },
+    },
+    {
+      testName: 'navigates to perps tab when initialTab is perps',
+      params: { initialTab: 'perps' },
+      isPerpsEnabled: true,
+      assertCase: (mocks) => {
+        expect(mocks.mockOnPerpsTabsSelected).toHaveBeenCalled();
+        expect(mocks.mockSetParams).toHaveBeenCalledWith({ initialTab: null });
+      },
+    },
+    {
+      testName:
+        'navigates to network selector when openNetworkSelector is true',
+      params: { openNetworkSelector: true },
+      isPerpsEnabled: false,
+      assertCase: (mocks) => {
+        expect(mocks.mockOnNetworkSelectorSelected).toHaveBeenCalled();
+        expect(mocks.mockSetParams).toHaveBeenCalledWith({
+          openNetworkSelector: null,
+        });
+      },
+    },
+    {
+      testName:
+        'performs no deeplink action when no deeplink params are provided',
+      params: {}, // no deeplink params
+      isPerpsEnabled: true,
+      assertCase: (mocks) => {
+        expect(mocks.mockOnPerpsTabsSelected).not.toHaveBeenCalled();
+        expect(mocks.mockOnNetworkSelectorSelected).not.toHaveBeenCalled();
+        expect(mocks.mockSetParams).not.toHaveBeenCalled();
+      },
+    },
+  ];
+
+  it.each(testCases)('$testName', ({ params, isPerpsEnabled, assertCase }) => {
+    const mocks = arrangeMocks();
+
+    // Setup the mocked useRoute to return the provided params.
+    mocks.mockUseRoute.mockReturnValue({
+      key: 'route',
+      name: 'route',
+      params,
+    });
+    const mockUseFocusEffect = jest.mocked(useFocusEffect);
+
+    renderHook(() =>
+      useHomeDeepLinkEffects({
+        isPerpsEnabled,
+        onPerpsTabSelected: mocks.mockOnPerpsTabsSelected,
+        onNetworkSelectorSelected: mocks.mockOnNetworkSelectorSelected,
+        navigation: mocks.navigation,
+      }),
+    );
+
+    const focusCallback = mockUseFocusEffect.mock.calls[0][0];
+    focusCallback();
+
+    jest.advanceTimersByTime(PERFORMANCE_CONFIG.NavigationParamsDelayMs);
+    assertCase(mocks);
+  });
+});
@@ -231,12 +231,80 @@ interface WalletTokensTabViewProps {
   }) => void;
   defiEnabled: boolean;
   collectiblesEnabled: boolean;
-  navigationParams?: {
-    shouldSelectPerpsTab?: boolean;
-    initialTab?: string;
-  };
 }
 
+interface WalletRouteParams {
+  openNetworkSelector?: boolean | null;
+  shouldSelectPerpsTab?: boolean | null;
+  initialTab?: string | null;
+}
+
+export const useHomeDeepLinkEffects = (opts: {
+  isPerpsEnabled: boolean;
+  onPerpsTabSelected: () => void;
+  onNetworkSelectorSelected: () => void;
+  navigation: NavigationProp<ParamListBase>;
+}) => {
+  const {
+    isPerpsEnabled,
+    onPerpsTabSelected,
+    onNetworkSelectorSelected,
+    navigation,
+  } = opts;
+
+  const route = useRoute<RouteProp<{ params: WalletRouteParams }, 'params'>>();
+
+  // Handle tab selection from navigation params (e.g., from deeplinks)
+  // This uses useFocusEffect to ensure the tab selection happens when the screen receives focus
+  useFocusEffect(
+    useCallback(() => {
+      const params = route.params;
+
+      const clearParams = () => {
+        if (navigation?.setParams) {
+          // React-Navigation shallow merges params, so we need to set each param to null to clear them
+          const nullParams: Record<string, null> = {};
+          Object.keys(params).forEach((key) => {
+            nullParams[key] = null;
+          });
+          navigation.setParams(nullParams);
+        }
+      };
+
+      const handleDelayedDeeplinkAction = (action: () => void) => {
+        const timer = setTimeout(() => {
+          // Call action
+          action();
+
+          // Clear all deeplink params
+          clearParams();
+          return;
+        }, PERFORMANCE_CONFIG.NavigationParamsDelayMs);
+
+        return () => clearTimeout(timer);
+      };
+
+      // Perps Tab Selection Deeplink
+      const shouldSelectPerpsTab = params?.shouldSelectPerpsTab;
+      const initialTab = params?.initialTab;
+      if ((shouldSelectPerpsTab || initialTab === 'perps') && isPerpsEnabled) {
+        return handleDelayedDeeplinkAction(() => onPerpsTabSelected());
+      }
+
+      // Network Picker Deeplink
+      if (params?.openNetworkSelector) {
+        return handleDelayedDeeplinkAction(() => onNetworkSelectorSelected());
+      }
+    }, [
+      route.params,
+      isPerpsEnabled,
+      navigation,
+      onPerpsTabSelected,
+      onNetworkSelectorSelected,
+    ]),
+  );
+};
+
 const WalletTokensTabView = forwardRef<
   WalletTokensTabViewHandle,
   WalletTokensTabViewProps
@@ -261,14 +329,8 @@ const WalletTokensTabView = forwardRef<
     [isPredictFlagEnabled],
   );
 
-  const {
-    navigation,
-    onChangeTab,
-    defiEnabled,
-    collectiblesEnabled,
-    navigationParams,
-  } = props;
-  const route = useRoute<RouteProp<ParamListBase, string>>();
+  const { navigation, onChangeTab, defiEnabled, collectiblesEnabled } = props;
+
   const tabsListRef = useRef<TabsListRef>(null);
   const { enabledNetworks: allEnabledNetworks } = useCurrentNetworkInfo();
 
@@ -420,40 +482,19 @@ const WalletTokensTabView = forwardRef<
     }
   }, [currentTabIndex, perpsTabIndex, isPerpsTabVisible, isPerpsEnabled]);
 
-  // Handle tab selection from navigation params (e.g., from deeplinks)
-  // This uses useFocusEffect to ensure the tab selection happens when the screen receives focus
-  useFocusEffect(
-    useCallback(() => {
-      // Check both navigationParams prop and route params for tab selection
-      // Type assertion needed as route params are not strongly typed in navigation
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const params = navigationParams || (route.params as any);
-      const shouldSelectPerpsTab = params?.shouldSelectPerpsTab;
-      const initialTab = params?.initialTab;
-
-      if ((shouldSelectPerpsTab || initialTab === 'perps') && isPerpsEnabled) {
-        // Calculate the index of the Perps tab
-        // Tokens is always at index 0, Perps is at index 1 when enabled
-        const targetPerpsTabIndex = 1;
-
-        // Small delay ensures the TabsList is fully rendered before selection
-        const timer = setTimeout(() => {
-          tabsListRef.current?.goToTabIndex(targetPerpsTabIndex);
-
-          // Clear the params to prevent re-selection on subsequent focuses
-          // This is important for navigation state management
-          if (navigation?.setParams) {
-            navigation.setParams({
-              shouldSelectPerpsTab: false,
-              initialTab: undefined,
-            });
-          }
-        }, PERFORMANCE_CONFIG.NavigationParamsDelayMs);
-
-        return () => clearTimeout(timer);
-      }
-    }, [route.params, isPerpsEnabled, navigationParams, navigation]),
-  );
+  // Handle deep link effects
+  useHomeDeepLinkEffects({
+    navigation,
+    isPerpsEnabled,
+    onPerpsTabSelected: () => {
+      tabsListRef.current?.goToTabIndex(1);
+    },
+    onNetworkSelectorSelected: () => {
+      navigation.navigate(Routes.MODAL.ROOT_MODAL_FLOW, {
+        screen: Routes.SHEET.NETWORK_SELECTOR,
+      });
+    },
+  });
 
   // Build tabs array dynamically based on enabled features
   const tabsToRender = useMemo(() => {
@@ -568,7 +609,6 @@ const Wallet = ({
   storePrivacyPolicyClickedOrClosed,
 }: WalletProps) => {
   const { navigate } = useNavigation();
-  const route = useRoute<RouteProp<ParamListBase, string>>();
   const walletRef = useRef(null);
   const walletTokensTabViewRef = useRef<WalletTokensTabViewHandle>(null);
   const scrollViewRef = useRef<ScrollView>(null);
@@ -1399,7 +1439,6 @@ const Wallet = ({
           onChangeTab={onChangeTab}
           defiEnabled={defiEnabled}
           collectiblesEnabled={collectiblesEnabled}
-          navigationParams={route.params}
         />
       </>
     </>
 
@@ -2,24 +2,36 @@ import NavigationService from '../../../../NavigationService';
 import { setContentPreviewToken } from '../../../../../actions/notification/helpers';
 import { navigateToHomeUrl } from '../handleHomeUrl';
 import Routes from '../../../../../constants/navigation/Routes';
+import { PERFORMANCE_CONFIG } from '../../../../../components/UI/Perps/constants/perpsConfig';
 
 jest.mock('../../../../NavigationService');
 jest.mock('../../../../../actions/notification/helpers');
 
 describe('navigateToHomeUrl', () => {
-  beforeEach(() => jest.clearAllMocks());
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
 
   const arrangeMocks = () => {
     const mockNavigate = jest.fn();
+    const mockSetParams = jest.fn();
     NavigationService.navigation = {
       navigate: mockNavigate,
+      setParams: mockSetParams,
     } as unknown as typeof NavigationService.navigation;
 
     const mockSetContentPreviewToken = jest.mocked(setContentPreviewToken);
 
     return {
       mockNavigate,
       mockSetContentPreviewToken,
+      mockSetParams,
     };
   };
 
@@ -39,11 +51,14 @@ describe('navigateToHomeUrl', () => {
     expect(mocks.mockNavigate).toHaveBeenCalledWith(Routes.WALLET.HOME);
   });
 
-  it('falls back to navigated to home sceen when no homePath', () => {
+  it('navigates to home screen with openNetworkSelector param when requested', () => {
     const mocks = arrangeMocks();
-    navigateToHomeUrl({ homePath: undefined });
+    navigateToHomeUrl({ homePath: 'home?openNetworkSelector=true' });
 
-    expect(mocks.mockSetContentPreviewToken).toHaveBeenCalledWith(null);
     expect(mocks.mockNavigate).toHaveBeenCalledWith(Routes.WALLET.HOME);
+    jest.advanceTimersByTime(PERFORMANCE_CONFIG.NavigationParamsDelayMs);
+    expect(mocks.mockSetParams).toHaveBeenCalledWith({
+      openNetworkSelector: true,
+    });
   });
 });