feat: fetch networks with transaction activity by accounts

packages/multichain-network-controller/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- New method `getNetworksWithTransactionActivityByAccounts` to fetch active networks for multiple accounts in a single request ([#5551](https://github.com/MetaMask/core/pull/5551))
+- New `MultichainNetworkService` for handling network activity fetching ([#5551](https://github.com/MetaMask/core/pull/5551))
+- New types for network activity state and responses ([#5551](https://github.com/MetaMask/core/pull/5551))
+
+### Changed
+
+- Updated state management for network activity ([#5551](https://github.com/MetaMask/core/pull/5551))
+
 ## [0.3.0]
 
 ### Changed

packages/multichain-network-controller/package.json

@@ -48,15 +48,19 @@
   },
   "dependencies": {
     "@metamask/base-controller": "^8.0.0",
+    "@metamask/controller-utils": "^11.7.0",
     "@metamask/keyring-api": "^17.4.0",
+    "@metamask/keyring-utils": "^3.0.0",
     "@metamask/utils": "^11.2.0",
-    "@solana/addresses": "^2.0.0"
+    "@solana/addresses": "^2.0.0",
+    "loglevel": "^1.8.1"
   },
   "devDependencies": {
     "@metamask/accounts-controller": "^27.0.0",
     "@metamask/auto-changelog": "^3.4.4",
     "@metamask/keyring-controller": "^21.0.2",
     "@metamask/network-controller": "^23.2.0",
+    "@metamask/superstruct": "^3.1.0",
     "@types/jest": "^27.4.1",
     "@types/uuid": "^8.3.0",
     "deepmerge": "^4.2.2",

packages/multichain-network-controller/src/MultichainNetworkController.test.ts → packages/multichain-network-controller/src/MultichainNetworkController/MultichainNetworkController.test.ts

@@ -8,6 +8,7 @@ import {
   SolAccountType,
   type KeyringAccountType,
   type CaipChainId,
+  EthScope,
 } from '@metamask/keyring-api';
 import type {
   NetworkControllerGetStateAction,
@@ -16,17 +17,34 @@ import type {
   NetworkControllerRemoveNetworkAction,
   NetworkControllerFindNetworkClientIdByChainIdAction,
 } from '@metamask/network-controller';
+import { KnownCaipNamespace } from '@metamask/utils';
+import log from 'loglevel';
 
-import { getDefaultMultichainNetworkControllerState } from './constants';
 import { MultichainNetworkController } from './MultichainNetworkController';
+import { createMockInternalAccount } from '../../tests/utils';
+import { type ActiveNetworksResponse } from '../api/accounts-api';
+import { getDefaultMultichainNetworkControllerState } from '../constants';
+import type { AbstractMultichainNetworkService } from '../MultichainNetworkService/AbstractMultichainNetworkService';
 import {
   type AllowedActions,
   type AllowedEvents,
   type MultichainNetworkControllerAllowedActions,
   type MultichainNetworkControllerAllowedEvents,
   MULTICHAIN_NETWORK_CONTROLLER_NAME,
-} from './types';
-import { createMockInternalAccount } from '../tests/utils';
+} from '../types';
+
+/**
+ * Creates a mock network service for testing.
+ *
+ * @returns A mock network service that implements the MultichainNetworkService interface.
+ */
+function createMockNetworkService(): AbstractMultichainNetworkService {
+  return {
+    fetchNetworkActivity: jest
+      .fn()
+      .mockResolvedValue({ activeNetworks: [] } as ActiveNetworksResponse),
+  };
+}
 
 /**
  * Setup a test controller instance.
@@ -38,6 +56,7 @@ import { createMockInternalAccount } from '../tests/utils';
  * @param args.removeNetwork - Mock for NetworkController:removeNetwork action.
  * @param args.getSelectedChainId - Mock for NetworkController:getSelectedChainId action.
  * @param args.findNetworkClientIdByChainId - Mock for NetworkController:findNetworkClientIdByChainId action.
+ * @param args.mockNetworkService - Mock for MultichainNetworkService.
  * @returns A collection of test controllers and mocks.
  */
 function setupController({
@@ -47,6 +66,7 @@ function setupController({
   removeNetwork,
   getSelectedChainId,
   findNetworkClientIdByChainId,
+  mockNetworkService,
 }: {
   options?: Partial<
     ConstructorParameters<typeof MultichainNetworkController>[0]
@@ -71,6 +91,7 @@ function setupController({
     ReturnType<NetworkControllerFindNetworkClientIdByChainIdAction['handler']>,
     Parameters<NetworkControllerFindNetworkClientIdByChainIdAction['handler']>
   >;
+  mockNetworkService?: AbstractMultichainNetworkService;
 } = {}) {
   const messenger = new Messenger<
     MultichainNetworkControllerAllowedActions,
@@ -149,18 +170,21 @@ function setupController({
       'NetworkController:removeNetwork',
       'NetworkController:getSelectedChainId',
       'NetworkController:findNetworkClientIdByChainId',
+      'AccountsController:listMultichainAccounts',
     ],
     allowedEvents: ['AccountsController:selectedAccountChange'],
   });
 
-  // Default state to use Solana network with EVM as active network
+  const defaultNetworkService = createMockNetworkService();
+
   const controller = new MultichainNetworkController({
-    messenger: options.messenger || controllerMessenger,
+    messenger: options.messenger ?? controllerMessenger,
     state: {
       selectedMultichainNetworkChainId: SolScope.Mainnet,
       isEvmSelected: true,
       ...options.state,
     },
+    networkService: mockNetworkService ?? defaultNetworkService,
   });
 
   const triggerSelectedAccountChange = (accountType: KeyringAccountType) => {
@@ -191,6 +215,7 @@ function setupController({
     mockFindNetworkClientIdByChainId,
     publishSpy,
     triggerSelectedAccountChange,
+    networkService: mockNetworkService ?? defaultNetworkService,
   };
 }
 
@@ -522,4 +547,123 @@ describe('MultichainNetworkController', () => {
       );
     });
   });
+
+  describe('getNetworksWithTransactionActivityByAccounts', () => {
+    const MOCK_EVM_ADDRESS = '0x1234567890123456789012345678901234567890';
+    const MOCK_SOLANA_ADDRESS = 'solana123';
+    const MOCK_EVM_CHAIN_1 = '1';
+    const MOCK_EVM_CHAIN_137 = '137';
+    const MOCK_SOLANA_CHAIN = '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
+
+    beforeEach(() => {
+      jest.spyOn(log, 'error').mockImplementation();
+    });
+
+    it('returns empty object when no accounts exist', async () => {
+      const { controller, messenger } = setupController({
+        getSelectedChainId: jest.fn().mockReturnValue('0x1'),
+      });
+
+      messenger.registerActionHandler(
+        'AccountsController:listMultichainAccounts',
+        () => [],
+      );
+
+      const result =
+        await controller.getNetworksWithTransactionActivityByAccounts();
+      expect(result).toStrictEqual({});
+    });
+
+    it('fetches and formats network activity for EVM accounts', async () => {
+      const mockResponse = {
+        activeNetworks: [
+          `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_1}:${MOCK_EVM_ADDRESS}`,
+          `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_137}:${MOCK_EVM_ADDRESS}`,
+        ],
+      };
+
+      const mockNetworkService = createMockNetworkService();
+      mockNetworkService.fetchNetworkActivity.mockResolvedValue(mockResponse);
+
+      const { controller, messenger } = setupController({
+        mockNetworkService,
+      });
+
+      messenger.registerActionHandler(
+        'AccountsController:listMultichainAccounts',
+        () => [
+          createMockInternalAccount({
+            type: EthAccountType.Eoa,
+            address: MOCK_EVM_ADDRESS,
+            scopes: [EthScope.Eoa],
+          }),
+        ],
+      );
+
+      const result =
+        await controller.getNetworksWithTransactionActivityByAccounts();
+
+      expect(mockNetworkService.fetchNetworkActivity).toHaveBeenCalledWith([
+        `${KnownCaipNamespace.Eip155}:0:${MOCK_EVM_ADDRESS}`,
+      ]);
+
+      expect(result).toStrictEqual({
+        [MOCK_EVM_ADDRESS]: {
+          namespace: KnownCaipNamespace.Eip155,
+          activeChains: [MOCK_EVM_CHAIN_1, MOCK_EVM_CHAIN_137],
+        },
+      });
+    });
+
+    it('formats network activity for mixed EVM and non-EVM accounts', async () => {
+      const mockResponse = {
+        activeNetworks: [
+          `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_1}:${MOCK_EVM_ADDRESS}`,
+          `${KnownCaipNamespace.Solana}:${MOCK_SOLANA_CHAIN}:${MOCK_SOLANA_ADDRESS}`,
+        ],
+      };
+
+      const mockNetworkService = createMockNetworkService();
+      mockNetworkService.fetchNetworkActivity.mockResolvedValue(mockResponse);
+
+      const { controller, messenger } = setupController({
+        mockNetworkService,
+      });
+
+      messenger.registerActionHandler(
+        'AccountsController:listMultichainAccounts',
+        () => [
+          createMockInternalAccount({
+            type: EthAccountType.Eoa,
+            address: MOCK_EVM_ADDRESS,
+            scopes: [EthScope.Eoa],
+          }),
+          createMockInternalAccount({
+            type: SolAccountType.DataAccount,
+            address: MOCK_SOLANA_ADDRESS,
+            scopes: [SolScope.Mainnet],
+          }),
+        ],
+      );
+
+      const result =
+        await controller.getNetworksWithTransactionActivityByAccounts();
+
+      expect(mockNetworkService.fetchNetworkActivity).toHaveBeenCalledWith([
+        `${KnownCaipNamespace.Eip155}:0:${MOCK_EVM_ADDRESS}`,
+        `${KnownCaipNamespace.Solana}:${MOCK_SOLANA_CHAIN}:${MOCK_SOLANA_ADDRESS}`,
+      ]);
+
+      expect(result).toStrictEqual({
+        [MOCK_EVM_ADDRESS]: {
+          namespace: KnownCaipNamespace.Eip155,
+          activeChains: [MOCK_EVM_CHAIN_1],
+        },
+        [MOCK_SOLANA_ADDRESS]: {
+          namespace: KnownCaipNamespace.Solana,
+          activeChains: [MOCK_SOLANA_CHAIN],
+        },
+      });
+    });
+  });
 });

packages/multichain-network-controller/src/MultichainNetworkController.ts → packages/multichain-network-controller/src/MultichainNetworkController/MultichainNetworkController.ts

@@ -4,22 +4,28 @@ import type { InternalAccount } from '@metamask/keyring-internal-api';
 import type { NetworkClientId } from '@metamask/network-controller';
 import { type CaipChainId, isCaipChainId } from '@metamask/utils';
 
+import {
+  type ActiveNetworksByAddress,
+  toAllowedCaipAccountIds,
+  toActiveNetworksByAddress,
+} from '../api/accounts-api';
 import {
   MULTICHAIN_NETWORK_CONTROLLER_METADATA,
   getDefaultMultichainNetworkControllerState,
-} from './constants';
+} from '../constants';
+import type { AbstractMultichainNetworkService } from '../MultichainNetworkService/AbstractMultichainNetworkService';
 import {
   MULTICHAIN_NETWORK_CONTROLLER_NAME,
   type MultichainNetworkControllerState,
   type MultichainNetworkControllerMessenger,
   type SupportedCaipChainId,
-} from './types';
+} from '../types';
 import {
   checkIfSupportedCaipChainId,
   getChainIdForNonEvmAddress,
   convertEvmCaipToHexChainId,
   isEvmCaipChainId,
-} from './utils';
+} from '../utils';
 
 /**
  * The MultichainNetworkController is responsible for fetching and caching account
@@ -30,15 +36,19 @@ export class MultichainNetworkController extends BaseController<
   MultichainNetworkControllerState,
   MultichainNetworkControllerMessenger
 > {
+  readonly #networkService: AbstractMultichainNetworkService;
+
   constructor({
     messenger,
     state,
+    networkService,
   }: {
     messenger: MultichainNetworkControllerMessenger;
     state?: Omit<
       Partial<MultichainNetworkControllerState>,
       'multichainNetworkConfigurationsByChainId'
     >;
+    networkService: AbstractMultichainNetworkService;
   }) {
     super({
       messenger,
@@ -50,6 +60,7 @@ export class MultichainNetworkController extends BaseController<
       },
     });
 
+    this.#networkService = networkService;
     this.#subscribeToMessageEvents();
     this.#registerMessageHandlers();
   }
@@ -139,6 +150,35 @@ export class MultichainNetworkController extends BaseController<
     return await this.#setActiveEvmNetwork(id);
   }
 
+  /**
+   * Returns the active networks for the available EVM addresses (non-EVM networks will be supported in the future).
+   * Fetches the data from the API and caches it in state.
+   *
+   * @returns A promise that resolves to the active networks for the available addresses
+   */
+  async getNetworksWithTransactionActivityByAccounts(): Promise<ActiveNetworksByAddress> {
+    const accounts = this.messagingSystem.call(
+      'AccountsController:listMultichainAccounts',
+    );
+    if (!accounts || accounts.length === 0) {
+      return this.state.networksWithTransactionActivity;
+    }
+
+    const formattedAccounts = accounts
+      .map((account: InternalAccount) => toAllowedCaipAccountIds(account))
+      .flat();
+
+    const activeNetworks =
+      await this.#networkService.fetchNetworkActivity(formattedAccounts);
+    const formattedNetworks = toActiveNetworksByAddress(activeNetworks);
+
+    this.update((state) => {
+      state.networksWithTransactionActivity = formattedNetworks;
+    });
+
+    return this.state.networksWithTransactionActivity;
+  }
+
   /**
    * Removes an EVM network from the list of networks.
    * This method re-directs the request to the network-controller.
@@ -260,5 +300,9 @@ export class MultichainNetworkController extends BaseController<
       'MultichainNetworkController:setActiveNetwork',
       this.setActiveNetwork.bind(this),
     );
+    this.messagingSystem.registerActionHandler(
+      'MultichainNetworkController:getNetworksWithTransactionActivityByAccounts',
+      this.getNetworksWithTransactionActivityByAccounts.bind(this),
+    );
   }
 }

packages/multichain-network-controller/src/MultichainNetworkService/AbstractMultichainNetworkService.ts

@@ -0,0 +1,9 @@
+import type { PublicInterface } from '@metamask/utils';
+
+import type { MultichainNetworkService } from './MultichainNetworkService';
+
+/**
+ * A service object which is responsible for fetching network activity data.
+ */
+export type AbstractMultichainNetworkService =
+  PublicInterface<MultichainNetworkService>;