feat: Add simulation receiving value for Predict withdraw metrics (MetaMask#24281)

<!--
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**

Predict withdraw transactions were missing
`simulation_receiving_assets_total_value`, limiting visibility into
total value withdrawn.

Attach `assetsFiatValues.receiving` to Predict withdraw transactions
during signing and add tests to verify the value is emitted through the
metrics pipeline.

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

Fixes: MetaMask/MetaMask-planning#6392

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

- [ ] 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).
- [ ] 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-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]
> Adds missing simulation receiving value for Predict withdraws and
validates metrics propagation.
> 
> - Updates `PredictController.beforeSign` to set updated `txParams` and
`assetsFiatValues.receiving` (stringified amount), and conditionally
apply gas estimates
> - Extends tests: `PredictController.test` asserts
`assetsFiatValues.receiving`; `metrics.test` verifies
`simulation_receiving_assets_total_value` is included when present and
adds coverage for Smart Transactions metrics properties
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
574d483. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: pedronfigueiredo

app/components/UI/Predict/controllers/PredictController.test.ts

@@ -3841,7 +3841,19 @@ describe('PredictController', () => {
         expect(result).toBeDefined();
         expect(result?.updateTransaction).toBeDefined();
 
-        const testTransaction = {
+        const testTransaction: {
+          txParams: {
+            from: string;
+            to: string;
+            data: string;
+            gas?: string;
+            gasLimit?: string;
+          };
+          assetsFiatValues?: {
+            receiving?: string;
+            sending?: string;
+          };
+        } = {
           txParams: {
             from: '0xFrom',
             to: '0xOldTarget',
@@ -3853,6 +3865,9 @@ describe('PredictController', () => {
 
         expect(testTransaction.txParams.data).toBe('0xmodifieddata');
         expect(testTransaction.txParams.to).toBe('0xPredictAddress');
+        expect(testTransaction.assetsFiatValues).toEqual({
+          receiving: '100',
+        });
       });
     });
 

app/components/UI/Predict/controllers/PredictController.ts

@@ -2157,6 +2157,10 @@ export class PredictController extends BaseController<
         transaction.txParams.data = callData;
         transaction.txParams.to = this.state.withdrawTransaction
           ?.predictAddress as Hex;
+        transaction.assetsFiatValues = {
+          ...transaction.assetsFiatValues,
+          receiving: String(amount),
+        };
         // Only update gas if estimation succeeded
         if (updatedGas) {
           transaction.txParams.gas = updatedGas;

app/core/Engine/controllers/transaction-controller/event-handlers/metrics.test.ts

@@ -4,6 +4,8 @@ import { merge } from 'lodash';
 import { MetaMetrics } from '../../../../Analytics';
 import { TRANSACTION_EVENTS } from '../../../../Analytics/events/confirmations';
 import { MetricsEventBuilder } from '../../../../Analytics/MetricsEventBuilder';
+import { selectShouldUseSmartTransaction } from '../../../../../selectors/smartTransactionsController';
+import { getSmartTransactionMetricsProperties } from '../../../../../util/smart-transactions';
 import {
   handleTransactionAddedEventForMetrics,
   handleTransactionApprovedEventForMetrics,
@@ -12,7 +14,10 @@ import {
   handleTransactionSubmittedEventForMetrics,
 } from './metrics';
 import { TransactionEventHandlerRequest } from '../types';
-import { enabledSmartTransactionsState } from '../data-helpers';
+import {
+  disabledSmartTransactionsState,
+  enabledSmartTransactionsState,
+} from '../data-helpers';
 
 jest.mock('../../../../../util/smart-transactions', () => {
   const actual = jest.requireActual('../../../../../util/smart-transactions');
@@ -64,6 +69,19 @@ jest.mock('../metrics_properties/metamask-pay', () => ({
   }),
 }));
 
+const mockSelectShouldUseSmartTransaction = jest.mocked(
+  selectShouldUseSmartTransaction,
+);
+const mockGetSmartTransactionMetricsProperties = jest.mocked(
+  getSmartTransactionMetricsProperties,
+);
+
+const mockSmartTransactionMetricsProperties = {
+  smart_transaction_timed_out: false,
+  smart_transaction_proxied: false,
+  is_smart_transaction: true,
+};
+
 describe('Transaction Metric Event Handlers', () => {
   const mockGetState = jest.fn();
   const mockInitMessenger = jest.fn();
@@ -212,4 +230,102 @@ describe('Transaction Metric Event Handlers', () => {
       }),
     );
   });
+
+  it('includes simulation receiving total value when assetsFiatValues is set', async () => {
+    const transactionMetaWithFiatValues = {
+      ...mockTransactionMeta,
+      assetsFiatValues: {
+        receiving: '123.45',
+      },
+    } as unknown as TransactionMeta;
+
+    await handleTransactionApprovedEventForMetrics(
+      transactionMetaWithFiatValues,
+      mockTransactionMetricRequest,
+    );
+
+    expect(mockEventBuilder.addProperties).toHaveBeenCalledWith(
+      expect.objectContaining({
+        simulation_receiving_assets_total_value: 123.45,
+      }),
+    );
+  });
+
+  describe('handleTransactionFinalized', () => {
+    it('adds STX metrics properties if smart transactions are enabled', async () => {
+      // Force the selector to return true
+      mockSelectShouldUseSmartTransaction.mockReturnValue(true);
+
+      // Force the mock to return the expected properties
+      mockGetSmartTransactionMetricsProperties.mockResolvedValue({
+        smart_transaction_timed_out: false,
+        smart_transaction_proxied: false,
+        is_smart_transaction: true,
+      });
+
+      await handleTransactionFinalizedEventForMetrics(
+        mockTransactionMeta,
+        mockTransactionMetricRequest,
+      );
+
+      // Check if the mock was called
+      expect(mockGetSmartTransactionMetricsProperties).toHaveBeenCalled();
+
+      // Check if addProperties was called with the STX properties
+      expect(mockEventBuilder.addProperties).toHaveBeenCalledWith(
+        expect.objectContaining({
+          smart_transaction_timed_out: false,
+          smart_transaction_proxied: false,
+          is_smart_transaction: true,
+        }),
+      );
+    });
+
+    it('does not add STX metrics properties if smart transactions are not enabled', async () => {
+      // Force the selector to return false for this test
+      mockSelectShouldUseSmartTransaction.mockReturnValue(false);
+
+      mockGetState.mockReturnValue(
+        merge({}, disabledSmartTransactionsState, {
+          confirmationMetrics: {
+            metricsById: {
+              [mockTransactionMeta.id]: {
+                properties: { test_property: 'test_value' },
+                sensitiveProperties: { sensitive_property: 'sensitive_value' },
+              },
+            },
+          },
+        }),
+      );
+
+      await handleTransactionFinalizedEventForMetrics(
+        mockTransactionMeta,
+        mockTransactionMetricRequest,
+      );
+
+      expect(mockEventBuilder.addProperties).toHaveBeenCalled();
+      expect(mockEventBuilder.addProperties).not.toHaveBeenCalledWith(
+        expect.objectContaining(mockSmartTransactionMetricsProperties),
+      );
+    });
+
+    it('includes builder metrics', async () => {
+      await handleTransactionFinalizedEventForMetrics(
+        mockTransactionMeta,
+        mockTransactionMetricRequest,
+      );
+
+      expect(mockEventBuilder.addProperties).toHaveBeenCalledWith(
+        expect.objectContaining({
+          builder_test: true,
+        }),
+      );
+
+      expect(mockEventBuilder.addSensitiveProperties).toHaveBeenCalledWith(
+        expect.objectContaining({
+          builder_sensitive_test: true,
+        }),
+      );
+    });
+  });
 });