chore(runway): cherry-pick fix: cp-7.58.0 update swap asset balance on switch (#21631)

- fix: cp-7.58.0 update swap asset balance on switch  (#21625)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**

Fix an issue where asset balances were not recalculated after users
switch assets on swaps and added appropriate unit tests

<!--
Write a short description of the changes included in this pull request,
also include relevant motivation and context. Have in mind the following
questions:
1. What is the reason for the change?
2. What is the improvement/solution?
-->

## **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: null

## **Related issues**

Fixes: null

## **Manual testing steps**

```gherkin
Feature: my feature name

  Scenario: user [verb for user action]
    Given [describe expected initial app state]

    When user [verb for user action]
    Then [describe expected outcome]
```

## **Screenshots/Recordings**

<!-- If applicable, add screenshots and/or recordings to visualize the
before and after of your change. -->

### **Before**

<!-- [screenshots/recordings] -->

### **After**

<!-- [screenshots/recordings] -->

## **Pre-merge author checklist**

- [x] I’ve followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding

Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [x] I've completed the PR template to the best of my ability
- [x] I’ve included tests if applicable
- [x] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [x] I’ve applied the right labels on the PR (see [labeling

guidelines](https://github.com/MetaMask/metamask-mobile/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]
> Ensure cached balance updates when token address changes and add unit
tests covering memoization and balance parsing edge cases.
> 
> - **Bridge > useLatestBalance**:
> - Include `token.address` in `useMemo` deps for `cachedBalance` to
refresh cache on token switch (with explanatory comments).
> - **Tests** (`useLatestBalance.test.tsx`):
>   - Add suite for cached balance memoization and parsing:
> - Validates memoization when deps unchanged and refresh on address
change.
> - Handles missing `decimals`, zero balance, very large/small balances.
> - Confirms behavior when `balance` present but `decimals` missing and
general parsing robustness.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
d770d6c. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->


[9e43877](9e43877)

Co-authored-by: George Gkasdrogkas <[email protected]>

Author: runway-github[bot]

app/components/UI/Bridge/hooks/useLatestBalance/index.ts

@@ -176,7 +176,10 @@ export const useLatestBalance = (token: {
     }
 
     return { displayBalance, atomicBalance };
-  }, [token.balance, token.decimals]);
+    // Include token.address in the dependency array to ensure
+    // that the cached balance is updated when the token address changes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [token.balance, token.decimals, token.address]);
 
   if (!token.address || !token.decimals) {
     return undefined;

app/components/UI/Bridge/hooks/useLatestBalance/useLatestBalance.test.tsx

@@ -526,4 +526,139 @@ describe('useLatestBalance', () => {
       });
     });
   });
+
+  describe('cachedBalance memoization', () => {
+    it('returns undefined when decimals is missing during balance parsing', () => {
+      const { result } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: undefined,
+            chainId: '0x1' as Hex,
+            balance: '10.0',
+          }),
+        { state: initialState },
+      );
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('memoizes cached balance when dependencies do not change', () => {
+      const { result, rerender } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: 18,
+            chainId: '0x1' as Hex,
+            balance: '5.5',
+          }),
+        { state: initialState },
+      );
+
+      const firstResult = result.current;
+      rerender({ state: initialState });
+
+      expect(result.current).toBe(firstResult);
+    });
+
+    it('returns cached balance when token address changes', () => {
+      const firstToken = {
+        address: '0x1234567890123456789012345678901234567890',
+        decimals: 18,
+        chainId: '0x1' as Hex,
+        balance: '5.5',
+      };
+
+      const { result: firstResult } = renderHookWithProvider(
+        () => useLatestBalance(firstToken),
+        { state: initialState },
+      );
+
+      expect(firstResult.current?.displayBalance).toBe('5.5');
+
+      const secondToken = {
+        address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        decimals: 18,
+        chainId: '0x1' as Hex,
+        balance: '10.0',
+      };
+
+      const { result: secondResult } = renderHookWithProvider(
+        () => useLatestBalance(secondToken),
+        { state: initialState },
+      );
+
+      expect(secondResult.current?.displayBalance).toBe('10.0');
+      expect(secondResult.current).not.toBe(firstResult.current);
+    });
+
+    it('returns undefined when balance is provided but decimals is missing', () => {
+      const { result } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: undefined,
+            chainId: '0x1' as Hex,
+            balance: '100.0',
+          }),
+        { state: initialState },
+      );
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('handles zero balance correctly', () => {
+      const { result } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: 18,
+            chainId: '0x1' as Hex,
+            balance: '0',
+          }),
+        { state: initialState },
+      );
+
+      expect(result.current).toEqual({
+        displayBalance: '0',
+        atomicBalance: BigNumber.from('0'),
+      });
+    });
+
+    it('handles very large balance values', () => {
+      const { result } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: 18,
+            chainId: '0x1' as Hex,
+            balance: '999999999999999999999999.123456789012345678',
+          }),
+        { state: initialState },
+      );
+
+      expect(result.current?.displayBalance).toBe(
+        '999999999999999999999999.123456789012345678',
+      );
+      expect(result.current?.atomicBalance).toBeDefined();
+    });
+
+    it('handles very small decimal balance values', () => {
+      const { result } = renderHookWithProvider(
+        () =>
+          useLatestBalance({
+            address: '0x1234567890123456789012345678901234567890',
+            decimals: 18,
+            chainId: '0x1' as Hex,
+            balance: '0.000000000000000001',
+          }),
+        { state: initialState },
+      );
+
+      expect(result.current).toEqual({
+        displayBalance: '0.000000000000000001',
+        atomicBalance: BigNumber.from('1'),
+      });
+    });
+  });
 });