feat: app event manager and attribution id parameters

app/core/Analytics/MetaMetrics.events.ts

@@ -36,6 +36,9 @@ const ONBOARDING_WIZARD_STEP_DESCRIPTION: { [key: number]: string } = {
  * Analytics Tracking Events
  */
 enum EVENT_NAME {
+  // App
+  APP_OPENED = 'App Opened',
+
   // Error
   ERROR = 'Error occurred',
   ERROR_SCREEN_VIEWED = 'Error Screen Viewed',
@@ -432,6 +435,7 @@ enum ACTIONS {
 }
 
 const events = {
+  APP_OPENED: generateOpt(EVENT_NAME.APP_OPENED),
   ERROR: generateOpt(EVENT_NAME.ERROR),
   ERROR_SCREEN_VIEWED: generateOpt(EVENT_NAME.ERROR_SCREEN_VIEWED),
   APPROVAL_STARTED: generateOpt(EVENT_NAME.APPROVAL_STARTED),

app/core/DeeplinkManager/ParseManager/extractURLParams.test.ts

@@ -42,6 +42,7 @@ describe('extractURLParams', () => {
       channelId: '123',
       comm: 'test',
       v: '2',
+      attributionId: '',
     };
 
     mockUrlParser.mockImplementation(
@@ -81,6 +82,7 @@ describe('extractURLParams', () => {
       comm: '',
       pubkey: '',
       v: '',
+      attributionId: '',
     });
   });
 
@@ -113,6 +115,7 @@ describe('extractURLParams', () => {
       comm: '',
       pubkey: '',
       v: '',
+      attributionId: '',
     });
 
     expect(alertSpy).toHaveBeenCalledWith(
@@ -133,6 +136,7 @@ describe('extractURLParams', () => {
       rpc: '',
       sdkVersion: '',
       pubkey: 'xyz',
+      attributionId: '',
     };
 
     mockUrlParser.mockImplementation(

app/core/DeeplinkManager/ParseManager/extractURLParams.ts

@@ -19,6 +19,7 @@ export interface DeeplinkUrlParams {
   message?: string;
   originatorInfo?: string;
   request?: string;
+  attributionId?: string;
   account?: string; // This is the format => "address@chainId"
 }
 
@@ -39,6 +40,7 @@ function extractURLParams(url: string) {
     originatorInfo: '',
     channelId: '',
     comm: '',
+    attributionId: '',
   };
 
   DevLogger.log(`extractParams:: urlObj`, urlObj);

app/core/DeeplinkManager/ParseManager/parseDeeplink.test.ts

@@ -5,6 +5,43 @@ import handleMetaMaskDeeplink from './handleMetaMaskDeeplink';
 import handleUniversalLink from './handleUniversalLink';
 import connectWithWC from './connectWithWC';
 import parseDeeplink from './parseDeeplink';
+import { MetaMetrics, MetaMetricsEvents } from '../../Analytics';
+import { store } from '../../../store';
+
+jest.mock('../../../constants/deeplinks', () => ({
+  PROTOCOLS: {
+    HTTP: 'http',
+    HTTPS: 'https',
+    WC: 'wc',
+    ETHEREUM: 'ethereum',
+    DAPP: 'dapp',
+    METAMASK: 'metamask',
+  },
+}));
+jest.mock('../../../core/SDKConnect/SDKConnect', () => ({
+  getInstance: jest.fn(() => ({
+    hasInitialized: jest.fn(() => true),
+  })),
+}));
+jest.mock('../../../store', () => ({
+  store: {
+    getState: jest.fn(() => ({
+      security: {
+        dataCollectionForMarketing: true,
+      },
+    })),
+  },
+}));
+
+jest.mock('../../../store', () => ({
+  store: {
+    getState: jest.fn(() => ({
+      security: {
+        dataCollectionForMarketing: true,
+      },
+    })),
+  },
+}));
 
 jest.mock('../../../constants/deeplinks');
 jest.mock('../../../util/Logger');
@@ -17,6 +54,14 @@ jest.mock('./connectWithWC');
 jest.mock('../../../../locales/i18n', () => ({
   strings: jest.fn((key) => key),
 }));
+jest.mock('../../Analytics', () => ({
+  MetaMetrics: {
+    getInstance: jest.fn(),
+  },
+  MetaMetricsEvents: {
+    APP_OPENED: 'APP_OPENED',
+  },
+}));
 
 const invalidUrls = [
   'htp://incorrect-format-url',
@@ -55,29 +100,118 @@ describe('parseDeeplink', () => {
     } as unknown as DeeplinkManager;
   });
 
-  it('should call handleUniversalLinks for HTTP protocol', () => {
-    const url = 'http://example.com/';
-    const browserCallBackMock = jest.fn();
-    const onHandledMock = jest.fn();
+  describe('Attribution ID handling', () => {
+    let mockTrackEvent: jest.Mock;
 
-    const { urlObj, params } = extractURLParams(url);
+    beforeEach(() => {
+      mockTrackEvent = jest.fn();
+      (MetaMetrics.getInstance as jest.Mock).mockReturnValue({
+        trackEvent: mockTrackEvent,
+      });
+    });
+
+    it('should track event with attributionId when data collection is enabled', () => {
+      const url = 'https://example.com/?attributionId=test123';
+      (store.getState as jest.Mock).mockReturnValue({
+        security: { dataCollectionForMarketing: true },
+      });
+
+      parseDeeplink({
+        deeplinkManager: instance,
+        url,
+        origin: 'testOrigin',
+        browserCallBack: mockBrowserCallBack,
+        onHandled: mockOnHandled,
+      });
+
+      expect(mockTrackEvent).toHaveBeenCalledWith(
+        MetaMetricsEvents.APP_OPENED,
+        { attributionId: 'test123' },
+        true
+      );
+    });
+
+    it('should not track event when attributionId is present but data collection is disabled', () => {
+      const url = 'https://example.com/?attributionId=test123';
+      (store.getState as jest.Mock).mockReturnValue({
+        security: { dataCollectionForMarketing: false },
+      });
+
+      parseDeeplink({
+        deeplinkManager: instance,
+        url,
+        origin: 'testOrigin',
+        browserCallBack: mockBrowserCallBack,
+        onHandled: mockOnHandled,
+      });
+
+      expect(mockTrackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should not track event when attributionId is not present', () => {
+      const url = 'https://example.com/';
+      (store.getState as jest.Mock).mockReturnValue({
+        security: { dataCollectionForMarketing: true },
+      });
 
+      parseDeeplink({
+        deeplinkManager: instance,
+        url,
+        origin: 'testOrigin',
+        browserCallBack: mockBrowserCallBack,
+        onHandled: mockOnHandled,
+      });
+
+      expect(mockTrackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle attributionId with different protocols', () => {
+      const protocols = ['http', 'https', 'wc', 'ethereum', 'dapp', 'metamask'];
+
+      protocols.forEach(protocol => {
+        const url = `${protocol}://example.com/?attributionId=test_${protocol}`;
+        (store.getState as jest.Mock).mockReturnValue({
+          security: { dataCollectionForMarketing: true },
+        });
+
+        parseDeeplink({
+          deeplinkManager: instance,
+          url,
+          origin: 'testOrigin',
+          browserCallBack: mockBrowserCallBack,
+          onHandled: mockOnHandled,
+        });
+
+        expect(mockTrackEvent).toHaveBeenCalledWith(
+          MetaMetricsEvents.APP_OPENED,
+          { attributionId: `test_${protocol}` },
+          true
+        );
+
+        mockTrackEvent.mockClear();
+      });
+    });
+  });
+
+  it('should call handleUniversalLinks for HTTP protocol', () => {
+    const url = 'http://example.com/';
     parseDeeplink({
       deeplinkManager: instance,
       url,
       origin: 'testOrigin',
-      browserCallBack: browserCallBackMock,
-      onHandled: onHandledMock,
+      browserCallBack: mockBrowserCallBack,
+      onHandled: mockOnHandled,
     });
 
     expect(mockHandleUniversalLinks).toHaveBeenCalledWith(
       expect.objectContaining({
         instance,
-        urlObj,
-        params,
-        browserCallBack: browserCallBackMock,
+        urlObj: expect.any(Object),
+        params: expect.any(Object),
+        browserCallBack: mockBrowserCallBack,
         origin: 'testOrigin',
         wcURL: url,
+        url,
       }),
     );
   });
@@ -111,7 +245,6 @@ describe('parseDeeplink', () => {
 
   it('should call handleWCProtocol for WC protocol', () => {
     const url = 'wc://example.com';
-
     parseDeeplink({
       deeplinkManager: instance,
       url,
@@ -120,12 +253,18 @@ describe('parseDeeplink', () => {
       onHandled: mockOnHandled,
     });
 
-    expect(mockHandleWCProtocol).toHaveBeenCalled();
+    expect(mockHandleWCProtocol).toHaveBeenCalledWith(
+      expect.objectContaining({
+        handled: expect.any(Function),
+        wcURL: url,
+        origin: 'testOrigin',
+        params: expect.any(Object),
+      }),
+    );
   });
 
   it('should handle Ethereum URL', () => {
     const url = 'ethereum://example.com';
-
     parseDeeplink({
       deeplinkManager: instance,
       url,

app/core/DeeplinkManager/ParseManager/parseDeeplink.ts

@@ -1,15 +1,18 @@
+import { Alert } from 'react-native';
+import { strings } from '../../../../locales/i18n';
 import { PROTOCOLS } from '../../../constants/deeplinks';
 import SDKConnect from '../../../core/SDKConnect/SDKConnect';
+import { RootState } from '../../../reducers';
+import { store } from '../../../store';
 import Logger from '../../../util/Logger';
+import { MetaMetrics, MetaMetricsEvents } from '../../Analytics';
 import DevLogger from '../../SDKConnect/utils/DevLogger';
 import DeeplinkManager from '../DeeplinkManager';
+import connectWithWC from './connectWithWC';
 import extractURLParams from './extractURLParams';
 import handleDappUrl from './handleDappUrl';
 import handleMetaMaskDeeplink from './handleMetaMaskDeeplink';
 import handleUniversalLink from './handleUniversalLink';
-import connectWithWC from './connectWithWC';
-import { Alert } from 'react-native';
-import { strings } from '../../../../locales/i18n';
 
 function parseDeeplink({
   deeplinkManager: instance,
@@ -41,6 +44,19 @@ function parseDeeplink({
     const handled = () => (onHandled ? onHandled() : false);
 
     const wcURL = params?.uri || urlObj.href;
+    const attributionId = params?.attributionId;
+
+    const { security } = store.getState() as RootState;
+    const isDataCollectionForMarketingEnabled = security.dataCollectionForMarketing;
+    DevLogger.log(`DeepLinkManager:parse isDataCollectionForMarketingEnabled=${isDataCollectionForMarketingEnabled} attributionId=${attributionId}`);
+
+    if(attributionId && isDataCollectionForMarketingEnabled) {
+      MetaMetrics.getInstance().trackEvent(
+          MetaMetricsEvents.APP_OPENED,
+          { attributionId },
+          true,
+        );
+    }
 
     switch (urlObj.protocol.replace(':', '')) {
       case PROTOCOLS.HTTP: