fix/account-tracker-prevent-empty-state-update (#5942)

## Explanation

This change prevents AccountTrackerController from overwriting cached
balances with empty or unchanged state during refresh operations.

Currently, if all balance requests for a chain fail or return undefined
(e.g., due to a temporary network issue), the controller updates the
state with an empty object, erasing previous data. Additionally, even
when the new balance data is identical to the current state, an update
is still triggered, resulting in unnecessary stateChange emissions and
potential UI re-renders.

This update introduces guards within the refresh method to:

- Skip updates if the computed accountsForChain object is empty.
- Skip updates if the resulting balances are identical to the current
state.
- Prevent stale or partial data from overriding valid cached values.
- Reduce unnecessary re-renders and state emissions.

These changes help improve performance and stability, particularly under
poor network conditions or when balance polling is frequent.

<!--
Thanks for your contribution! Take a moment to answer these questions so
that reviewers have the information they need to properly understand
your changes:

* What is the current state of things and why does it need to change?
* What is the solution your changes offer and how does it work?
* Are there any changes whose purpose might not obvious to those
unfamiliar with the domain?
* If your primary goal was to update one package but you found you had
to update another one along the way, why did you do so?
* If you had to upgrade a dependency, why did you do so?
-->

## References

* Fixes
[#15472](MetaMask/metamask-mobile#15472)
<!--
Are there any issues that this pull request is tied to?
Are there other links that reviewers should consult to understand these
changes better?
Are there client or consumer pull requests to adopt any breaking
changes?

For example:

* Fixes #12345
* Related to #67890
-->

## Changelog

<!--
THIS SECTION IS NO LONGER NEEDED.

The process for updating changelogs has changed. Please consult the
"Updating changelogs" section of the Contributing doc for more.
-->

### `@metamask/assets-controllers`

UPDATE: Prevent AccountTrackerController from updating state with empty
or unchanged data during balance refresh. Adds checks to avoid
overwriting valid cached balances and reduce unnecessary stateChange
emissions.

## Checklist

- [x] I've updated the test suite for new or updated code as appropriate
- [ ] I've updated documentation (JSDoc, Markdown, etc.) for new or
updated code as appropriate
- [ ] 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
- [ ] I've prepared draft pull requests for clients and consumer
packages to resolve any breaking changes

Author: salimtb

packages/assets-controllers/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Prevented `AccountTrackerController` from updating state with empty or unchanged account balance data during refresh ([#5942](https://github.com/MetaMask/core/pull/5942))
+  - Added guards to skip state updates when fetched balances are empty or identical to existing state
+  - Reduces unnecessary `stateChange` emissions and preserves previously-cached balances under network failure scenarios
+
 ## [68.1.0]
 
 ### Added

packages/assets-controllers/src/AccountTrackerController.ts

@@ -24,7 +24,7 @@ import { StaticIntervalPollingController } from '@metamask/polling-controller';
 import type { PreferencesControllerGetStateAction } from '@metamask/preferences-controller';
 import { assert } from '@metamask/utils';
 import { Mutex } from 'async-mutex';
-import { cloneDeep } from 'lodash';
+import { cloneDeep, isEqual } from 'lodash';
 
 import type {
   AssetsContractController,
@@ -193,13 +193,18 @@ export class AccountTrackerController extends StaticIntervalPollingController<Ac
 
     this.messagingSystem.subscribe(
       'AccountsController:selectedEvmAccountChange',
-      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      () => this.refresh(this.#getNetworkClientIds()),
+      (newAddress, prevAddress) => {
+        if (newAddress !== prevAddress) {
+          // Making an async call for this new event
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+          this.refresh(this.#getNetworkClientIds());
+        }
+      },
+      (event): string => event.address,
     );
   }
 
-  private syncAccounts(newChainId: string) {
+  private syncAccounts(newChainIds: string[]) {
     const accountsByChainId = cloneDeep(this.state.accountsByChainId);
     const { selectedNetworkClientId } = this.messagingSystem.call(
       'NetworkController:getState',
@@ -213,12 +218,15 @@ export class AccountTrackerController extends StaticIntervalPollingController<Ac
 
     const existing = Object.keys(accountsByChainId?.[currentChainId] ?? {});
 
-    if (!accountsByChainId[newChainId]) {
-      accountsByChainId[newChainId] = {};
-      existing.forEach((address) => {
-        accountsByChainId[newChainId][address] = { balance: '0x0' };
-      });
-    }
+    // Initialize new chain IDs if they don't exist
+    newChainIds.forEach((newChainId) => {
+      if (!accountsByChainId[newChainId]) {
+        accountsByChainId[newChainId] = {};
+        existing.forEach((address) => {
+          accountsByChainId[newChainId][address] = { balance: '0x0' };
+        });
+      }
+    });
 
     // Note: The address from the preferences controller are checksummed
     // The addresses from the accounts controller are lowercased
@@ -249,9 +257,11 @@ export class AccountTrackerController extends StaticIntervalPollingController<Ac
       });
     });
 
-    this.update((state) => {
-      state.accountsByChainId = accountsByChainId;
-    });
+    if (!isEqual(this.state.accountsByChainId, accountsByChainId)) {
+      this.update((state) => {
+        state.accountsByChainId = accountsByChainId;
+      });
+    }
   }
 
   /**
@@ -327,11 +337,17 @@ export class AccountTrackerController extends StaticIntervalPollingController<Ac
     );
     const releaseLock = await this.#refreshMutex.acquire();
     try {
+      const chainIds = networkClientIds.map((networkClientId) => {
+        const { chainId } = this.#getCorrectNetworkClient(networkClientId);
+        return chainId;
+      });
+
+      this.syncAccounts(chainIds);
+
       // Create an array of promises for each networkClientId
       const updatePromises = networkClientIds.map(async (networkClientId) => {
         const { chainId, ethQuery } =
           this.#getCorrectNetworkClient(networkClientId);
-        this.syncAccounts(chainId);
         const { accountsByChainId } = this.state;
         const { isMultiAccountBalancesEnabled } = this.messagingSystem.call(
           'PreferencesController:getState',
@@ -394,15 +410,28 @@ export class AccountTrackerController extends StaticIntervalPollingController<Ac
       // Wait for all networkClientId updates to settle in parallel
       const allResults = await Promise.allSettled(updatePromises);
 
-      // Update the state once all networkClientId updates are completed
+      // Build a _copy_ of the current state and track whether anything changed
+      const nextAccountsByChainId: AccountTrackerControllerState['accountsByChainId'] =
+        cloneDeep(this.state.accountsByChainId);
+      let hasChanges = false;
+
       allResults.forEach((result) => {
         if (result.status === 'fulfilled') {
           const { chainId, accountsForChain } = result.value;
-          this.update((state) => {
-            state.accountsByChainId[chainId] = accountsForChain;
-          });
+          // Only mark as changed if the incoming data differs
+          if (!isEqual(nextAccountsByChainId[chainId], accountsForChain)) {
+            nextAccountsByChainId[chainId] = accountsForChain;
+            hasChanges = true;
+          }
         }
       });
+
+      // 👇🏻 call `update` only when something is new / different
+      if (hasChanges) {
+        this.update((state) => {
+          state.accountsByChainId = nextAccountsByChainId;
+        });
+      }
     } finally {
       releaseLock();
     }