MetaMask
diff --git a/‎app/core/AppStateEventListener.test.ts‎
Lines changed: 57 additions & 8 deletions b/‎app/core/AppStateEventListener.test.ts‎
Lines changed: 57 additions & 8 deletions
diff --git a/‎app/core/AppStateEventListener.ts‎
Lines changed: 12 additions & 0 deletions b/‎app/core/AppStateEventListener.ts‎
Lines changed: 12 additions & 0 deletions
diff --git a/‎app/core/DeeplinkManager/handlers/legacy/__tests__/handleDeeplink.test.ts‎
Lines changed: 38 additions & 1 deletion b/‎app/core/DeeplinkManager/handlers/legacy/__tests__/handleDeeplink.test.ts‎
Lines changed: 38 additions & 1 deletion
diff --git a/‎app/core/DeeplinkManager/handlers/legacy/handleDeeplink.ts‎
Lines changed: 11 additions & 0 deletions b/‎app/core/DeeplinkManager/handlers/legacy/handleDeeplink.ts‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎app/core/DeeplinkManager/types/deepLink.types.ts‎
Lines changed: 1 addition & 0 deletions b/‎app/core/DeeplinkManager/types/deepLink.types.ts‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎app/core/processAttribution.test.tsx‎
Lines changed: 80 additions & 0 deletions b/‎app/core/processAttribution.test.tsx‎
Lines changed: 80 additions & 0 deletions
diff --git a/‎app/core/processAttribution.tsx‎
Lines changed: 7 additions & 1 deletion b/‎app/core/processAttribution.tsx‎
Lines changed: 7 additions & 1 deletion
@@ -6,6 +6,14 @@ import { processAttribution } from './processAttribution';
 import { AnalyticsEventBuilder } from '../util/analytics/AnalyticsEventBuilder';
 import { analytics } from '../util/analytics/analytics';
 import ReduxService, { ReduxStore } from './redux';
+import { saveAttribution } from './redux/slices/attribution';
+
+function createMockReduxStore(): ReduxStore {
+  return {
+    dispatch: jest.fn(),
+    getState: jest.fn(() => ({})),
+  } as unknown as ReduxStore;
+}
 
 jest.mock('./DeeplinkManager/utils/extractURLParams', () => jest.fn());
 
@@ -86,9 +94,8 @@ describe('AppStateEventListener', () => {
   });
 
   it('tracks event when app becomes active and attribution data is available', () => {
-    jest
-      .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+    const mockStore = createMockReduxStore();
+    jest.spyOn(ReduxService, 'store', 'get').mockReturnValue(mockStore);
     const mockAttribution = {
       attributionId: 'test123',
       utm_source: 'source',
@@ -104,6 +111,14 @@ describe('AppStateEventListener', () => {
     mockAppStateListener('active');
     jest.advanceTimersByTime(2000);
 
+    expect(mockStore.dispatch).toHaveBeenCalledWith(
+      saveAttribution({
+        attribution_id: 'test123',
+        utm_source: 'source',
+        utm_medium: 'medium',
+        utm_campaign: 'campaign',
+      }),
+    );
     expect(AnalyticsEventBuilder.createEventBuilder).toHaveBeenCalledWith(
       MetaMetricsEvents.APP_OPENED,
     );
@@ -114,12 +129,46 @@ describe('AppStateEventListener', () => {
     expect(mockAnalytics.trackEvent).toHaveBeenCalledWith(
       mockEventBuilder.build(),
     );
+    expect(appStateManager.currentDeeplink).toBeNull();
+  });
+
+  it('clears currentDeeplink after processing so a later resume does not re-save attribution', () => {
+    const mockStore = createMockReduxStore();
+    jest.spyOn(ReduxService, 'store', 'get').mockReturnValue(mockStore);
+    (processAttribution as jest.Mock)
+      .mockReturnValueOnce({
+        attributionId: 'x',
+        utm_source: 'y',
+      })
+      .mockReturnValue(undefined);
+
+    appStateManager.setCurrentDeeplink('metamask://x');
+    mockAppStateListener('background');
+    mockAppStateListener('active');
+    jest.advanceTimersByTime(2000);
+
+    expect(appStateManager.currentDeeplink).toBeNull();
+    expect(mockStore.dispatch).toHaveBeenCalledWith(
+      saveAttribution({
+        attribution_id: 'x',
+        utm_source: 'y',
+      }),
+    );
+
+    (mockStore.dispatch as jest.Mock).mockClear();
+    mockAppStateListener('background');
+    mockAppStateListener('active');
+    jest.advanceTimersByTime(2000);
+
+    expect(mockStore.dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: saveAttribution.type }),
+    );
   });
 
   it('tracks event when app becomes active without attribution data', () => {
     jest
       .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+      .mockReturnValue(createMockReduxStore());
     (processAttribution as jest.Mock).mockReturnValue(undefined);
 
     mockAppStateListener('background');
@@ -164,7 +213,7 @@ describe('AppStateEventListener', () => {
     jest.clearAllMocks();
     jest
       .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+      .mockReturnValue(createMockReduxStore());
     const testError = new Error('Test error');
     (processAttribution as jest.Mock).mockImplementation(() => {
       throw testError;
@@ -206,7 +255,7 @@ describe('AppStateEventListener', () => {
     jest.clearAllMocks();
     jest
       .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+      .mockReturnValue(createMockReduxStore());
     (processAttribution as jest.Mock).mockReturnValue(undefined);
 
     mockAppStateListener('background');
@@ -225,7 +274,7 @@ describe('AppStateEventListener', () => {
     jest.clearAllMocks();
     jest
       .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+      .mockReturnValue(createMockReduxStore());
     (processAttribution as jest.Mock).mockReturnValue(undefined);
 
     // Simulate iOS background → inactive → active sequence
@@ -244,7 +293,7 @@ describe('AppStateEventListener', () => {
     jest.clearAllMocks();
     jest
       .spyOn(ReduxService, 'store', 'get')
-      .mockReturnValue({} as unknown as ReduxStore);
+      .mockReturnValue(createMockReduxStore());
     (processAttribution as jest.Mock).mockReturnValue(undefined);
 
     // Simulate iOS system permission dialog: active → inactive → active
 
@@ -4,6 +4,8 @@ import { MetaMetricsEvents } from './Analytics';
 import { AnalyticsEventBuilder } from '../util/analytics/AnalyticsEventBuilder';
 import { analytics } from '../util/analytics/analytics';
 import { processAttribution } from './processAttribution';
+import { saveAttribution } from './redux/slices/attribution';
+import { attributionPayloadFromProcessAttribution } from './redux/slices/attributionFromSources';
 import DevLogger from './SDKConnect/utils/DevLogger';
 import ReduxService from './redux';
 import generateDeviceAnalyticsMetaData from '../util/metrics';
@@ -90,6 +92,13 @@ export class AppStateEventListener {
         currentDeeplink: this.currentDeeplink,
         store: ReduxService.store,
       });
+      if (attribution) {
+        const persistedPayload =
+          attributionPayloadFromProcessAttribution(attribution);
+        if (persistedPayload) {
+          ReduxService.store.dispatch(saveAttribution(persistedPayload));
+        }
+      }
       // Note: User identification is handled when settings change individually
       // We only track the APP_OPENED event on app state transitions
       const appOpenedEventBuilder = AnalyticsEventBuilder.createEventBuilder(
@@ -104,6 +113,9 @@ export class AppStateEventListener {
         appOpenedEventBuilder.addProperties(attribution);
       }
       analytics.trackEvent(appOpenedEventBuilder.build());
+      // One-shot use for attribution: keeping currentDeeplink causes every
+      // background→active cycle to re-save and reset capturedAt (TTL).
+      this.currentDeeplink = null;
     } catch (error) {
       Logger.error(
         error as Error,
 
@@ -1,5 +1,6 @@
 import { handleDeeplink } from '../handleDeeplink';
 import { checkForDeeplink } from '../../../../../actions/user';
+import { saveAttribution } from '../../../../redux/slices/attribution';
 import ReduxService from '../../../../redux';
 import Logger from '../../../../../util/Logger';
 import { AppStateEventProcessor } from '../../../../AppStateEventListener';
@@ -22,6 +23,9 @@ jest.mock('../../../../redux', () => ({
   default: {
     store: {
       dispatch: jest.fn(),
+      getState: jest.fn(() => ({
+        security: { dataCollectionForMarketing: true },
+      })),
     },
   },
 }));
@@ -67,6 +71,7 @@ jest.mock('../../../util/deeplinks/deepLinkAnalytics', () => ({
 
 describe('handleDeeplink', () => {
   const mockDispatch = ReduxService.store.dispatch as jest.Mock;
+  const mockGetState = ReduxService.store.getState as jest.Mock;
   const mockCheckForDeeplink = checkForDeeplink as jest.Mock;
   const mockLoggerError = Logger.error as jest.Mock;
   const mockSetCurrentDeeplink =
@@ -75,10 +80,12 @@ describe('handleDeeplink', () => {
   const mockHandleMwpDeeplink = SDKConnectV2.handleMwpDeeplink as jest.Mock;
   const mockTrackEvent = analytics.trackEvent as jest.Mock;
   const mockDetectAppInstallation = detectAppInstallation as jest.Mock;
-
   beforeEach(() => {
     jest.clearAllMocks();
     mockIsMwpDeeplink.mockReturnValue(false);
+    mockGetState.mockReturnValue({
+      security: { dataCollectionForMarketing: true },
+    });
   });
 
   it('processes valid URI and dispatch checkForDeeplink', () => {
@@ -92,6 +99,36 @@ describe('handleDeeplink', () => {
     expect(mockLoggerError).not.toHaveBeenCalled();
   });
 
+  it('dispatches saveAttribution when marketing consent is on and URI has acquisition params', () => {
+    const testUri =
+      'metamask://open?utm_source=email&utm_campaign=spring&attribution_id=abc123';
+
+    handleDeeplink({ uri: testUri });
+
+    expect(mockDispatch).toHaveBeenCalledWith(
+      saveAttribution({
+        utm_source: 'email',
+        utm_campaign: 'spring',
+        attribution_id: 'abc123',
+      }),
+    );
+    expect(mockDispatch).toHaveBeenCalledWith({ type: 'CHECK_FOR_DEEPLINK' });
+  });
+
+  it('does not dispatch saveAttribution when marketing consent is off', () => {
+    mockGetState.mockReturnValue({
+      security: { dataCollectionForMarketing: false },
+    });
+    const testUri = 'metamask://open?utm_source=email';
+
+    handleDeeplink({ uri: testUri });
+
+    expect(mockDispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: saveAttribution.type }),
+    );
+    expect(mockDispatch).toHaveBeenCalledWith({ type: 'CHECK_FOR_DEEPLINK' });
+  });
+
   it('processes valid URI with source and passes source to setCurrentDeeplink', () => {
     const testUri = 'metamask://test-deeplink';
     const testSource = 'push-notification';
 
@@ -1,3 +1,5 @@
+import { saveAttribution } from '../../../redux/slices/attribution';
+import { attributionPayloadFromDeeplink } from '../../../redux/slices/attributionFromSources';
 import { checkForDeeplink } from '../../../../actions/user';
 import Logger from '../../../../util/Logger';
 import { AppStateEventProcessor } from '../../../AppStateEventListener';
@@ -30,6 +32,15 @@ export function handleDeeplink(opts: { uri?: string; source?: string }) {
   try {
     if (uri && typeof uri === 'string') {
       AppStateEventProcessor.setCurrentDeeplink(uri, source);
+      if (
+        ReduxService.store.getState().security.dataCollectionForMarketing ===
+        true
+      ) {
+        const payload = attributionPayloadFromDeeplink(uri);
+        if (payload) {
+          ReduxService.store.dispatch(saveAttribution(payload));
+        }
+      }
       dispatch(checkForDeeplink());
     }
   } catch (e) {
 
@@ -22,6 +22,7 @@ export interface DeeplinkUrlParams {
   originatorInfo?: string;
   request?: string;
   attributionId?: string;
+  attribution_id?: string;
   utm_source?: string;
   utm_medium?: string;
   utm_campaign?: string;
 
@@ -100,6 +100,86 @@ describe('processAttribution', () => {
     });
   });
 
+  it('resolves attribution_id (snake_case) when attributionId (camelCase) is absent', () => {
+    (store.getState as jest.Mock).mockReturnValue({
+      security: { dataCollectionForMarketing: true },
+    });
+    (extractURLParams as jest.Mock).mockReturnValue({
+      params: {
+        attributionId: '',
+        attribution_id: 'snake-abc',
+        utm_source: 'twitter',
+        utm_medium: '',
+        utm_campaign: '',
+        utm_term: '',
+        utm_content: '',
+      },
+    });
+
+    const result = processAttribution({
+      currentDeeplink:
+        'metamask://connect?attribution_id=snake-abc&utm_source=twitter',
+      store,
+    });
+    expect(result).toEqual(
+      expect.objectContaining({ attributionId: 'snake-abc' }),
+    );
+  });
+
+  it('prefers camelCase attributionId over snake_case attribution_id', () => {
+    (store.getState as jest.Mock).mockReturnValue({
+      security: { dataCollectionForMarketing: true },
+    });
+    (extractURLParams as jest.Mock).mockReturnValue({
+      params: {
+        attributionId: 'camel-abc',
+        attribution_id: 'snake-abc',
+        utm_source: '',
+        utm_medium: '',
+        utm_campaign: '',
+        utm_term: '',
+        utm_content: '',
+      },
+    });
+
+    const result = processAttribution({
+      currentDeeplink:
+        'metamask://connect?attributionId=camel-abc&attribution_id=snake-abc',
+      store,
+    });
+    expect(result).toEqual(
+      expect.objectContaining({ attributionId: 'camel-abc' }),
+    );
+  });
+
+  it('does not populate attributionId when both camelCase and snake_case IDs are blank', () => {
+    (store.getState as jest.Mock).mockReturnValue({
+      security: { dataCollectionForMarketing: true },
+    });
+    (extractURLParams as jest.Mock).mockReturnValue({
+      params: {
+        attributionId: '',
+        attribution_id: '   ',
+        utm_source: 'news',
+        utm_medium: '',
+        utm_campaign: '',
+        utm_term: '',
+        utm_content: '',
+      },
+    });
+
+    const result = processAttribution({
+      currentDeeplink: 'metamask://connect',
+      store,
+    });
+    expect(result).toEqual(
+      expect.objectContaining({
+        attributionId: undefined,
+        utm_source: 'news',
+      }),
+    );
+  });
+
   it('handles empty UTM parameters gracefully', () => {
     (store.getState as jest.Mock).mockReturnValue({
       security: { dataCollectionForMarketing: true },
 
@@ -35,15 +35,21 @@ export function processAttribution({
     const { params } = extractURLParams(currentDeeplink);
     const {
       attributionId,
+      attribution_id,
       utm_source,
       utm_medium,
       utm_campaign,
       utm_term,
       utm_content,
     } = params;
 
+    // Prefer camelCase attributionId; fall back to snake_case attribution_id
+    // so URLs using either form are handled consistently.
+    const resolvedAttributionId =
+      attributionId?.trim() || attribution_id?.trim() || undefined;
+
     return {
-      attributionId,
+      attributionId: resolvedAttributionId,
       utm_source,
       utm_medium,
       utm_campaign,