fix: Autodetect NFTs does not detect NFTs on Linea and Ethereum Mainnet (#20504)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**

Te logic of the useNftDetectionChainIds function was failing to get the
chainIds and always defaulted to using Ethereum only. I have simplified
the logic to make this work

<!--
Write a short description of the changes included in this pull request,
also include relevant motivation and context. Have in mind the following
questions:
1. What is the reason for the change?
2. What is the improvement/solution?
-->

## **Changelog**

<!--
If this PR is not End-User-Facing and should not show up in the
CHANGELOG, you can choose to either:
1. Write `CHANGELOG entry: null`
2. Label with `no-changelog`

If this PR is End-User-Facing, please write a short User-Facing
description in the past tense like:
`CHANGELOG entry: Added a new tab for users to see their NFTs`
`CHANGELOG entry: Fixed a bug that was causing some NFTs to flicker`

(This helps the Release Engineer do their job more quickly and
accurately)
-->

CHANGELOG entry:

## **Related issues**

Fixes: #19220 |
https://consensyssoftware.atlassian.net/browse/ASSETS-1179

## **Manual testing steps**

```gherkin
Feature: my feature name

  Scenario: user [verb for user action]
    Given [describe expected initial app state]

    When user [verb for user action]
    Then [describe expected outcome]
```

## **Screenshots/Recordings**

<!-- If applicable, add screenshots and/or recordings to visualize the
before and after of your change. -->

### **Before**

<img width="375" height="770" alt="image"
src="https://github.com/user-attachments/assets/277dcf9a-4647-4e05-9ee5-153c6717c110"
/>

### **After**

<img width="362" height="751" alt="image"
src="https://github.com/user-attachments/assets/d0faa9a9-8c04-415f-8285-849b27fdde39"
/>

## **Pre-merge author checklist**

- [ ] I’ve followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [ ] I've completed the PR template to the best of my ability
- [ ] I’ve included tests if applicable
- [ ] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [ ] I’ve applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Simplifies NFT detection chain ID logic to use enabledNetworks from
useCurrentNetworkInfo with fallback to current chainId, and updates
tests accordingly.
> 
> - **Hooks**
> - **useNftDetectionChainIds**: Replace all-networks/popular-network
selectors with `useCurrentNetworkInfo().enabledNetworks`; if any
enabled, return their `chainId`s, otherwise fallback to current
`selectChainId`.
> - **Tests**
> - Update `useNftDetectionChainIds.test.ts` to mock
`useCurrentNetworkInfo` and validate both empty and populated
`enabledNetworks`; remove reliance on popular-network selectors; add
`beforeEach` to clear mocks.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
c42beb2. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Salim TOUBAL <[email protected]>

Author: juanmigdr

app/components/hooks/useNftDetectionChainIds.test.ts

@@ -6,12 +6,8 @@ import { backgroundState } from '../../util/test/initial-root-state';
 import { RootState } from '../../reducers';
 import { useNftDetectionChainIds } from './useNftDetectionChainIds';
 import { useSelector } from 'react-redux';
-import {
-  selectChainId,
-  selectIsAllNetworks,
-  selectIsPopularNetwork,
-  selectAllPopularNetworkConfigurations,
-} from '../../selectors/networkController';
+import { selectChainId } from '../../selectors/networkController';
+import { useCurrentNetworkInfo } from './useCurrentNetworkInfo';
 
 const mockInitialState: DeepPartial<RootState> = {
   settings: {},
@@ -27,45 +23,52 @@ jest.mock('react-redux', () => ({
   useSelector: jest.fn(),
 }));
 
+jest.mock('./useCurrentNetworkInfo', () => ({
+  useCurrentNetworkInfo: jest.fn(),
+}));
+
 describe('useNftDetectionChainIds', () => {
-  it('returns current chain id when filtered on current network', async () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns current chain id when enabledNetworks is empty', async () => {
     (useSelector as jest.Mock).mockImplementation((selector) => {
-      if (selector === selectIsAllNetworks) {
-        return false; // to show all networks
-      }
       if (selector === selectChainId) {
         return '0x1';
       }
       return null;
     });
+
+    (useCurrentNetworkInfo as jest.Mock).mockReturnValue({
+      enabledNetworks: [], // Empty array should fallback to current chainId
+    });
+
     const { result } = renderHookWithProvider(() => useNftDetectionChainIds(), {
       state: mockInitialState,
     });
     expect(result?.current).toEqual(['0x1']);
   });
-  it('returns array of all popular networks when there is no filter on networks', async () => {
+
+  it('returns array of enabled network chain ids when enabledNetworks has networks', async () => {
     (useSelector as jest.Mock).mockImplementation((selector) => {
-      if (selector === selectIsAllNetworks) {
-        return true;
-      }
-      if (selector === selectIsPopularNetwork) {
-        return true;
-      }
-      if (selector === selectAllPopularNetworkConfigurations) {
-        return {
-          '0x1': {
-            chainId: '0x1',
-          },
-          '0x2': {
-            chainId: '0x2',
-          },
-        };
+      if (selector === selectChainId) {
+        return '0x1';
       }
       return null;
     });
+
+    (useCurrentNetworkInfo as jest.Mock).mockReturnValue({
+      enabledNetworks: [
+        { chainId: '0x1', enabled: true },
+        { chainId: '0x89', enabled: true },
+        { chainId: '0xa', enabled: true },
+      ],
+    });
+
     const { result } = renderHookWithProvider(() => useNftDetectionChainIds(), {
       state: mockInitialState,
     });
-    expect(result?.current).toEqual(['0x1', '0x2']);
+    expect(result?.current).toEqual(['0x1', '0x89', '0xa']);
   });
 });

app/components/hooks/useNftDetectionChainIds.ts

@@ -1,38 +1,26 @@
 import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
-import {
-  selectAllPopularNetworkConfigurations,
-  selectChainId,
-  selectIsAllNetworks,
-  selectIsPopularNetwork,
-} from '../../selectors/networkController';
+import { selectChainId } from '../../selectors/networkController';
 import { Hex } from '@metamask/utils';
+import { useCurrentNetworkInfo } from './useCurrentNetworkInfo';
 
 /**
  * Hook to determine the chains that should detect NFTs
  *
  * @returns an array of the chain ids allowed for NFTs search
  */
 export const useNftDetectionChainIds = (): Hex[] => {
-  const isAllNetworks = useSelector(selectIsAllNetworks);
-  const isPopularNetworks = useSelector(selectIsPopularNetwork);
-  const networkConfigurationsPopularNetworks = useSelector(
-    selectAllPopularNetworkConfigurations,
-  );
+  const { enabledNetworks } = useCurrentNetworkInfo();
+
   const chainId = useSelector(selectChainId);
 
   return useMemo(
     () =>
-      isAllNetworks && isPopularNetworks
-        ? (Object.values(networkConfigurationsPopularNetworks).map(
+      enabledNetworks.length >= 1
+        ? (Object.values(enabledNetworks).map(
             (network) => network.chainId,
           ) as Hex[])
         : ([chainId] as Hex[]),
-    [
-      isAllNetworks,
-      isPopularNetworks,
-      networkConfigurationsPopularNetworks,
-      chainId,
-    ],
+    [enabledNetworks, chainId],
   );
 };