feat(analytics): add ASSET_VIEWED for Predict, Perps, and Swaps funnel views (MetaMask#30069)

## Summary

Unifies Segment funnel reporting by emitting a new MetaMetrics event
`ASSET_VIEWED` whenever any of these legacy events fire, with the **same
properties** plus:

- `trade_type`: `Predict` | `Perps` | `Swaps` (mapped from the legacy
event)
- `implementation_type`: `native` (mobile)

Legacy events are **unchanged**; `ASSET_VIEWED` is an additional
duplicate for downstream analytics.

## **Changelog**

CHANGELOG entry: refactor: update analytic events

## Implementation

| Legacy event | Trigger |
|--------------|---------|
| Predict Feed Viewed | `PredictAnalytics` (`feedViewed` /
`trackFeedViewed`) |
| Perp Screen Viewed | `usePerpsEventTracking` `track()`;
`PerpsOpenOrderCard` geo path (`useAnalytics`) |
| Unified SwapBridge Page Viewed | `useTrackSwapPageViewed` |

Shared merge helper:
`app/core/Analytics/trade-transaction-funnel/assetViewedAnalytics.ts`
(exported via `app/core/Analytics/index.ts`).

Swap-related AB test mappings include `ASSET_VIEWED` so
`enrichWithABTests` applies the same assignments as `Unified SwapBridge
Page Viewed`.

## Testing

```bash
yarn jest app/core/Analytics/trade-transaction-funnel/assetViewedAnalytics.test.ts \
  app/components/UI/Perps/hooks/usePerpsEventTracking.test.ts \
  app/components/UI/Predict/controllers/PredictAnalytics.test.ts \
  app/components/UI/Bridge/hooks/useTrackSwapPageViewed/index.test.ts \
  app/util/analytics/enrichWithABTests.test.ts
```


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Analytics-only duplication of existing events with guarded AB
enrichment and one Perps screen-type exclusion; no auth, payments, or
transaction logic changes.
> 
> **Overview**
> Introduces a unified Segment **`Asset Viewed`** event that fires **in
addition to** existing Predict, Perps, and Swaps screen-view events,
carrying the same payload plus `trade_type` (`Predict` | `Perps` |
`Swaps`) and `implementation_type: native` via
**`mergeAssetViewedProperties`**.
> 
> **Swaps:** `useTrackSwapPageViewed` now emits `ASSET_VIEWED` next to
`Unified SwapBridge Page Viewed`. Swap numpad and token-selector AB
mappings include `ASSET_VIEWED` with **`eventPropertyRequirements`** so
`enrichWithABTests` only attaches swap experiments when `trade_type` is
`Swaps`.
> 
> **Perps:** `usePerpsEventTracking` mirrors `Perp Screen Viewed` with
`ASSET_VIEWED`, except **`cancel_all_orders`** screens (avoids
mis-mapping `open_position`). Geo-block cancel flow in
**`PerpsOpenOrderCard`** also emits `ASSET_VIEWED`.
> 
> **Predict:** `PredictAnalytics` emits `ASSET_VIEWED` for **feed
viewed** and **market details opened**. Explore
**`trackExploreSectionSeeAll`** adds Predict funnel `ASSET_VIEWED` for
**`predictions_trending`** only.
> 
> Helper normalizes open-position fields to **`open_positions_count`**
on Asset Viewed. Tests and integration expectations updated accordingly.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
3e5bc2f. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Prithpal Sooriya <prithpal.sooriya@gmail.com>
Co-authored-by: Prithpal Sooriya <prithpal.sooriya@consensys.net>

Author: 3 people

app/components/UI/Bridge/components/GaslessQuickPickOptions/abTestConfig.ts

@@ -1,3 +1,4 @@
+import { ASSET_VIEWED_PROPERTY } from '../../../../../core/Analytics/trade-transaction-funnel/assetViewedAnalytics';
 import { EVENT_NAME } from '../../../../../core/Analytics/MetaMetrics.events';
 import type { ABTestAnalyticsMapping } from '../../../../../util/analytics/abTestAnalytics.types';
 
@@ -30,5 +31,10 @@ export const NUMPAD_QUICK_ACTIONS_AB_TEST_ANALYTICS_MAPPING: ABTestAnalyticsMapp
   {
     flagKey: NUMPAD_QUICK_ACTIONS_AB_KEY,
     validVariants: Object.values(NumpadQuickActionsVariant),
-    eventNames: [EVENT_NAME.SWAP_PAGE_VIEWED],
+    eventNames: [EVENT_NAME.SWAP_PAGE_VIEWED, EVENT_NAME.ASSET_VIEWED],
+    eventPropertyRequirements: {
+      [EVENT_NAME.ASSET_VIEWED]: {
+        [ASSET_VIEWED_PROPERTY.TRADE_TYPE]: 'Swaps',
+      },
+    },
   };

app/components/UI/Bridge/components/TokenSelectorItem.abTestConfig.ts

@@ -1,3 +1,4 @@
+import { ASSET_VIEWED_PROPERTY } from '../../../../core/Analytics/trade-transaction-funnel/assetViewedAnalytics';
 import { EVENT_NAME } from '../../../../core/Analytics/MetaMetrics.events';
 import type { ABTestAnalyticsMapping } from '../../../../util/analytics/abTestAnalytics.types';
 
@@ -32,5 +33,10 @@ export const TOKEN_SELECTOR_BALANCE_LAYOUT_AB_TEST_ANALYTICS_MAPPING: ABTestAnal
   {
     flagKey: TOKEN_SELECTOR_BALANCE_LAYOUT_AB_KEY,
     validVariants: Object.values(TokenSelectorBalanceLayoutVariant),
-    eventNames: [EVENT_NAME.SWAP_PAGE_VIEWED],
+    eventNames: [EVENT_NAME.SWAP_PAGE_VIEWED, EVENT_NAME.ASSET_VIEWED],
+    eventPropertyRequirements: {
+      [EVENT_NAME.ASSET_VIEWED]: {
+        [ASSET_VIEWED_PROPERTY.TRADE_TYPE]: 'Swaps',
+      },
+    },
   };

app/components/UI/Bridge/hooks/useTrackSwapPageViewed/index.test.ts

@@ -0,0 +1,124 @@
+import { renderHook } from '@testing-library/react-native';
+import { useSelector } from 'react-redux';
+import {
+  selectDestToken,
+  selectSourceToken,
+} from '../../../../../core/redux/slices/bridge';
+import { useAnalytics } from '../../../../hooks/useAnalytics/useAnalytics';
+import { MetaMetricsEvents } from '../../../../../core/Analytics';
+import { useTrackSwapPageViewed } from './index';
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
+
+jest.mock('../../../../hooks/useAnalytics/useAnalytics');
+
+const mockUseSelector = useSelector as jest.MockedFunction<typeof useSelector>;
+const mockTrackEvent = jest.fn();
+const mockCreateEventBuilder = jest.fn();
+
+const sourceToken = {
+  symbol: 'ETH',
+  chainId: '0x1',
+  address: '0x0000000000000000000000000000000000000000',
+};
+
+const destToken = {
+  symbol: 'USDC',
+  chainId: '0x89',
+  address: '0x2791bca1f2de4661ed88a30c99a7a9449aa84174',
+};
+
+describe('useTrackSwapPageViewed', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCreateEventBuilder.mockImplementation(() => ({
+      addProperties: jest.fn().mockReturnThis(),
+      build: jest.fn(() => ({ type: 'built' })),
+    }));
+    jest.mocked(useAnalytics).mockReturnValue({
+      trackEvent: mockTrackEvent,
+      createEventBuilder: mockCreateEventBuilder,
+    } as unknown as ReturnType<typeof useAnalytics>);
+  });
+
+  it('does not track when the source token is missing', () => {
+    mockUseSelector.mockImplementation((selector: unknown) => {
+      if (selector === selectSourceToken) {
+        return null;
+      }
+      if (selector === selectDestToken) {
+        return destToken;
+      }
+      return undefined;
+    });
+
+    renderHook(() => useTrackSwapPageViewed());
+
+    expect(mockTrackEvent).not.toHaveBeenCalled();
+    expect(mockCreateEventBuilder).not.toHaveBeenCalled();
+  });
+
+  it('tracks SWAP_PAGE_VIEWED and Asset Viewed with swap page properties when the source token is set', () => {
+    mockUseSelector.mockImplementation((selector: unknown) => {
+      if (selector === selectSourceToken) {
+        return sourceToken;
+      }
+      if (selector === selectDestToken) {
+        return destToken;
+      }
+      return undefined;
+    });
+
+    renderHook(() => useTrackSwapPageViewed());
+
+    const expectedPageProperties = {
+      chain_id_source: '1',
+      chain_id_destination: '137',
+      token_symbol_source: 'ETH',
+      token_symbol_destination: 'USDC',
+      token_address_source: sourceToken.address,
+      token_address_destination: destToken.address,
+    };
+
+    expect(mockTrackEvent).toHaveBeenCalledTimes(2);
+    expect(mockCreateEventBuilder.mock.calls[0][0]).toBe(
+      MetaMetricsEvents.SWAP_PAGE_VIEWED,
+    );
+    expect(mockCreateEventBuilder.mock.calls[1][0]).toBe(
+      MetaMetricsEvents.ASSET_VIEWED,
+    );
+
+    const swapBuilder = mockCreateEventBuilder.mock.results[0].value;
+    const assetViewedBuilder = mockCreateEventBuilder.mock.results[1].value;
+
+    expect(swapBuilder.addProperties).toHaveBeenCalledWith(
+      expectedPageProperties,
+    );
+    expect(assetViewedBuilder.addProperties).toHaveBeenCalledWith({
+      ...expectedPageProperties,
+      trade_type: 'Swaps',
+      implementation_type: 'native',
+    });
+  });
+
+  it('tracks at most once per hook mount when the source token stays set', () => {
+    mockUseSelector.mockImplementation((selector: unknown) => {
+      if (selector === selectSourceToken) {
+        return sourceToken;
+      }
+      if (selector === selectDestToken) {
+        return destToken;
+      }
+      return undefined;
+    });
+
+    const { rerender } = renderHook(() => useTrackSwapPageViewed());
+
+    rerender(undefined);
+
+    expect(mockTrackEvent).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -1,7 +1,10 @@
 import { useEffect, useRef } from 'react';
 import { useSelector } from 'react-redux';
 import { useAnalytics } from '../../../../hooks/useAnalytics/useAnalytics';
-import { MetaMetricsEvents } from '../../../../../core/Analytics';
+import {
+  MetaMetricsEvents,
+  mergeAssetViewedProperties,
+} from '../../../../../core/Analytics';
 import { getDecimalChainId } from '../../../../../util/networks';
 import {
   selectDestToken,
@@ -33,6 +36,13 @@ export const useTrackSwapPageViewed = () => {
           .addProperties(pageViewedProperties)
           .build(),
       );
+      trackEvent(
+        createEventBuilder(MetaMetricsEvents.ASSET_VIEWED)
+          .addProperties(
+            mergeAssetViewedProperties('Swaps', pageViewedProperties),
+          )
+          .build(),
+      );
     }
   }, [sourceToken, destToken, trackEvent, createEventBuilder]);
 };

app/components/UI/Perps/components/PerpsOpenOrderCard/PerpsOpenOrderCard.tsx

@@ -40,7 +40,10 @@ import {
   PERPS_EVENT_PROPERTY,
   PERPS_EVENT_VALUE,
 } from '@metamask/perps-controller';
-import { MetaMetricsEvents } from '../../../../../core/Analytics';
+import {
+  MetaMetricsEvents,
+  mergeAssetViewedProperties,
+} from '../../../../../core/Analytics';
 import { useAnalytics } from '../../../../hooks/useAnalytics/useAnalytics';
 
 /**
@@ -144,14 +147,21 @@ const PerpsOpenOrderCard: React.FC<PerpsOpenOrderCardProps> = ({
 
     if (!isEligible) {
       // Track geo-block screen viewed
+      const geoBlockProperties = {
+        [PERPS_EVENT_PROPERTY.SCREEN_TYPE]:
+          PERPS_EVENT_VALUE.SCREEN_TYPE.GEO_BLOCK_NOTIF,
+        [PERPS_EVENT_PROPERTY.SOURCE]: PERPS_EVENT_VALUE.SOURCE.CANCEL_ORDER,
+      };
       trackEvent(
         createEventBuilder(MetaMetricsEvents.PERPS_SCREEN_VIEWED)
-          .addProperties({
-            [PERPS_EVENT_PROPERTY.SCREEN_TYPE]:
-              PERPS_EVENT_VALUE.SCREEN_TYPE.GEO_BLOCK_NOTIF,
-            [PERPS_EVENT_PROPERTY.SOURCE]:
-              PERPS_EVENT_VALUE.SOURCE.CANCEL_ORDER,
-          })
+          .addProperties(geoBlockProperties)
+          .build(),
+      );
+      trackEvent(
+        createEventBuilder(MetaMetricsEvents.ASSET_VIEWED)
+          .addProperties(
+            mergeAssetViewedProperties('Perps', geoBlockProperties),
+          )
           .build(),
       );
       setIsEligibilityModalVisible(true);

app/components/UI/Perps/hooks/usePerpsEventTracking.test.ts

@@ -1,7 +1,11 @@
 import { renderHook, act } from '@testing-library/react-native';
 import { usePerpsEventTracking } from './usePerpsEventTracking';
-import { PERPS_EVENT_PROPERTY } from '@metamask/perps-controller';
+import {
+  PERPS_EVENT_PROPERTY,
+  PERPS_EVENT_VALUE,
+} from '@metamask/perps-controller';
 import { useAnalytics } from '../../../hooks/useAnalytics/useAnalytics';
+import { MetaMetricsEvents } from '../../../../core/Analytics';
 
 const mockTrackEvent = jest.fn();
 const mockCreateEventBuilder = jest.fn();
@@ -13,11 +17,10 @@ describe('usePerpsEventTracking', () => {
     jest.clearAllMocks();
     jest.spyOn(Date, 'now').mockReturnValue(1234567890);
 
-    const eventBuilder = {
+    mockCreateEventBuilder.mockImplementation(() => ({
       addProperties: jest.fn().mockReturnThis(),
       build: jest.fn().mockReturnValue({ type: 'mock-event' }),
-    };
-    mockCreateEventBuilder.mockReturnValue(eventBuilder);
+    }));
     jest.mocked(useAnalytics).mockReturnValue({
       trackEvent: mockTrackEvent,
       createEventBuilder: mockCreateEventBuilder,
@@ -67,5 +70,77 @@ describe('usePerpsEventTracking', () => {
         ...customProps,
       });
     });
+
+    it('tracks Asset Viewed when PERPS_SCREEN_VIEWED is tracked', () => {
+      const { result } = renderHook(() => usePerpsEventTracking());
+      const customProps = {
+        screen_type: 'home',
+        [PERPS_EVENT_PROPERTY.OPEN_POSITION]: 2,
+      };
+
+      act(() => {
+        result.current.track(
+          MetaMetricsEvents.PERPS_SCREEN_VIEWED,
+          customProps,
+        );
+      });
+
+      expect(mockTrackEvent).toHaveBeenCalledTimes(2);
+      expect(mockCreateEventBuilder.mock.calls[0][0]).toBe(
+        MetaMetricsEvents.PERPS_SCREEN_VIEWED,
+      );
+      expect(mockCreateEventBuilder.mock.calls[1][0]).toBe(
+        MetaMetricsEvents.ASSET_VIEWED,
+      );
+
+      const perpsBuilder = mockCreateEventBuilder.mock.results[0].value;
+      const assetBuilder = mockCreateEventBuilder.mock.results[1].value;
+      expect(perpsBuilder.addProperties).toHaveBeenCalledWith({
+        [PERPS_EVENT_PROPERTY.TIMESTAMP]: 1234567890,
+        ...customProps,
+      });
+      const assetViewedProperties = assetBuilder.addProperties.mock
+        .calls[0][0] as Record<string, unknown>;
+      expect(assetViewedProperties).toEqual({
+        [PERPS_EVENT_PROPERTY.TIMESTAMP]: 1234567890,
+        screen_type: 'home',
+        open_positions_count: 2,
+        trade_type: 'Perps',
+        implementation_type: 'native',
+      });
+      expect(assetViewedProperties).not.toHaveProperty(
+        PERPS_EVENT_PROPERTY.OPEN_POSITION,
+      );
+    });
+
+    it('does not track Asset Viewed for cancel_all_orders', () => {
+      const { result } = renderHook(() => usePerpsEventTracking());
+      const customProps = {
+        [PERPS_EVENT_PROPERTY.SCREEN_TYPE]:
+          PERPS_EVENT_VALUE.SCREEN_TYPE.CANCEL_ALL_ORDERS,
+        [PERPS_EVENT_PROPERTY.OPEN_POSITION]: 3,
+        [PERPS_EVENT_PROPERTY.SOURCE]:
+          PERPS_EVENT_VALUE.SOURCE.CANCEL_ALL_ORDERS_BUTTON,
+      };
+
+      act(() => {
+        result.current.track(
+          MetaMetricsEvents.PERPS_SCREEN_VIEWED,
+          customProps,
+        );
+      });
+
+      expect(mockTrackEvent).toHaveBeenCalledTimes(1);
+      expect(mockCreateEventBuilder).toHaveBeenCalledTimes(1);
+      expect(mockCreateEventBuilder).toHaveBeenCalledWith(
+        MetaMetricsEvents.PERPS_SCREEN_VIEWED,
+      );
+
+      const perpsBuilder = mockCreateEventBuilder.mock.results[0].value;
+      expect(perpsBuilder.addProperties).toHaveBeenCalledWith({
+        [PERPS_EVENT_PROPERTY.TIMESTAMP]: 1234567890,
+        ...customProps,
+      });
+    });
   });
 });

app/components/UI/Perps/hooks/usePerpsEventTracking.ts

@@ -1,12 +1,40 @@
 import { useCallback, useEffect, useRef, useMemo } from 'react';
-import { MetaMetricsEvents } from '../../../../core/Analytics';
+import {
+  MetaMetricsEvents,
+  mergeAssetViewedProperties,
+} from '../../../../core/Analytics';
 import { useAnalytics } from '../../../hooks/useAnalytics/useAnalytics';
-import { PERPS_EVENT_PROPERTY } from '@metamask/perps-controller';
+import {
+  PERPS_EVENT_PROPERTY,
+  PERPS_EVENT_VALUE,
+} from '@metamask/perps-controller';
 
 // Static helper function - moved outside component to avoid recreation
 const allTrue = (conditionArray: boolean[]): boolean =>
   conditionArray.length > 0 && conditionArray.every(Boolean);
 
+/**
+ * Perps screen types excluded from the parallel Asset Viewed emission.
+ *
+ * `screen_type: 'cancel_all_orders'` (PERPS_EVENT_VALUE.SCREEN_TYPE.CANCEL_ALL_ORDERS)
+ * sends open-order count in legacy `open_position`. `mergeAssetViewedProperties`
+ * would map that to `open_positions_count`, so we skip Asset Viewed for this flow.
+ */
+const PERPS_SCREEN_TYPES_SKIP_ASSET_VIEWED: ReadonlySet<string> = new Set([
+  PERPS_EVENT_VALUE.SCREEN_TYPE.CANCEL_ALL_ORDERS,
+]);
+
+const shouldEmitAssetViewedForPerpsScreenViewed = (
+  perpsScreenViewedProperties: Record<string, unknown>,
+): boolean => {
+  const screenType =
+    perpsScreenViewedProperties[PERPS_EVENT_PROPERTY.SCREEN_TYPE];
+  return !(
+    typeof screenType === 'string' &&
+    PERPS_SCREEN_TYPES_SKIP_ASSET_VIEWED.has(screenType)
+  );
+};
+
 interface EventTrackingOptions {
   eventName: (typeof MetaMetricsEvents)[keyof typeof MetaMetricsEvents];
   properties?: Record<string, unknown>;
@@ -63,6 +91,17 @@ export const usePerpsEventTracking = (options?: EventTrackingOptions) => {
         ...properties,
       };
       trackEvent(createEventBuilder(eventName).addProperties(props).build());
+
+      if (
+        eventName === MetaMetricsEvents.PERPS_SCREEN_VIEWED &&
+        shouldEmitAssetViewedForPerpsScreenViewed(props)
+      ) {
+        trackEvent(
+          createEventBuilder(MetaMetricsEvents.ASSET_VIEWED)
+            .addProperties(mergeAssetViewedProperties('Perps', props))
+            .build(),
+        );
+      }
     },
     [trackEvent, createEventBuilder],
   );