Merge branch 'main' into predict/bump-sell-slippage

Author: matallui

.github/CODEOWNERS

@@ -43,6 +43,7 @@ app/core/Engine/controllers/remote-feature-flag-controller/ @MetaMask/mobile-pla
 app/core/DeeplinkManager                                    @MetaMask/mobile-platform
 scripts/build.sh                                            @MetaMask/mobile-platform
 scripts/update-expo-channel.js                              @MetaMask/mobile-admins
+certs/certificate.pem                                       @MetaMask/mobile-admins
 
 # Platform & Snaps Code Fencing File
 metro.transform.js @MetaMask/mobile-platform @MetaMask/core-platform

android/app/build.gradle

@@ -187,8 +187,8 @@ android {
         applicationId "io.metamask"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionName "7.61.0"
-        versionCode 2993
+        versionName "7.61.99"
+        versionCode 3092
         testBuildType System.getProperty('testBuildType', 'debug')
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         manifestPlaceholders.MM_BRANCH_KEY_TEST = "$System.env.MM_BRANCH_KEY_TEST"

app.config.js

@@ -46,6 +46,11 @@ module.exports = {
     owner: 'metamask-test',
     runtimeVersion: RUNTIME_VERSION,
     updates: {
+      codeSigningCertificate: './certs/certificate.pem',
+      codeSigningMetadata: {
+        keyid: 'main',
+        alg: 'rsa-v1_5-sha256',
+      },
       url: UPDATE_URL,
       // Channel is set by requestHeaders, will be overridden with build script
       requestHeaders: {

app/components/UI/NetworkManager/index.test.tsx

@@ -5,6 +5,7 @@ import configureStore from 'redux-mock-store';
 
 import NetworkManager from './index';
 import { useNetworksByNamespace } from '../../hooks/useNetworksByNamespace/useNetworksByNamespace';
+import { useNetworkEnablement } from '../../hooks/useNetworkEnablement/useNetworkEnablement';
 import Engine from '../../../core/Engine';
 
 // Create mock functions that we can spy on
@@ -147,16 +148,40 @@ jest.mock('../../hooks/useNetworksByNamespace/useNetworksByNamespace', () => ({
   },
 }));
 
+const mockEnableNetwork = jest.fn();
+
 jest.mock('../../hooks/useNetworkEnablement/useNetworkEnablement', () => ({
-  useNetworkEnablement: () => ({
+  useNetworkEnablement: jest.fn(() => ({
     disableNetwork: mockDisableNetwork,
+    enableNetwork: mockEnableNetwork,
     enabledNetworksByNamespace: {
       eip155: {
         '0x1': true,
         '0x89': true,
       },
     },
-  }),
+  })),
+}));
+
+jest.mock('../../hooks/useNetworksToUse/useNetworksToUse', () => ({
+  useNetworksToUse: jest.fn(() => ({
+    networksToUse: [
+      {
+        id: 'eip155:1',
+        name: 'Ethereum Mainnet',
+        caipChainId: 'eip155:1',
+        isSelected: true,
+        imageSource: { uri: 'ethereum.png' },
+      },
+      {
+        id: 'eip155:137',
+        name: 'Polygon Mainnet',
+        caipChainId: 'eip155:137',
+        isSelected: false,
+        imageSource: { uri: 'polygon.png' },
+      },
+    ],
+  })),
 }));
 
 jest.mock('../../../util/device', () => ({
@@ -1011,4 +1036,193 @@ describe('NetworkManager Component', () => {
       });
     });
   });
+
+  describe('Enabled Networks Processing', () => {
+    const mockUseNetworkEnablement =
+      useNetworkEnablement as jest.MockedFunction<typeof useNetworkEnablement>;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should correctly process enabled networks from flat structure', () => {
+      mockUseNetworkEnablement.mockReturnValue({
+        disableNetwork: mockDisableNetwork,
+        enableNetwork: mockEnableNetwork,
+        enabledNetworksByNamespace: {
+          eip155: {
+            '0x1': true,
+            '0x89': true,
+            '0xa': false,
+          },
+        },
+        namespace: 'eip155',
+        enabledNetworksForCurrentNamespace: {},
+        networkEnablementController: {} as never,
+        isNetworkEnabled: jest.fn(),
+        hasOneEnabledNetwork: false,
+        enableAllPopularNetworks: jest.fn(),
+        tryEnableEvmNetwork: jest.fn(),
+        enabledNetworksForAllNamespaces: {
+          '0x1': true,
+          '0x89': true,
+          '0xa': false,
+        },
+      });
+
+      // The component internally processes enabledNetworksByNamespace
+      // We verify it renders without errors and has correct tab state
+      const { getByTestId } = renderComponent();
+
+      // Verify component renders successfully with processed networks
+      expect(getByTestId('main-bottom-sheet')).toBeOnTheScreen();
+    });
+
+    it('should correctly process enabled networks from nested structure', () => {
+      mockUseNetworkEnablement.mockReturnValue({
+        disableNetwork: mockDisableNetwork,
+        enableNetwork: mockEnableNetwork,
+        enabledNetworksByNamespace: {
+          eip155: {
+            '0x1': true,
+            '0x89': false,
+          },
+          bip122: {
+            '0x1': true,
+          },
+        } as never,
+        namespace: 'eip155',
+        enabledNetworksForCurrentNamespace: {},
+        networkEnablementController: {} as never,
+        isNetworkEnabled: jest.fn(),
+        hasOneEnabledNetwork: false,
+        enableAllPopularNetworks: jest.fn(),
+        tryEnableEvmNetwork: jest.fn(),
+        enabledNetworksForAllNamespaces: {
+          '0x1': true,
+          '0x89': false,
+          '0xa': false,
+        },
+      });
+
+      // The component should handle nested namespace structures
+      const { getByTestId } = renderComponent();
+
+      expect(getByTestId('main-bottom-sheet')).toBeOnTheScreen();
+    });
+
+    it('should handle empty enabled networks gracefully', () => {
+      mockUseNetworkEnablement.mockReturnValue({
+        disableNetwork: mockDisableNetwork,
+        enableNetwork: mockEnableNetwork,
+        enabledNetworksByNamespace: {},
+        namespace: 'eip155',
+        enabledNetworksForCurrentNamespace: {},
+        networkEnablementController: {} as never,
+        isNetworkEnabled: jest.fn(),
+        hasOneEnabledNetwork: false,
+        enableAllPopularNetworks: jest.fn(),
+        tryEnableEvmNetwork: jest.fn(),
+        enabledNetworksForAllNamespaces: {},
+      });
+
+      const { getByTestId } = renderComponent();
+
+      expect(getByTestId('main-bottom-sheet')).toBeOnTheScreen();
+    });
+
+    it('should filter out disabled networks correctly', () => {
+      mockUseNetworkEnablement.mockReturnValue({
+        disableNetwork: mockDisableNetwork,
+        enableNetwork: mockEnableNetwork,
+        enabledNetworksByNamespace: {
+          eip155: {
+            '0x1': true,
+            '0x89': false,
+            '0xa': false,
+            '0xa4b1': true,
+          },
+        },
+        namespace: 'eip155',
+        enabledNetworksForCurrentNamespace: {},
+        networkEnablementController: {} as never,
+        isNetworkEnabled: jest.fn(),
+        hasOneEnabledNetwork: false,
+        enableAllPopularNetworks: jest.fn(),
+        tryEnableEvmNetwork: jest.fn(),
+        enabledNetworksForAllNamespaces: {
+          '0x1': true,
+          '0x89': false,
+          '0xa': false,
+          '0xa4b1': true,
+        },
+      });
+
+      // Component should only include enabled (true) networks
+      const { getByTestId } = renderComponent();
+
+      expect(getByTestId('main-bottom-sheet')).toBeOnTheScreen();
+    });
+
+    it('should enable and disable networks correctly during deletion', async () => {
+      const otherNetwork = {
+        id: 'eip155:137',
+        name: 'Polygon Mainnet',
+        caipChainId: 'eip155:137',
+        isSelected: false,
+        imageSource: { uri: 'polygon.png' },
+      };
+
+      (useNetworksByNamespace as jest.Mock).mockImplementation((args) => {
+        if (args.networkType === 'custom') {
+          return {
+            networks: [otherNetwork],
+            areAllNetworksSelected: false,
+          };
+        }
+        return { selectedCount: 2 };
+      });
+
+      mockUseNetworkEnablement.mockReturnValue({
+        disableNetwork: mockDisableNetwork,
+        enableNetwork: mockEnableNetwork,
+        enabledNetworksByNamespace: {
+          eip155: {
+            '0x1': true,
+            '0x89': true,
+          },
+        },
+        namespace: 'eip155',
+        enabledNetworksForCurrentNamespace: {},
+        networkEnablementController: {} as never,
+        isNetworkEnabled: jest.fn(),
+        hasOneEnabledNetwork: false,
+        enableAllPopularNetworks: jest.fn(),
+        tryEnableEvmNetwork: jest.fn(),
+        enabledNetworksForAllNamespaces: {
+          '0x1': true,
+          '0x89': true,
+        },
+      });
+
+      const { getByTestId } = renderComponent();
+
+      // Open modal and trigger delete confirmation
+      const openModalButton = getByTestId('open-modal-button');
+      fireEvent.press(openModalButton);
+
+      await waitFor(() => {
+        const deleteButton = getByTestId('account-action-app_settings.delete');
+        fireEvent.press(deleteButton);
+      });
+
+      // Confirm deletion
+      const confirmButton = getByTestId('footer-button-app_settings.delete');
+      fireEvent.press(confirmButton);
+
+      // Should enable the other network and disable the deleted one
+      expect(mockEnableNetwork).toHaveBeenCalledWith('eip155:137');
+      expect(mockDisableNetwork).toHaveBeenCalledWith('eip155:1');
+    });
+  });
 });

app/components/UI/NetworkManager/index.tsx

@@ -60,6 +60,7 @@ import { POPULAR_NETWORK_CHAIN_IDS } from '../../../constants/popular-networks';
 import RpcSelectionModal from '../../Views/NetworkSelector/RpcSelectionModal/RpcSelectionModal';
 import { isNonEvmChainId } from '../../../core/Multichain/utils';
 import { NetworkConfiguration } from '@metamask/network-controller';
+import { useNetworksToUse } from '../../hooks/useNetworksToUse/useNetworksToUse';
 
 export const createNetworkManagerNavDetails = createNavigationDetails(
   Routes.MODAL.ROOT_MODAL_FLOW,
@@ -94,7 +95,16 @@ const NetworkManager = () => {
   const { selectedCount } = useNetworksByNamespace({
     networkType: NetworkType.Popular,
   });
-  const { disableNetwork, enabledNetworksByNamespace } = useNetworkEnablement();
+  const { networks, areAllNetworksSelected } = useNetworksByNamespace({
+    networkType: NetworkType.Custom,
+  });
+  const { disableNetwork, enableNetwork, enabledNetworksByNamespace } =
+    useNetworkEnablement();
+  const { networksToUse } = useNetworksToUse({
+    networks,
+    networkType: NetworkType.Custom,
+    areAllNetworksSelected,
+  });
 
   const isMultichainAccountsState2Enabled = useSelector(
     selectMultichainAccountsState2Enabled,
@@ -304,17 +314,24 @@ const NetworkManager = () => {
       const { NetworkController } = Engine.context;
       const rawChainId = parseCaipChainId(caipChainId).reference;
       const chainId = toHex(rawChainId);
+      const otherNetwork = networksToUse.find(
+        (network) => network.caipChainId !== caipChainId,
+      );
 
+      // Remove the network from controller and disable it
       NetworkController.removeNetwork(chainId);
-      disableNetwork(showConfirmDeleteModal.caipChainId);
 
+      if (otherNetwork?.caipChainId) {
+        enableNetwork(otherNetwork.caipChainId);
+      }
+      disableNetwork(showConfirmDeleteModal.caipChainId);
       MetaMetrics.getInstance().addTraitsToUser(
         removeItemFromChainIdList(chainId),
       );
 
       setShowConfirmDeleteModal(initialShowConfirmDeleteModal);
     }
-  }, [showConfirmDeleteModal, disableNetwork]);
+  }, [showConfirmDeleteModal, disableNetwork, networksToUse, enableNetwork]);
 
   const cancelButtonProps: ButtonProps = useMemo(
     () => ({