fix(multichain-network-controller): batch requests for active networks (#5752)

## Explanation

This PR implements request batching for the Network Activity API to
accommodate a new limitation imposed by the API platform team. The API
endpoint now caps requests at 20 account IDs per call to prevent URL
length limitations in some browsers.

### Key Changes

- Modified `MultichainNetworkService` to handle batching of account IDs
in groups of 20
- Added internal batch processing logic to maintain the same public
interface
- Updated tests to validate correct batching behavior

## References

Related to
[#4469](MetaMask/MetaMask-planning#4469)

## Changelog

NA

## Checklist

- [x] I've updated the test suite for new or updated code as appropriate
- [x] I've updated documentation (JSDoc, Markdown, etc.) for new or
updated code as appropriate
- [x] I've communicated my changes to consumers by [updating changelogs
for packages I've
changed](https://github.com/MetaMask/core/tree/main/docs/contributing.md#updating-changelogs),
highlighting breaking changes as necessary
- [x] I've prepared draft pull requests for clients and consumer
packages to resolve any breaking changes

Author: vinnyhoward

packages/multichain-network-controller/CHANGELOG.md

@@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Updated to restrict `getNetworksWithTransactionActivityByAccounts` to EVM networks only while non-EVM network endpoint support is being completed. Full multi-chain support will be restored in the coming weeks ([#5677](https://github.com/MetaMask/core/pull/5677))
+- Updated network activity API requests to have batching support to handle URL length limitations, allowing the controller to fetch network activity for any number of accounts ([#5752](https://github.com/MetaMask/core/pull/5752))
 
 ## [0.5.0]
 

packages/multichain-network-controller/package.json

@@ -53,14 +53,16 @@
     "@metamask/keyring-internal-api": "^6.0.1",
     "@metamask/superstruct": "^3.1.0",
     "@metamask/utils": "^11.2.0",
-    "@solana/addresses": "^2.0.0"
+    "@solana/addresses": "^2.0.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
     "@metamask/accounts-controller": "^28.0.0",
     "@metamask/auto-changelog": "^3.4.4",
     "@metamask/keyring-controller": "^21.0.6",
     "@metamask/network-controller": "^23.3.0",
     "@types/jest": "^27.4.1",
+    "@types/lodash": "^4.14.191",
     "@types/uuid": "^8.3.0",
     "deepmerge": "^4.2.2",
     "immer": "^9.0.6",

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

@@ -1,4 +1,5 @@
 import { KnownCaipNamespace, type CaipAccountId } from '@metamask/utils';
+import { chunk } from 'lodash';
 
 import { MultichainNetworkService } from './MultichainNetworkService';
 import {
@@ -9,10 +10,15 @@ import {
 } from '../api/accounts-api';
 
 describe('MultichainNetworkService', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
   const mockFetch = jest.fn();
   const MOCK_EVM_ADDRESS = '0x1234567890123456789012345678901234567890';
   const MOCK_EVM_CHAIN_1 = '1';
   const MOCK_EVM_CHAIN_137 = '137';
+  const DEFAULT_BATCH_SIZE = 20;
   const validAccountIds: CaipAccountId[] = [
     `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_1}:${MOCK_EVM_ADDRESS}`,
     `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_137}:${MOCK_EVM_ADDRESS}`,
@@ -25,10 +31,30 @@ describe('MultichainNetworkService', () => {
       });
       expect(service).toBeInstanceOf(MultichainNetworkService);
     });
+
+    it('accepts a custom batch size', () => {
+      const customBatchSize = 10;
+      const service = new MultichainNetworkService({
+        fetch: mockFetch,
+        batchSize: customBatchSize,
+      });
+      expect(service).toBeInstanceOf(MultichainNetworkService);
+    });
   });
 
   describe('fetchNetworkActivity', () => {
-    it('makes request with correct URL and headers', async () => {
+    it('returns empty response for empty account list without making network requests', async () => {
+      const service = new MultichainNetworkService({
+        fetch: mockFetch,
+      });
+
+      const result = await service.fetchNetworkActivity([]);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(result).toStrictEqual({ activeNetworks: [] });
+    });
+
+    it('makes request with correct URL and headers for single batch', async () => {
       const mockResponse: ActiveNetworksResponse = {
         activeNetworks: [
           `${KnownCaipNamespace.Eip155}:${MOCK_EVM_CHAIN_1}:${MOCK_EVM_ADDRESS}`,
@@ -59,6 +85,90 @@ describe('MultichainNetworkService', () => {
       expect(result).toStrictEqual(mockResponse);
     });
 
+    it('batches requests when account IDs exceed the default batch size', async () => {
+      const manyAccountIds: CaipAccountId[] = [];
+      for (let i = 1; i <= 30; i++) {
+        manyAccountIds.push(
+          `${KnownCaipNamespace.Eip155}:${i}:${MOCK_EVM_ADDRESS}` as CaipAccountId,
+        );
+      }
+
+      const batches = chunk(manyAccountIds, DEFAULT_BATCH_SIZE);
+
+      const firstBatchResponse = {
+        activeNetworks: batches[0],
+      };
+      const secondBatchResponse = {
+        activeNetworks: batches[1],
+      };
+
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(firstBatchResponse),
+        })
+        .mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve(secondBatchResponse),
+        });
+
+      const service = new MultichainNetworkService({
+        fetch: mockFetch,
+      });
+
+      const result = await service.fetchNetworkActivity(manyAccountIds);
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+
+      for (const accountId of manyAccountIds) {
+        expect(result.activeNetworks).toContain(accountId);
+      }
+    });
+
+    it('batches requests with custom batch size', async () => {
+      const customBatchSize = 10;
+      const manyAccountIds: CaipAccountId[] = [];
+      for (let i = 1; i <= 30; i++) {
+        manyAccountIds.push(
+          `${KnownCaipNamespace.Eip155}:${i}:${MOCK_EVM_ADDRESS}` as CaipAccountId,
+        );
+      }
+
+      const batches = chunk(manyAccountIds, customBatchSize);
+      expect(batches).toHaveLength(3);
+
+      const batchResponses = batches.map((batch) => ({
+        activeNetworks: batch,
+      }));
+
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(batchResponses[0]),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(batchResponses[1]),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(batchResponses[2]),
+        });
+
+      const service = new MultichainNetworkService({
+        fetch: mockFetch,
+        batchSize: customBatchSize,
+      });
+
+      const result = await service.fetchNetworkActivity(manyAccountIds);
+
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+
+      for (const accountId of manyAccountIds) {
+        expect(result.activeNetworks).toContain(accountId);
+      }
+    });
+
     it('throws error for non-200 response', async () => {
       mockFetch.mockResolvedValueOnce({
         ok: false,

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

@@ -1,5 +1,6 @@
 import { assert } from '@metamask/superstruct';
 import type { CaipAccountId } from '@metamask/utils';
+import { chunk } from 'lodash';
 
 import {
   type ActiveNetworksResponse,
@@ -15,19 +16,61 @@ import {
 export class MultichainNetworkService {
   readonly #fetch: typeof fetch;
 
-  constructor({ fetch: fetchFunction }: { fetch: typeof fetch }) {
+  readonly #batchSize: number;
+
+  constructor({
+    fetch: fetchFunction,
+    batchSize,
+  }: {
+    fetch: typeof fetch;
+    batchSize?: number;
+  }) {
     this.#fetch = fetchFunction;
+    this.#batchSize = batchSize ?? 20;
   }
 
   /**
    * Fetches active networks for the given account IDs.
+   * Automatically handles batching requests to comply with URL length limitations.
    *
    * @param accountIds - Array of CAIP-10 account IDs to fetch activity for.
-   * @returns Promise resolving to the active networks response.
+   * @returns Promise resolving to the combined active networks response.
    * @throws Error if the response format is invalid or the request fails.
    */
   async fetchNetworkActivity(
     accountIds: CaipAccountId[],
+  ): Promise<ActiveNetworksResponse> {
+    if (accountIds.length === 0) {
+      return { activeNetworks: [] };
+    }
+
+    if (accountIds.length <= this.#batchSize) {
+      return this.#fetchNetworkActivityBatch(accountIds);
+    }
+
+    const batches = chunk(accountIds, this.#batchSize);
+    const batchResults = await Promise.all(
+      batches.map((batch) => this.#fetchNetworkActivityBatch(batch)),
+    );
+
+    const combinedResponse: ActiveNetworksResponse = {
+      activeNetworks: batchResults.flatMap(
+        (response) => response.activeNetworks,
+      ),
+    };
+
+    return combinedResponse;
+  }
+
+  /**
+   * Internal method to fetch a single batch of account IDs.
+   *
+   * @param accountIds - Batch of account IDs to fetch
+   * @returns Promise resolving to the active networks response for this batch
+   * @throws Error if the response format is invalid or the request fails
+   */
+  async #fetchNetworkActivityBatch(
+    accountIds: CaipAccountId[],
   ): Promise<ActiveNetworksResponse> {
     try {
       const url = buildActiveNetworksUrl(accountIds);

yarn.lock

@@ -3709,10 +3709,12 @@ __metadata:
     "@metamask/utils": "npm:^11.2.0"
     "@solana/addresses": "npm:^2.0.0"
     "@types/jest": "npm:^27.4.1"
+    "@types/lodash": "npm:^4.14.191"
     "@types/uuid": "npm:^8.3.0"
     deepmerge: "npm:^4.2.2"
     immer: "npm:^9.0.6"
     jest: "npm:^27.5.1"
+    lodash: "npm:^4.17.21"
     nock: "npm:^13.3.1"
     ts-jest: "npm:^27.1.4"
     typedoc: "npm:^0.24.8"