perf(multichain-account-service)!: avoid excessive state syncing (#6654)

## Explanation

### `MultichainAccountService`

- Unified wallet creation into one flow
(`createMultichainAccountWallet`) that handles import/restore/new vault.
- Builds a single `ServiceState` index in one pass and passes state
slices to wallets/groups (cuts repeated controller scans/calls).
- Simplified `init` path and removed dead `accountIdToContext` mapping.

### `MultichainAccountWallet`

- `init` now consumes a pre-sliced wallet state (entropySource → groups
→ providerName → ids) instead of querying providers.
- Emits clear events on group creation/updates; alignment orchestration
uses provider state instead of full scans.

### `MultichainAccountGroup`

- `init` registers account IDs per provider and fills reverse maps;
calls `provider.addAccounts(ids)` to keep providers in sync.
- Added `getAccountIds()` for direct access to underlying IDs.
- Improved partial‑failure reporting (aggregates provider errors by
name).

### `BaseBip44AccountProvider`

- Added `addAccounts(ids: string[])`, enabling providers to track their
own account ID lists.
- `getAccounts()` paths rely on known IDs (plural lookups) rather than
scanning the full controller list.

### `EvmAccountProvider`

- Switched from address‑based scans to ID‑based fetches
(`getAccount(s)`) for create/discover (removes $O(n)$ scans).

### Performance Analysis

```
n = total BIP-44 accounts in the AccountsController
p = number of providers (currently 4)
w = number of wallets (entropy sources)
g = total number of groups
e = number of created EVM accounts
```
When fully aligned $g = n / p$. 
When accounts are not fully aligned then $g = max(f(p))$, where $f(p)$
is the number of accounts associated with a provider.

Consider two scenarios: 
1. State 1 -> State 2 transition, the user has unaligned groups after
the transition.
2. Already transitioned to State 2, the service is initialized after
onboarding and every time the client is unlocked.

<ins>General formulas</ins>

For **Scenario 2**, the formulas are as follows:

_Before_ this refactor, the number of loops can be represented $n * p *
(1 + w + g)$, which with $p = 4$, becomes $n^2 + 4n(1 + w)$.

_Before_ this refactor, the number of controller calls can be
represented as $1 + w + g$, which with $p = 4$, becomes $1 + w + n/4$.

_After_ this refactor, the number of loops can be represented by $n *
p$, which with $p = 4$, becomes $4n$.

_After_ this refactor, the number of calls is just $1$.

For **Scenario 1**, the formulas are entirely dependent on the breakdown
of the number of accounts each provider has amongst the $n$ accounts,
let's consider a scenario where Solana has $n/2$, Ethereum has $n/8$,
Bitcoin has $n/4$ and Tron has $n/8$, the formulas would be as follows:

_Before_ this refactor, the number of loops in the alignment process can
be represented as $(p * g) + (n * e)$, which with $p=4$ and $g = n/2$,
becomes $2n + 3n^2/8$. Therefore the number of loops for initialization
+ alignment in this scenario with $p = 4$ and $g = n/2$, becomes
$(19/8)n^2 + (4w + 6)n$.

_Before_ this refactor, the number of controller calls in the alignment
process can be represented as $e$, which becomes $3n/8$. Therefore the
number of controller calls for initialization + alignment in this
scenario with $p = 4$, becomes $1 + w + 5n/8$.

_After_ this refactor, the number of loops in the alignment process can
be represented as $p * g$, which becomes $2n$. Therefore, the number of
loops for initialization + alignment in this scenario with $p = 4$ and
$g = n/2$, becomes $6n$.

_After_ this refactor, the number of controller calls in the alignment
process can be represented as $e$ which becomes $3n/8$. Therefore, the
number of controller calls for initialization + alignment in this
scenario with $p = 4$ and $g = n/2$, becomes $1 + 3n/8$.

In short, previous `init` performance for loops and controller calls was
quadratic and linear, respectively. After, it is linear and constant.

### Performance Charts

Below are charts that show performance (loops and controller calls) $n =
0$ -> $n = 256$ for Scenario 1 and 2 with $w = 2$, respectively:

<img width="678" height="401" alt="MisalignedLoops"
src="https://github.com/user-attachments/assets/52009899-9d8b-4c66-8db3-b76b13fffc86"
/>

<img width="678" height="401" alt="MisalignedCalls"
src="https://github.com/user-attachments/assets/b07222c7-ac86-4854-a29e-a364166bcc8f"
/>

<img width="678" height="401" alt="AlignedLoops"
src="https://github.com/user-attachments/assets/92de8ae2-fae3-4071-b3bf-9575fb9a0f1a"
/>

<img width="678" height="401" alt="AlignedCalls"
src="https://github.com/user-attachments/assets/bfe39332-edb8-4b7d-9623-ffe8e97cddf9"
/>

## References

- MetaMask/metamask-extension#38265
- MetaMask/metamask-mobile#25040

## 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



<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Introduces a centralized `ServiceState` and ID-based provider model to
remove repeated controller scans and ad‑hoc syncing.
> 
> - MultichainAccountService: builds `ServiceState` in one pass; `init`
passes state slices to wallets/groups; unified
`createMultichainAccountWallet` (import/create/restore); added
`removeMultichainAccountWallet` action; removed reverse
`accountIdToContext` and legacy sync handlers
> - MultichainAccountWallet/Group: new `init`/`update` APIs; groups
store provider→IDs, expose `getAccountIds`; alignment uses provider
`alignAccounts`, aggregates per‑provider errors; background non‑EVM
creation supported
> - Providers: new `init(ids)` and `alignAccounts` on
`BaseBip44AccountProvider`; providers track account IDs and fetch via
`AccountsController:getAccount(s)`; `AccountProviderWrapper` forwards
`init`, adds enable/disable handling
> - EVM provider: derives deterministic account IDs, fetches via
`getAccount`, reduces address scanning; discovery uses retry/timeout
helpers
> - Tests and changelog updated; BREAKING changes to provider interfaces
and service init/creation flows
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
cd0d095. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Charly Chevalier <charly.chevalier@consensys.net>

Author: hmalik88

eslint-suppressions.json

@@ -1092,20 +1092,11 @@
   "packages/multichain-account-service/src/MultichainAccountWallet.test.ts": {
     "id-length": {
       "count": 2
-    },
-    "no-param-reassign": {
-      "count": 1
     }
   },
   "packages/multichain-account-service/src/MultichainAccountWallet.ts": {
     "@typescript-eslint/explicit-function-return-type": {
-      "count": 3
-    },
-    "@typescript-eslint/prefer-nullish-coalescing": {
-      "count": 1
-    },
-    "id-length": {
-      "count": 1
+      "count": 2
     },
     "require-atomic-updates": {
       "count": 2
@@ -1126,11 +1117,6 @@
       "count": 2
     }
   },
-  "packages/multichain-account-service/src/providers/EvmAccountProvider.test.ts": {
-    "@typescript-eslint/explicit-function-return-type": {
-      "count": 4
-    }
-  },
   "packages/multichain-account-service/src/providers/EvmAccountProvider.ts": {
     "@typescript-eslint/naming-convention": {
       "count": 1
@@ -1166,17 +1152,14 @@
   },
   "packages/multichain-account-service/src/tests/providers.ts": {
     "@typescript-eslint/explicit-function-return-type": {
-      "count": 2
+      "count": 1
     }
   },
   "packages/multichain-account-service/src/utils.ts": {
     "@typescript-eslint/explicit-function-return-type": {
-      "count": 2
-    },
-    "id-denylist": {
       "count": 1
     },
-    "id-length": {
+    "id-denylist": {
       "count": 1
     }
   },

packages/multichain-account-service/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **BREAKING** A performance refactor was made around all the classes in this package ([#6654](https://github.com/MetaMask/core/pull/6654))
+  - Add logic in the `createMultichainAccountWallet` method in `MultichainAccountService` so that it can handle all entry points: importing an SRP, recovering a vault and creating a new vault.
+  - Add a `getAccountIds` method which returns all the account ids pertaining to a group.
+  - Add an `addAccounts` method on the `BaseBip44AccountProvider` class which keeps track of all the account IDs that pertain to it.
+
 ### Changed
 
 - Bump `@metamask/keyring-controller` from `^25.0.0` to `^25.1.0` ([#7713](https://github.com/MetaMask/core/pull/7713))
@@ -123,8 +130,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **BREAKING** A performance refactor was made around all the classes in this package ([#6654](https://github.com/MetaMask/core/pull/6654))
+  - The `MultichainAccountService` is refactored to construct a top level service state for its `init` function, this state is passed down to the `MultichainAccountWallet` and `MultichainAccountGroup` classes in slices for them to construct their internal states.
+  - Additional state is generated at the entry points where it needs to be updated i.e. `createMultichainAccountGroup`, `discoverAccounts` and `alignAccounts`.
+  - We no longer prevent group creation if some providers' `createAccounts` calls fail during group creation, only if they all fail.
+  - The `getAccounts` method in the `BaseBip44AccountProvider` class no longer relies on fetching the entire list of internal accounts from the `AccountsController`, instead it gets the specific accounts that it stores in its internal accounts list.
+  - The `EvmAccountProvider` no longer fetches from the `AccountController` to get an account for its ID, we deterministically get the associated account ID through `getUUIDFromAddressOfNormalAccount`.
+  - The `EvmAccountProvider` now uses the `getAccount` method from the `AccountsController` when fetching an account after account creation as it is more efficient.
 - Bump `@metamask/base-controller` from `^8.4.1` to `^8.4.2` ([#6917](https://github.com/MetaMask/core/pull/6917))
 
+### Removed
+
+- **BREAKING** A performance refactor was made around all the classes in this package ([#6654](https://github.com/MetaMask/core/pull/6654))
+  - Remove `#handleOnAccountAdded` and `#handleOnAccountRemoved` methods in `MultichainAccountService` due to internal state being updated within the service.
+  - Remove `getAccountContext` (and associated map) in the `MultichainAccountService` as the service no longer uses that method.
+  - Remove the `sync` method in favor of the sole `init` method for both `MultichainAccountWallet` and `MultichainAccountGroup`.
+
 ## [1.6.1]
 
 ### Changed

packages/multichain-account-service/src/MultichainAccountGroup.test.ts

@@ -1,26 +1,29 @@
 import type { Bip44Account } from '@metamask/account-api';
 import {
   AccountGroupType,
+  isBip44Account,
   toMultichainAccountGroupId,
   toMultichainAccountWalletId,
 } from '@metamask/account-api';
 import { EthScope, SolScope } from '@metamask/keyring-api';
 import type { InternalAccount } from '@metamask/keyring-internal-api';
 
+import type { GroupState } from './MultichainAccountGroup';
 import { MultichainAccountGroup } from './MultichainAccountGroup';
 import { MultichainAccountWallet } from './MultichainAccountWallet';
+import type { RootMessenger, MockAccountProvider } from './tests';
 import {
   MOCK_SNAP_ACCOUNT_2,
   MOCK_WALLET_1_BTC_P2TR_ACCOUNT,
   MOCK_WALLET_1_BTC_P2WPKH_ACCOUNT,
   MOCK_WALLET_1_ENTROPY_SOURCE,
   MOCK_WALLET_1_EVM_ACCOUNT,
   MOCK_WALLET_1_SOL_ACCOUNT,
-  setupNamedAccountProvider,
+  setupBip44AccountProvider,
   getMultichainAccountServiceMessenger,
   getRootMessenger,
+  mockCreateAccountsOnce,
 } from './tests';
-import type { MockAccountProvider, RootMessenger } from './tests';
 import type { MultichainAccountServiceMessenger } from './types';
 
 function setup({
@@ -45,8 +48,11 @@ function setup({
   providers: MockAccountProvider[];
   messenger: MultichainAccountServiceMessenger;
 } {
-  const providers = accounts.map((providerAccounts) => {
-    return setupNamedAccountProvider({ accounts: providerAccounts });
+  const providers = accounts.map((providerAccounts, idx) => {
+    return setupBip44AccountProvider({
+      name: `Provider ${idx + 1}`,
+      accounts: providerAccounts,
+    });
   });
 
   const serviceMessenger = getMultichainAccountServiceMessenger(messenger);
@@ -64,6 +70,18 @@ function setup({
     messenger: serviceMessenger,
   });
 
+  // Initialize group state from provided accounts so that constructor tests
+  // observe accounts immediately
+  const groupState = providers.reduce<GroupState>((state, provider, idx) => {
+    const ids = accounts[idx].filter(isBip44Account).map((a) => a.id);
+    if (ids.length > 0) {
+      state[provider.getName()] = ids;
+    }
+    return state;
+  }, {});
+
+  group.init(groupState);
+
   return { wallet, group, providers, messenger: serviceMessenger };
 }
 
@@ -88,6 +106,10 @@ describe('MultichainAccount', () => {
       expect(group.type).toBe(AccountGroupType.MultichainAccount);
       expect(group.groupIndex).toBe(groupIndex);
       expect(group.wallet).toStrictEqual(wallet);
+      expect(group.hasAccounts()).toBe(true);
+      expect(group.getAccountIds()).toStrictEqual(
+        expectedAccounts.map((a) => a.id),
+      );
       expect(group.getAccounts()).toHaveLength(expectedAccounts.length);
       expect(group.getAccounts()).toStrictEqual(expectedAccounts);
     });
@@ -160,62 +182,118 @@ describe('MultichainAccount', () => {
   });
 
   describe('alignAccounts', () => {
-    it('creates missing accounts only for providers with no accounts', async () => {
+    it('aligns accounts for all providers', async () => {
       const groupIndex = 0;
       const { group, providers, wallet } = setup({
         groupIndex,
-        accounts: [
-          [MOCK_WALLET_1_EVM_ACCOUNT], // provider[0] already has group 0
-          [], // provider[1] missing group 0
-        ],
+        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], []],
       });
 
+      mockCreateAccountsOnce(providers[0], [MOCK_WALLET_1_EVM_ACCOUNT]);
+      mockCreateAccountsOnce(providers[1], [MOCK_WALLET_1_SOL_ACCOUNT]);
+
       await group.alignAccounts();
 
-      expect(providers[0].createAccounts).not.toHaveBeenCalled();
+      expect(providers[0].createAccounts).toHaveBeenCalledWith({
+        entropySource: wallet.entropySource,
+        groupIndex,
+      });
       expect(providers[1].createAccounts).toHaveBeenCalledWith({
         entropySource: wallet.entropySource,
         groupIndex,
       });
+
+      expect(group.getAccounts()).toHaveLength(2);
+      expect(group.getAccounts()).toStrictEqual([
+        MOCK_WALLET_1_EVM_ACCOUNT,
+        MOCK_WALLET_1_SOL_ACCOUNT,
+      ]);
     });
 
-    it('does nothing when already aligned', async () => {
+    it('warns if alignment fails for a single provider', async () => {
       const groupIndex = 0;
-      const { group, providers } = setup({
+      const { group, providers, wallet } = setup({
         groupIndex,
-        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], [MOCK_WALLET_1_SOL_ACCOUNT]],
+        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], []],
       });
 
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      providers[1].createAccounts.mockRejectedValueOnce(
+        new Error('Unable to create accounts'),
+      );
+
       await group.alignAccounts();
 
-      expect(providers[0].createAccounts).not.toHaveBeenCalled();
-      expect(providers[1].createAccounts).not.toHaveBeenCalled();
+      expect(providers[1].createAccounts).toHaveBeenCalledWith({
+        entropySource: wallet.entropySource,
+        groupIndex,
+      });
+      expect(consoleSpy).toHaveBeenCalledWith(
+        `Failed to fully align multichain account group for entropy ID: ${wallet.entropySource} and group index: ${groupIndex}, some accounts might be missing. Provider threw the following error:\n- Provider 2: Unable to create accounts`,
+      );
     });
 
-    it('warns if provider alignment fails', async () => {
+    it('warns if alignment fails for multiple providers', async () => {
       const groupIndex = 0;
       const { group, providers, wallet } = setup({
         groupIndex,
-        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], []],
+        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], [], []],
       });
 
       const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
       providers[1].createAccounts.mockRejectedValueOnce(
         new Error('Unable to create accounts'),
       );
 
+      providers[2].createAccounts.mockRejectedValueOnce(
+        new Error('Unable to create accounts'),
+      );
+
       await group.alignAccounts();
 
-      expect(providers[0].createAccounts).not.toHaveBeenCalled();
       expect(providers[1].createAccounts).toHaveBeenCalledWith({
         entropySource: wallet.entropySource,
         groupIndex,
       });
+      expect(providers[2].createAccounts).toHaveBeenCalledWith({
+        entropySource: wallet.entropySource,
+        groupIndex,
+      });
       expect(consoleSpy).toHaveBeenCalledWith(
-        `Failed to fully align multichain account group for entropy ID: ${wallet.entropySource} and group index: ${groupIndex}, some accounts might be missing`,
+        `Failed to fully align multichain account group for entropy ID: ${wallet.entropySource} and group index: ${groupIndex}, some accounts might be missing. Providers threw the following errors:\n- Provider 2: Unable to create accounts\n- Provider 3: Unable to create accounts`,
       );
     });
 
+    it('does not create accounts when a provider is disabled', async () => {
+      const groupIndex = 0;
+      const { group, providers } = setup({
+        groupIndex,
+        accounts: [[], []],
+      });
+
+      providers[1].setEnabled(false);
+      await group.alignAccounts();
+
+      expect(providers[0].createAccounts).toHaveBeenCalled();
+      expect(providers[1].createAccounts).not.toHaveBeenCalled();
+    });
+
+    it('removes accounts from the group when a provider is disabled', async () => {
+      const groupIndex = 0;
+      const { group, providers } = setup({
+        groupIndex,
+        accounts: [[MOCK_WALLET_1_EVM_ACCOUNT], []],
+      });
+
+      providers[0].setEnabled(false);
+      await group.alignAccounts();
+
+      expect(providers[0].createAccounts).not.toHaveBeenCalled();
+      expect(providers[1].createAccounts).toHaveBeenCalled();
+
+      expect(group.getAccount(MOCK_WALLET_1_EVM_ACCOUNT.id)).toBeUndefined();
+    });
+
     it('captures an error when a provider fails to create its account', async () => {
       const groupIndex = 0;
       const { group, providers, messenger } = setup({
@@ -227,7 +305,7 @@ describe('MultichainAccount', () => {
       const captureExceptionSpy = jest.spyOn(messenger, 'captureException');
       await group.alignAccounts();
       expect(captureExceptionSpy).toHaveBeenCalledWith(
-        new Error('Unable to align accounts with provider "Mocked Provider"'),
+        new Error('Unable to align accounts with provider "Provider 2"'),
       );
       expect(captureExceptionSpy.mock.lastCall[0]).toHaveProperty(
         'cause',