fix: Checksum EVM addresses in the address list (#38539)

## **Description**


1. What is the reason for the change?
The EVM address on the address list page was not checksummed while it
was on on the home page. This is important for users so that their
addresses match what they see in the ecosystem.
2. What is the improvement/solution?
Call the following formatting function.

```ts
/**
 * Normalize an address to a "safer" representation. The address might be returned as-is, if
 * there's no normalizer available.
 *
 * @param address - An address to normalize.
 * @returns The "safer" normalized address.
 */
export function normalizeSafeAddress(address: string): string {
  // NOTE: We assume that the overhead over checking the address format
  // at runtime is small
  return isEthAddress(address) ? toChecksumHexAddress(address) : address;
}
```



[![Open in GitHub
Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/MetaMask/metamask-extension/pull/38539?quickstart=1)

## **Changelog**

<!--
If this PR is not End-User-Facing and should not show up in the
CHANGELOG, you can choose to either:
1. Write `CHANGELOG entry: null`
2. Label with `no-changelog`

If this PR is End-User-Facing, please write a short User-Facing
description in the past tense like:
`CHANGELOG entry: Added a new tab for users to see their NFTs`
`CHANGELOG entry: Fixed a bug that was causing some NFTs to flicker`

(This helps the Release Engineer do their job more quickly and
accurately)
-->

CHANGELOG entry: Fixed bug where the EVM addresses were not checksummed

## **Related issues**

Fixes: https://consensyssoftware.atlassian.net/browse/MUL-1325

## **Manual testing steps**

1. Create/impor a wallet
2. hover address list via the network icons below the account name
3. notice the address for ETH
4. click view all
5. you will be taken to the address list
6. verify that the addresses for the EVm networks are checksummed
7. verify that copying the address results in a checksummed address
8. verify that the qr code is checksummed
9. verify that the non evm addresses are NOT checksummed

## **Screenshots/Recordings**

### **Before**

<img width="405" height="625" alt="Screenshot 2025-12-03 at 11 54 18 PM"
src="https://github.com/user-attachments/assets/815cf104-55d5-4922-83cc-a0ed521874a6"
/>

<img width="413" height="624" alt="Screenshot 2025-12-03 at 11 54 24 PM"
src="https://github.com/user-attachments/assets/d597d6a3-a3dc-4968-8e7d-8b18dc9c6db4"
/>


### **After**

<img width="425" height="633" alt="Screenshot 2025-12-03 at 8 10 56 PM"
src="https://github.com/user-attachments/assets/2f5dccf2-3c78-41c2-a9aa-e0ee150e7516"
/>

<img width="414" height="621" alt="Screenshot 2025-12-03 at 8 10 48 PM"
src="https://github.com/user-attachments/assets/152123c8-3691-4add-8616-1b8e7cdef993"
/>

<img width="447" height="630" alt="Screenshot 2025-12-03 at 8 11 24 PM"
src="https://github.com/user-attachments/assets/b213f18d-315b-418d-aa05-03c0c392ccd6"
/>




https://github.com/user-attachments/assets/9cef5a93-4e0f-4de9-880a-744eaaa3465a



## **Pre-merge author checklist**

- [ ] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask
Extension Coding
Standards](https://github.com/MetaMask/metamask-extension/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [ ] I've completed the PR template to the best of my ability
- [ ] I’ve included tests if applicable
- [ ] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [ ] I’ve applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-extension/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.



<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Checksums EVM addresses for display, copy, and search in the
multichain address list while preserving non‑EVM formats, with
accompanying tests.
> 
> - **UI**
> - Use `normalizeSafeAddress` to provide a normalized `address` for
`MultichainAddressRow` and for copy actions.
> - Search now matches against `normalizedAddress` in addition to
network name.
> - Memoize `normalizedAddress` per item and render list using the
normalized values.
>   - Generalize `sortByPriorityNetworks` with a generic type.
> - **Tests**
> - Add tests verifying EVM addresses are checksummed for display/copy
and searchable by checksummed form.
>   - Confirm non‑EVM addresses (e.g., Bitcoin) remain unchanged.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
221ffd6. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: owencraston

ui/components/multichain-accounts/multichain-address-rows-list/multichain-address-rows-list.test.tsx

@@ -578,4 +578,152 @@ describe('MultichainAddressRowsList', () => {
       }
     });
   });
+
+  describe('Address formatting', () => {
+    it('formats addresses to checksum format for display and copy', async () => {
+      // Create a state with a lowercase EVM address that needs formatting
+      const lowercaseAddress = '0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed';
+
+      const customState = createMockState();
+      const customAccountId = 'test-account-lowercase';
+
+      // Add an account with a lowercase address
+      customState.metamask.internalAccounts.accounts[customAccountId] = {
+        id: customAccountId,
+        address: lowercaseAddress,
+        metadata: {
+          name: 'Test Account',
+          importTime: Date.now(),
+          keyring: { type: 'HD Key Tree' },
+        },
+        options: {},
+        methods: [],
+        type: 'eip155:eoa',
+        scopes: ['eip155:0'],
+      };
+
+      const customGroupId = `${WALLET_ID_MOCK}/test-group`;
+      (
+        customState.metamask.accountTree.wallets[WALLET_ID_MOCK]
+          .groups as Record<string, unknown>
+      )[customGroupId] = {
+        type: 'multichain-account',
+        id: customGroupId,
+        metadata: {},
+        accounts: [customAccountId],
+      };
+
+      const store = mockStore(customState);
+      render(
+        <Provider store={store}>
+          <MultichainAddressRowsList
+            groupId={customGroupId as AccountGroupId}
+            onQrClick={jest.fn()}
+          />
+        </Provider>,
+      );
+
+      // Find the address text element
+      const addressElements = screen.getAllByTestId(
+        'multichain-address-row-address',
+      );
+
+      // The displayed address should be shortened, but when we copy, it should be the full checksum
+      // We can't directly test the full address since it's shortened, but we can test the copy functionality
+      const copyButton = screen.getAllByTestId(
+        'multichain-address-row-copy-button',
+      )[0];
+
+      // Mock clipboard
+      Object.assign(navigator, {
+        clipboard: {
+          writeText: jest.fn().mockImplementation(() => Promise.resolve()),
+        },
+      });
+
+      fireEvent.click(copyButton);
+
+      // The useCopyToClipboard hook should have been called with the checksummed address
+      // Note: We can verify this indirectly by checking that the component renders without errors
+      // and the copy success state is shown
+      expect(addressElements[0]).toHaveTextContent(/copied|0x5a/iu);
+    });
+
+    it('searches using formatted addresses', () => {
+      // Create a state with a lowercase EVM address
+      const lowercaseAddress = '0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed';
+
+      const customState = createMockState();
+      const customAccountId = 'test-account-search';
+
+      customState.metamask.internalAccounts.accounts[customAccountId] = {
+        id: customAccountId,
+        address: lowercaseAddress,
+        metadata: {
+          name: 'Search Test Account',
+          importTime: Date.now(),
+          keyring: { type: 'HD Key Tree' },
+        },
+        options: {},
+        methods: [],
+        type: 'eip155:eoa',
+        scopes: ['eip155:0'],
+      };
+
+      const customGroupId = `${WALLET_ID_MOCK}/search-group`;
+      (
+        customState.metamask.accountTree.wallets[WALLET_ID_MOCK]
+          .groups as Record<string, unknown>
+      )[customGroupId] = {
+        type: 'multichain-account',
+        id: customGroupId,
+        metadata: {},
+        accounts: [customAccountId],
+      };
+
+      const store = mockStore(customState);
+      render(
+        <Provider store={store}>
+          <MultichainAddressRowsList
+            groupId={customGroupId as AccountGroupId}
+            onQrClick={jest.fn()}
+          />
+        </Provider>,
+      );
+
+      const searchInput = screen
+        .getByTestId('multichain-address-rows-list-search')
+        .querySelector('input') as HTMLInputElement;
+
+      // Search for the checksummed version - should find the address even though it was stored lowercase
+      fireEvent.change(searchInput, { target: { value: '0x5aAeb' } });
+
+      const addressRows = screen.queryAllByTestId('multichain-address-row');
+      expect(addressRows.length).toBeGreaterThan(0);
+    });
+
+    it('preserves non-EVM addresses as-is', () => {
+      renderComponent();
+
+      // Find Bitcoin and Solana addresses
+      const addressElements = screen.getAllByTestId(
+        'multichain-address-row-address',
+      );
+      const networkNames = screen.getAllByTestId(
+        'multichain-address-row-network-name',
+      );
+
+      // Find the Bitcoin row
+      const bitcoinIndex = Array.from(networkNames).findIndex(
+        (el) => el.textContent === 'Bitcoin',
+      );
+
+      if (bitcoinIndex !== -1) {
+        // Bitcoin address should be preserved as-is (not checksummed)
+        const bitcoinAddressElement = addressElements[bitcoinIndex];
+        // The element should contain part of the Bitcoin address (shortened)
+        expect(bitcoinAddressElement.textContent).toMatch(/bc1q/u);
+      }
+    });
+  });
 });

ui/components/multichain-accounts/multichain-address-rows-list/multichain-address-rows-list.tsx

@@ -23,6 +23,8 @@ import {
 import { useCopyToClipboard } from '../../../hooks/useCopyToClipboard';
 import { MultichainAddressRow } from '../multichain-address-row/multichain-address-row';
 import { getInternalAccountListSpreadByScopesByGroupId } from '../../../selectors/multichain-accounts/account-tree';
+// eslint-disable-next-line import/no-restricted-paths
+import { normalizeSafeAddress } from '../../../../app/scripts/lib/multichain/address';
 
 // Priority networks that should appear first (using CAIP chain IDs)
 const PRIORITY_CHAIN_IDS: CaipChainId[] = [
@@ -62,9 +64,9 @@ export const MultichainAddressRowsList = ({
   );
 
   const sortByPriorityNetworks = useCallback(
-    (items: typeof getAccountsSpreadByNetworkByGroupId) => {
-      const priorityItems: typeof items = [];
-      const otherItems: typeof items = [];
+    <ItemType extends { scope: CaipChainId }>(items: ItemType[]) => {
+      const priorityItems: ItemType[] = [];
+      const otherItems: ItemType[] = [];
 
       items.forEach((item) => {
         const priorityIndex = PRIORITY_CHAIN_IDS.findIndex(
@@ -85,27 +87,31 @@ export const MultichainAddressRowsList = ({
     [],
   );
 
+  // Normalize addresses once for all items for performance
+  const itemsWithNormalizedAddresses = useMemo(() => {
+    return getAccountsSpreadByNetworkByGroupId.map((item) => ({
+      ...item,
+      normalizedAddress: normalizeSafeAddress(item.account.address),
+    }));
+  }, [getAccountsSpreadByNetworkByGroupId]);
+
   const filteredItems = useMemo(() => {
-    let items = getAccountsSpreadByNetworkByGroupId;
+    let items = itemsWithNormalizedAddresses;
 
     // Apply search filter if there's a search pattern
     if (searchPattern.trim()) {
       const pattern = searchPattern.toLowerCase();
-      items = items.filter(({ networkName, account }) => {
+      items = items.filter(({ networkName, normalizedAddress }) => {
         return (
           networkName.toLowerCase().includes(pattern) ||
-          account.address.toLowerCase().includes(pattern)
+          normalizedAddress.toLowerCase().includes(pattern)
         );
       });
     }
 
     // Sort by priority networks
     return sortByPriorityNetworks(items);
-  }, [
-    getAccountsSpreadByNetworkByGroupId,
-    searchPattern,
-    sortByPriorityNetworks,
-  ]);
+  }, [itemsWithNormalizedAddresses, searchPattern, sortByPriorityNetworks]);
 
   const handleSearchChange = (event: React.ChangeEvent<HTMLInputElement>) => {
     setSearchPattern(event.target.value);
@@ -121,19 +127,20 @@ export const MultichainAddressRowsList = ({
         scope: CaipChainId;
         account: InternalAccount;
         networkName: string;
+        normalizedAddress: string;
       },
       index: number,
     ): React.JSX.Element => {
       const handleCopyClick = () => {
-        handleCopy(item.account.address);
+        handleCopy(item.normalizedAddress);
       };
 
       return (
         <MultichainAddressRow
           key={`${item.account.address}-${item.scope}-${index}`}
           chainId={item.scope}
           networkName={item.networkName}
-          address={item.account.address}
+          address={item.normalizedAddress}
           copyActionParams={{
             message: t('multichainAccountAddressCopied'),
             callback: handleCopyClick,