fix: update required assets correctly for money account deposits (#29806)

<!--
Please submit this PR as a draft initially.

Do not mark it as "Ready for review" until this PR meets the canonical
Definition of Ready For Review in `docs/readme/ready-for-review.md`.

In short: the template must be materially complete (not just section
titles
present), all status checks must be currently passing, and the only
expected
follow-up commits must be reviewer-driven.
-->

## **Description**

Fix money account deposits by setting correst required asset in
transaction.

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

## **Related issues**

Ref: https://consensyssoftware.atlassian.net/browse/CONF-1324

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

## **Pre-merge author checklist**

<!--
Every checklist item must be consciously assessed before marking this PR
as
"Ready for review". A checked box means you deliberately considered that
responsibility, not that you literally performed every action listed.

Unchecked boxes are ambiguous: they are not an implicit "N/A" and they
are not
a silent "skip". See `docs/readme/ready-for-review.md` for the full
checklist
semantics.
-->

- [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.

#### Performance checks (if applicable)

- [ ] I've tested on Android
  - Ideally on a mid-range device; emulator is acceptable
- [ ] I've tested with a power user scenario
- Use these [power-user
SRPs](https://consensyssoftware.atlassian.net/wiki/spaces/TL1/pages/edit-v2/401401446401?draftShareId=9d77e1e1-4bdc-4be1-9ebb-ccd916988d93)
to import wallets with many accounts and tokens
- [ ] I've instrumented key operations with Sentry traces for production
performance metrics
- See [`trace()`](/app/util/trace.ts) for usage and
[`addToken`](/app/components/Views/AddAsset/components/AddCustomToken/AddCustomToken.tsx#L274)
for an example

For performance guidelines and tooling, see the [Performance
Guide](https://consensyssoftware.atlassian.net/wiki/spaces/TL1/pages/400085549067/Performance+Guide+for+Engineers).

## **Pre-merge reviewer checklist**

<!--
Reviewer checklist items follow the same semantics as the author
checklist: an
unchecked box is ambiguous, a checked box means the reviewer consciously
assessed that responsibility. See `docs/readme/ready-for-review.md`.
-->

- [ ] 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]
> **Medium Risk**
> Touches transaction amount update flow for `moneyAccountDeposit`,
including writing `requiredAssets` via `updateTransaction`, which could
affect what token/amount is used for deposits if decimals or asset
ordering are wrong.
> 
> **Overview**
> Fixes Money Account deposit pay-amount updates by **syncing
`transactionMeta.requiredAssets[0].amount`** to the user-entered amount
(converted to atomic units using required-token decimals, rounded up,
and hex-encoded) before applying nested transaction updates.
> 
> Also updates `getTokenAddress` to **prefer
`requiredAssets[0].address`** when no ERC-20 transfer call is detected,
and adds/expands unit tests covering the new required-asset sync and
address selection behavior.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
c14d618. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: jpuri

app/components/Views/confirmations/hooks/pay/useUpdateTransactionPayAmount.test.ts

@@ -4,7 +4,10 @@ import { useUpdateTransactionPayAmount } from './useUpdateTransactionPayAmount';
 import { simpleSendTransactionControllerMock } from '../../__mocks__/controllers/transaction-controller-mock';
 import { transactionApprovalControllerMock } from '../../__mocks__/controllers/approval-controller-mock';
 import { otherControllersMock } from '../../__mocks__/controllers/other-controllers-mock';
-import { updateAtomicBatchData } from '../../../../../util/transaction-controller';
+import {
+  updateAtomicBatchData,
+  updateTransaction,
+} from '../../../../../util/transaction-controller';
 import {
   updateMoneyAccountDepositTokenAmount,
   updateMoneyAccountWithdrawTokenAmount,
@@ -15,11 +18,15 @@ import {
 } from '@metamask/transaction-controller';
 import { useUpdateTokenAmount } from '../transactions/useUpdateTokenAmount';
 import Logger from '../../../../../util/Logger';
+import { useTransactionPayRequiredTokens } from './useTransactionPayData';
+import { TransactionPayRequiredToken } from '@metamask/transaction-pay-controller';
+import { Hex } from '@metamask/utils';
 
 jest.mock('../../../../../util/transaction-controller');
 jest.mock('../../../../UI/Money/utils/moneyAccountTransactions');
 jest.mock('../transactions/useUpdateTokenAmount');
 jest.mock('../../../../../util/Logger');
+jest.mock('./useTransactionPayData');
 
 const moneyAccountDepositMeta: Partial<TransactionMeta> = {
   type: TransactionType.moneyAccountDeposit,
@@ -57,13 +64,17 @@ function runHook({
 
 describe('useUpdateTransactionPayAmount', () => {
   const updateAtomicBatchDataMock = jest.mocked(updateAtomicBatchData);
+  const updateTransactionMock = jest.mocked(updateTransaction);
   const updateMoneyAccountDepositTokenAmountMock = jest.mocked(
     updateMoneyAccountDepositTokenAmount,
   );
   const updateMoneyAccountWithdrawTokenAmountMock = jest.mocked(
     updateMoneyAccountWithdrawTokenAmount,
   );
   const useUpdateTokenAmountMock = jest.mocked(useUpdateTokenAmount);
+  const useTransactionPayRequiredTokensMock = jest.mocked(
+    useTransactionPayRequiredTokens,
+  );
   const updateTokenAmountMock = jest.fn();
   const loggerErrorMock = jest.mocked(Logger.error);
 
@@ -73,6 +84,7 @@ describe('useUpdateTransactionPayAmount', () => {
     useUpdateTokenAmountMock.mockReturnValue({
       updateTokenAmount: updateTokenAmountMock,
     });
+    useTransactionPayRequiredTokensMock.mockReturnValue([]);
   });
 
   async function flushPromises() {
@@ -259,4 +271,152 @@ describe('useUpdateTransactionPayAmount', () => {
       expect.stringContaining('Failed to prepare Money Account withdraw'),
     );
   });
+
+  describe('syncMoneyAccountDepositRequiredAssets', () => {
+    const TOKEN_ADDRESS_MOCK = '0xToken' as Hex;
+    const existingRequiredAsset = {
+      address: TOKEN_ADDRESS_MOCK,
+      amount: '0x0' as Hex,
+      standard: 'erc20',
+    };
+    const moneyAccountDepositMetaWithRequiredAssets = {
+      ...moneyAccountDepositMeta,
+      requiredAssets: [existingRequiredAsset],
+    };
+
+    beforeEach(() => {
+      updateMoneyAccountDepositTokenAmountMock.mockResolvedValue([]);
+      useTransactionPayRequiredTokensMock.mockReturnValue([
+        { decimals: 6 } as TransactionPayRequiredToken,
+      ]);
+    });
+
+    it('calls updateTransaction with hex-encoded amount when requiredAssets exist', async () => {
+      const { result } = runHook({
+        transactionMeta: moneyAccountDepositMetaWithRequiredAssets,
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).toHaveBeenCalledTimes(1);
+      expect(updateTransactionMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requiredAssets: [{ ...existingRequiredAsset, amount: '0xf4240' }],
+        }),
+        'Money Account deposit: sync requiredAssets amount',
+      );
+    });
+
+    it('rounds fractional atomic amounts up before encoding', async () => {
+      const { result } = runHook({
+        transactionMeta: moneyAccountDepositMetaWithRequiredAssets,
+      });
+
+      result.current.updateTransactionPayAmount('1.0000005');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requiredAssets: [{ ...existingRequiredAsset, amount: '0xf4241' }],
+        }),
+        expect.any(String),
+      );
+    });
+
+    it('does not call updateTransaction when transactionMeta has no requiredAssets', async () => {
+      const { result } = runHook({ transactionMeta: moneyAccountDepositMeta });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).not.toHaveBeenCalled();
+    });
+
+    it('does not call updateTransaction when no required tokens are available', async () => {
+      useTransactionPayRequiredTokensMock.mockReturnValue([]);
+
+      const { result } = runHook({
+        transactionMeta: moneyAccountDepositMetaWithRequiredAssets,
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).not.toHaveBeenCalled();
+    });
+
+    it('does not call updateTransaction when computed amount matches existing amount', async () => {
+      const { result } = runHook({
+        transactionMeta: {
+          ...moneyAccountDepositMeta,
+          requiredAssets: [{ ...existingRequiredAsset, amount: '0xf4240' }],
+        },
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).not.toHaveBeenCalled();
+    });
+
+    it('does not run sync logic for non-deposit transaction types', async () => {
+      updateMoneyAccountWithdrawTokenAmountMock.mockResolvedValue([]);
+
+      const { result } = runHook({
+        transactionMeta: {
+          ...moneyAccountWithdrawMeta,
+          requiredAssets: [existingRequiredAsset],
+        },
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).not.toHaveBeenCalled();
+    });
+
+    it('logs an error when updateTransaction throws', async () => {
+      const error = new Error('updateTransaction failed');
+      updateTransactionMock.mockImplementation(() => {
+        throw error;
+      });
+
+      const { result } = runHook({
+        transactionMeta: moneyAccountDepositMetaWithRequiredAssets,
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(loggerErrorMock).toHaveBeenCalledWith(
+        error,
+        'Failed to sync Money Account deposit requiredAssets amount',
+      );
+    });
+
+    it('still applies money account deposit updates after syncing requiredAssets', async () => {
+      updateMoneyAccountDepositTokenAmountMock.mockResolvedValue([
+        { nestedTransactionIndex: 0, transactionData: '0xaaaa' },
+      ]);
+
+      const { result } = runHook({
+        transactionMeta: moneyAccountDepositMetaWithRequiredAssets,
+      });
+
+      result.current.updateTransactionPayAmount('1');
+
+      await flushPromises();
+
+      expect(updateTransactionMock).toHaveBeenCalledTimes(1);
+      expect(updateAtomicBatchDataMock).toHaveBeenCalledTimes(1);
+    });
+  });
 });

app/components/Views/confirmations/hooks/pay/useUpdateTransactionPayAmount.ts

@@ -1,18 +1,25 @@
 import { useCallback } from 'react';
+import { BigNumber } from 'bignumber.js';
+import { toHex } from '@metamask/controller-utils';
 import {
   TransactionMeta,
   TransactionType,
 } from '@metamask/transaction-controller';
+import { Hex } from '@metamask/utils';
 import { useTransactionMetadataRequest } from '../transactions/useTransactionMetadataRequest';
 import { useUpdateTokenAmount } from '../transactions/useUpdateTokenAmount';
-import { updateAtomicBatchData } from '../../../../../util/transaction-controller';
+import {
+  updateAtomicBatchData,
+  updateTransaction,
+} from '../../../../../util/transaction-controller';
 import {
   updateMoneyAccountDepositTokenAmount,
   updateMoneyAccountWithdrawTokenAmount,
 } from '../../../../UI/Money/utils/moneyAccountTransactions';
 import { UpdateTransactionPayAmountCall } from '../../types/transactions';
 import { hasTransactionType } from '../../utils/transaction';
 import Logger from '../../../../../util/Logger';
+import { useTransactionPayRequiredTokens } from './useTransactionPayData';
 
 type MoneyAccountAmountUpdater = (
   transactionMeta: TransactionMeta,
@@ -22,6 +29,7 @@ type MoneyAccountAmountUpdater = (
 export function useUpdateTransactionPayAmount() {
   const transactionMeta = useTransactionMetadataRequest();
   const { updateTokenAmount } = useUpdateTokenAmount();
+  const requiredTokens = useTransactionPayRequiredTokens();
 
   const applyMoneyAccountAmountUpdates = useCallback(
     async (
@@ -72,6 +80,11 @@ export function useUpdateTransactionPayAmount() {
           TransactionType.moneyAccountDeposit,
         ])
       ) {
+        syncMoneyAccountDepositRequiredAssets(
+          transactionMeta,
+          amountHuman,
+          requiredTokens?.[0]?.decimals,
+        );
         await applyMoneyAccountAmountUpdates(
           amountHuman,
           updateMoneyAccountDepositTokenAmount,
@@ -95,8 +108,45 @@ export function useUpdateTransactionPayAmount() {
 
       updateTokenAmount(amountHuman);
     },
-    [transactionMeta, applyMoneyAccountAmountUpdates, updateTokenAmount],
+    [
+      transactionMeta,
+      applyMoneyAccountAmountUpdates,
+      updateTokenAmount,
+      requiredTokens,
+    ],
   );
 
   return { updateTransactionPayAmount };
 }
+
+function syncMoneyAccountDepositRequiredAssets(
+  transactionMeta: TransactionMeta,
+  amountHuman: string,
+  decimals: number | undefined,
+): void {
+  const existing = transactionMeta.requiredAssets;
+  if (!existing?.length || decimals === undefined) return;
+
+  try {
+    const amount = toHex(
+      new BigNumber(amountHuman)
+        .shiftedBy(decimals)
+        .decimalPlaces(0, BigNumber.ROUND_UP)
+        .toFixed(0),
+    ) as Hex;
+    if (existing[0].amount === amount) return;
+
+    updateTransaction(
+      {
+        ...transactionMeta,
+        requiredAssets: [{ ...existing[0], amount }, ...existing.slice(1)],
+      },
+      'Money Account deposit: sync requiredAssets amount',
+    );
+  } catch (error) {
+    Logger.error(
+      error as Error,
+      'Failed to sync Money Account deposit requiredAssets amount',
+    );
+  }
+}

app/components/Views/confirmations/utils/transaction-pay.test.ts

@@ -185,6 +185,38 @@ describe('Transaction Pay Utils', () => {
 
       expect(getTokenAddress(transactionMeta)).toBe(TO_MOCK);
     });
+
+    it('returns first requiredAsset address if no nested transfer and requiredAssets present', () => {
+      const requiredAssetAddress =
+        '0xrequiredAssetAddress00000000000000000000' as Hex;
+      const transactionMeta = {
+        txParams: {
+          data: '0x1234',
+          to: TO_MOCK,
+        },
+        requiredAssets: [
+          {
+            address: requiredAssetAddress,
+            amount: '0x1' as Hex,
+            standard: 'erc20',
+          },
+        ],
+      } as TransactionMeta;
+
+      expect(getTokenAddress(transactionMeta)).toBe(requiredAssetAddress);
+    });
+
+    it('falls back to txParams.to when requiredAssets is empty', () => {
+      const transactionMeta = {
+        txParams: {
+          data: '0x1234',
+          to: TO_MOCK,
+        },
+        requiredAssets: [],
+      } as unknown as TransactionMeta;
+
+      expect(getTokenAddress(transactionMeta)).toBe(TO_MOCK);
+    });
   });
 
   describe('getAvailableTokens', () => {

app/components/Views/confirmations/utils/transaction-pay.ts

@@ -85,6 +85,11 @@ export function getTokenAddress(
     return nestedCall.to;
   }
 
+  const requiredAssetAddress = transactionMeta?.requiredAssets?.[0]?.address;
+  if (requiredAssetAddress) {
+    return requiredAssetAddress;
+  }
+
   return transactionMeta?.txParams?.to as Hex;
 }