Merge branch 'main' into feat/add-estimate-gas-fee-batch-tx

Author: vinistevam

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/core-monorepo",
-  "version": "430.0.0",
+  "version": "432.0.0",
   "private": true,
   "description": "Monorepo for packages shared between MetaMask clients",
   "repository": {

packages/account-tree-controller/src/AccountTreeController.ts

@@ -68,7 +68,7 @@ export type AccountWallet = {
   groups: {
     [groupId: AccountGroupId]: AccountGroup;
   };
-  metadata: AccountGroupMetadata; // Assuming Metadata is a defined type
+  metadata: AccountWalletMetadata;
 };
 
 export type AccountTreeControllerState = {

packages/assets-controllers/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Bump `@metamask/controller-utils` to `^11.10.0` ([#5935](https://github.com/MetaMask/core/pull/5935))
+- Add `getErc20Balances` function within `TokenBalancesController` to support fetching ERC-20 token balances for a given address and token list ([#5925](https://github.com/MetaMask/core/pull/5925))
+  - This modular service simplifies balance retrieval logic and can be reused across different parts of the controller
+
+### 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
@@ -18,6 +30,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Bump `@metamask/controller-utils` to `^11.10.0` ([#5935](https://github.com/MetaMask/core/pull/5935))
+- Add `getErc20Balances` function within `TokenBalancesController` to support fetching ERC-20 token balances for a given address and token list ([#5925](https://github.com/MetaMask/core/pull/5925))
+  - This modular service simplifies balance retrieval logic and can be reused across different parts of the controller
 
 ## [68.0.0]
 

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();
     }

packages/assets-controllers/src/TokenBalancesController.test.ts

@@ -832,4 +832,70 @@ describe('TokenBalancesController', () => {
       });
     });
   });
+
+  describe('getErc20Balances', () => {
+    const chainId = '0x1';
+    const account = '0x0000000000000000000000000000000000000000';
+    const tokenA = '0x00000000000000000000000000000000000000a1';
+    const tokenB = '0x00000000000000000000000000000000000000b2';
+
+    afterEach(() => {
+      // make sure spies do not leak between tests
+      jest.restoreAllMocks();
+    });
+
+    it('returns an **empty object** if no token addresses are provided', async () => {
+      const { controller } = setupController();
+      const balances = await controller.getErc20Balances({
+        chainId,
+        accountAddress: account,
+        tokenAddresses: [],
+      });
+
+      expect(balances).toStrictEqual({});
+    });
+
+    it('maps **each address to a hex balance** on success', async () => {
+      const bal1 = 42;
+      const bal2 = 0;
+
+      jest.spyOn(multicall, 'multicallOrFallback').mockResolvedValueOnce([
+        { success: true, value: new BN(bal1) },
+        { success: true, value: new BN(bal2) },
+      ]);
+
+      const { controller } = setupController();
+
+      const balances = await controller.getErc20Balances({
+        chainId,
+        accountAddress: account,
+        tokenAddresses: [tokenA, tokenB],
+      });
+
+      expect(balances).toStrictEqual({
+        [tokenA]: toHex(bal1),
+        [tokenB]: toHex(bal2), // zero balance is still a success
+      });
+    });
+
+    it('returns **null** for tokens whose `balanceOf` call failed', async () => {
+      jest.spyOn(multicall, 'multicallOrFallback').mockResolvedValueOnce([
+        { success: false, value: null },
+        { success: true, value: new BN(7) },
+      ]);
+
+      const { controller } = setupController();
+
+      const balances = await controller.getErc20Balances({
+        chainId,
+        accountAddress: account,
+        tokenAddresses: [tokenA, tokenB],
+      });
+
+      expect(balances).toStrictEqual({
+        [tokenA]: null, // failed call
+        [tokenB]: toHex(7), // succeeded call
+      });
+    });
+  });
 });

packages/assets-controllers/src/TokenBalancesController.ts

@@ -411,6 +411,86 @@ export class TokenBalancesController extends StaticIntervalPollingController<Tok
     }
   }
 
+  /**
+   * Get an Ethers.js Web3Provider for the requested chain.
+   *
+   * @param chainId - The chain id to get the provider for.
+   * @returns The provider for the given chain id.
+   */
+  #getProvider(chainId: Hex): Web3Provider {
+    return new Web3Provider(this.#getNetworkClient(chainId).provider);
+  }
+
+  /**
+   * Internal util: run `balanceOf` for an arbitrary set of account/token pairs.
+   *
+   * @param params - The parameters for the balance fetch.
+   * @param params.chainId - The chain id to fetch balances on.
+   * @param params.pairs - The account/token pairs to fetch balances for.
+   * @returns The balances for the given token addresses.
+   */
+  async #batchBalanceOf({
+    chainId,
+    pairs,
+  }: {
+    chainId: Hex;
+    pairs: { accountAddress: Hex; tokenAddress: Hex }[];
+  }): Promise<MulticallResult[]> {
+    if (!pairs.length) {
+      return [];
+    }
+
+    const provider = this.#getProvider(chainId);
+
+    const calls = pairs.map(({ accountAddress, tokenAddress }) => ({
+      contract: new Contract(tokenAddress, abiERC20, provider),
+      functionSignature: 'balanceOf(address)',
+      arguments: [accountAddress],
+    }));
+
+    return multicallOrFallback(calls, chainId, provider);
+  }
+
+  /**
+   * Returns ERC-20 balances for a single account on a single chain.
+   *
+   * @param params - The parameters for the balance fetch.
+   * @param params.chainId - The chain id to fetch balances on.
+   * @param params.accountAddress - The account address to fetch balances for.
+   * @param params.tokenAddresses - The token addresses to fetch balances for.
+   * @returns A mapping from token address to balance (hex) | null.
+   */
+  async getErc20Balances({
+    chainId,
+    accountAddress,
+    tokenAddresses,
+  }: {
+    chainId: Hex;
+    accountAddress: Hex;
+    tokenAddresses: Hex[];
+  }): Promise<Record<Hex, Hex | null>> {
+    // Return early if no token addresses provided
+    if (tokenAddresses.length === 0) {
+      return {};
+    }
+
+    const pairs = tokenAddresses.map((tokenAddress) => ({
+      accountAddress,
+      tokenAddress,
+    }));
+
+    const results = await this.#batchBalanceOf({ chainId, pairs });
+
+    const balances: Record<Hex, Hex | null> = {};
+    tokenAddresses.forEach((tokenAddress, i) => {
+      balances[tokenAddress] = results[i]?.success
+        ? toHex(results[i].value as BN)
+        : null;
+    });
+
+    return balances;
+  }
+
   /**
    * Updates token balances for the given chain id.
    * @param input - The input for the update.
@@ -448,19 +528,10 @@ export class TokenBalancesController extends StaticIntervalPollingController<Tok
     );
 
     if (accountTokenPairs.length > 0) {
-      const provider = new Web3Provider(
-        this.#getNetworkClient(chainId).provider,
-      );
-
-      const calls = accountTokenPairs.map(
-        ({ accountAddress, tokenAddress }) => ({
-          contract: new Contract(tokenAddress, abiERC20, provider),
-          functionSignature: 'balanceOf(address)',
-          arguments: [accountAddress],
-        }),
-      );
-
-      results = await multicallOrFallback(calls, chainId, provider);
+      results = await this.#batchBalanceOf({
+        chainId,
+        pairs: accountTokenPairs,
+      });
     }
 
     const updatedResults: (MulticallResult & {

packages/notification-services-controller/package.json

@@ -123,7 +123,7 @@
     "@lavamoat/preinstall-always-fail": "^2.1.0",
     "@metamask/auto-changelog": "^3.4.4",
     "@metamask/keyring-controller": "^22.0.2",
-    "@metamask/profile-sync-controller": "^17.0.0",
+    "@metamask/profile-sync-controller": "^17.1.0",
     "@types/jest": "^27.4.1",
     "@types/readable-stream": "^2.3.0",
     "contentful": "^10.15.0",

packages/profile-sync-controller/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [17.1.0]
+
+### Added
+
+- Add `EventQueue` class util to guarantee the order of some user-storage updates ([#5937](https://github.com/MetaMask/core/pull/5937))
+  - Add an instance of `EventQueue` to `UserStorageController`
+  - Event subscriptions for `AccountsController:accountAdded` and `AccountsController:accountRenamed` are now pushing their callbacks to the `UserStorageController` instance of `EventQueue`, so that we stay in control of the order these callbacks are fulfilled.
+
 ## [17.0.0]
 
 ### Added
@@ -614,7 +622,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/[email protected]
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/[email protected]
+[17.1.0]: https://github.com/MetaMask/core/compare/@metamask/[email protected]...@metamask/[email protected]
 [17.0.0]: https://github.com/MetaMask/core/compare/@metamask/[email protected]...@metamask/[email protected]
 [16.0.0]: https://github.com/MetaMask/core/compare/@metamask/[email protected]...@metamask/[email protected]
 [15.0.0]: https://github.com/MetaMask/core/compare/@metamask/[email protected]...@metamask/[email protected]

packages/profile-sync-controller/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/profile-sync-controller",
-  "version": "17.0.0",
+  "version": "17.1.0",
   "description": "The profile sync helps developers synchronize data across multiple clients and devices in a privacy-preserving way. All data saved in the user storage database is encrypted client-side to preserve privacy. The user storage provides a modular design, giving developers the flexibility to construct and manage their storage spaces in a way that best suits their needs",
   "keywords": [
     "MetaMask",