MetaMask
diff --git a/‎app/components/Nav/App/App.test.tsx‎
Lines changed: 40 additions & 1 deletion b/‎app/components/Nav/App/App.test.tsx‎
Lines changed: 40 additions & 1 deletion
diff --git a/‎app/components/Nav/App/App.tsx‎
Lines changed: 6 additions & 0 deletions b/‎app/components/Nav/App/App.tsx‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎app/components/UI/OptinMetrics/OptinMetrics.navigation.test.tsx‎
Lines changed: 324 additions & 0 deletions b/‎app/components/UI/OptinMetrics/OptinMetrics.navigation.test.tsx‎
Lines changed: 324 additions & 0 deletions
@@ -123,6 +123,9 @@ jest.mock('../../Views/QRTabSwitcher', () => () => (
 jest.mock('../../UI/OptinMetrics', () => () => (
   <MockView testID="mock-optin" />
 ));
+jest.mock('../../Views/OnboardingInterestQuestionnaire', () => () => (
+  <MockView testID="mock-onboarding-interest-questionnaire" />
+));
 jest.mock('../../Views/AccountStatus', () => () => (
   <MockView testID="mock-account-status" />
 ));
@@ -1728,7 +1731,43 @@ describe('App', () => {
       const { getByTestId } = renderAppAtRoute(routeState);
 
       await waitFor(() => {
-        expect(getByTestId('mock-onboarding')).toBeTruthy();
+        expect(getByTestId('mock-onboarding')).toBeOnTheScreen();
+      });
+    });
+
+    it('renders OnboardingInterestQuestionnaire when it is the active OnboardingNav route', async () => {
+      const routeState = {
+        index: 0,
+        routes: [
+          {
+            name: 'OnboardingRootNav',
+            state: {
+              index: 0,
+              routes: [
+                {
+                  name: 'OnboardingNav',
+                  state: {
+                    index: 0,
+                    routes: [
+                      {
+                        name: Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+                        params: { onComplete: jest.fn() },
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      };
+
+      const { getByTestId } = renderAppAtRoute(routeState);
+
+      await waitFor(() => {
+        expect(
+          getByTestId('mock-onboarding-interest-questionnaire'),
+        ).toBeOnTheScreen();
       });
     });
 
 
@@ -19,6 +19,7 @@ import ImportFromSecretRecoveryPhrase from '../../Views/ImportFromSecretRecovery
 import DeleteWalletModal from '../../../components/UI/DeleteWalletModal';
 import Main from '../Main';
 import OptinMetrics from '../../UI/OptinMetrics';
+import OnboardingInterestQuestionnaire from '../../Views/OnboardingInterestQuestionnaire';
 import SimpleWebview from '../../Views/SimpleWebview';
 import Logger from '../../../util/Logger';
 import { useSelector } from 'react-redux';
@@ -305,6 +306,11 @@ const OnboardingNav = () => {
         component={OptinMetrics}
         options={{ headerShown: false }}
       />
+      <Stack.Screen
+        name={Routes.ONBOARDING.INTEREST_QUESTIONNAIRE}
+        component={OnboardingInterestQuestionnaire}
+        options={{ headerShown: false, gestureEnabled: false }}
+      />
       <Stack.Screen
         name="AccountStatus"
         component={AccountStatus as ScreenComponent}
 
@@ -0,0 +1,324 @@
+import React from 'react';
+import OptinMetrics from './index.tsx';
+import { renderScreen } from '../../../util/test/renderWithProvider';
+import { fireEvent, screen, waitFor } from '@testing-library/react-native';
+import { strings } from '../../../../locales/i18n';
+import Device from '../../../util/device';
+import { createMockUseAnalyticsHook } from '../../../util/test/analyticsMock';
+import { useAnalytics } from '../../hooks/useAnalytics/useAnalytics';
+import { AnalyticsEventBuilder } from '../../../util/analytics/AnalyticsEventBuilder';
+import Routes from '../../../constants/navigation/Routes';
+import { analytics } from '../../../util/analytics/analytics';
+import Logger from '../../../util/Logger';
+
+jest.mock('../../hooks/useAnalytics/useAnalytics');
+
+jest.mock('../../../util/Logger', () => ({
+  __esModule: true,
+  default: {
+    error: jest.fn(),
+  },
+}));
+
+const mockOptinMetricsTestOnboardingSlice = {
+  events: [] as unknown[],
+  accountType: undefined as string | undefined,
+};
+
+jest.mock('react-redux', () => {
+  const actual = jest.requireActual('react-redux');
+  const rootState = jest.requireActual(
+    '../../../util/test/initial-root-state',
+  ).default;
+  return {
+    ...actual,
+    useSelector: jest.fn((selector) =>
+      selector({
+        ...rootState,
+        onboarding: {
+          ...rootState.onboarding,
+          events: mockOptinMetricsTestOnboardingSlice.events,
+          accountType: mockOptinMetricsTestOnboardingSlice.accountType,
+        },
+      }),
+    ),
+  };
+});
+
+const mockGetShouldShow = jest.fn();
+jest.mock(
+  '../../Views/OnboardingInterestQuestionnaire/useOnboardingInterestQuestionnaireEligibility',
+  () => ({
+    useOnboardingInterestQuestionnaireEligibility: () => mockGetShouldShow,
+  }),
+);
+
+jest.mock('../../../util/analytics/analytics', () => ({
+  analytics: {
+    isEnabled: jest.fn(() => true),
+    trackEvent: jest.fn(),
+    optIn: jest.fn().mockResolvedValue(undefined),
+    optOut: jest.fn().mockResolvedValue(undefined),
+    getAnalyticsId: jest
+      .fn()
+      .mockResolvedValue('123e4567-e89b-12d3-a456-426614174000'),
+    identify: jest.fn(),
+    trackView: jest.fn(),
+    isOptedIn: jest.fn().mockResolvedValue(false),
+  },
+}));
+
+jest.mock('../../../core/Analytics/MetaMetrics', () => ({
+  MetaMetricsEvents: jest.requireActual('../../../core/Analytics/MetaMetrics')
+    .MetaMetricsEvents,
+  getInstance: jest.fn(() => ({
+    createDataDeletionTask: jest.fn(),
+    checkDataDeleteStatus: jest.fn(),
+    getDeleteRegulationCreationDate: jest.fn(),
+    getDeleteRegulationId: jest.fn(),
+    isDataRecorded: jest.fn(),
+    updateDataRecordingFlag: jest.fn(),
+  })),
+}));
+
+jest.mock(
+  '../../../util/metrics/UserSettingsAnalyticsMetaData/generateUserProfileAnalyticsMetaData',
+  () => jest.fn().mockReturnValue({}),
+);
+
+jest.mock('../../../util/metrics/MultichainAPI/networkMetricUtils', () => ({
+  getConfiguredCaipChainIds: jest.fn().mockReturnValue(['eip155:1']),
+}));
+
+jest.mock(
+  '../../../util/metrics/DeviceAnalyticsMetaData/generateDeviceAnalyticsMetaData',
+  () => jest.fn().mockReturnValue({}),
+);
+
+jest.mock('../../../reducers/legalNotices', () => ({
+  isPastPrivacyPolicyDate: jest.fn().mockReturnValue(true),
+}));
+
+jest.mock('../../../util/device', () => ({
+  isMediumDevice: jest.fn(),
+  isAndroid: jest.fn(),
+  isIos: jest.fn(),
+  isLargeDevice: jest.fn(),
+  isIphoneX: jest.fn(),
+}));
+
+const mockNavigate = jest.fn();
+const mockReset = jest.fn();
+
+jest.mock('@react-navigation/native', () => {
+  const actual = jest.requireActual('@react-navigation/native');
+  return {
+    ...actual,
+    useNavigation: () => ({
+      navigate: mockNavigate,
+      reset: mockReset,
+      setOptions: jest.fn(),
+      goBack: jest.fn(),
+      dispatch: jest.fn(),
+    }),
+    useRoute: () => ({
+      key: 'OptinMetrics',
+      name: 'OptinMetrics',
+      params: undefined,
+    }),
+  };
+});
+
+const mockAnalytics = analytics as jest.Mocked<typeof analytics>;
+
+describe('OptinMetrics — interest questionnaire navigation branching', () => {
+  beforeEach(() => {
+    mockOptinMetricsTestOnboardingSlice.events = [];
+    mockOptinMetricsTestOnboardingSlice.accountType = undefined;
+    jest.clearAllMocks();
+    jest.mocked(useAnalytics).mockReturnValue(
+      createMockUseAnalyticsHook({
+        trackEvent: (event) => mockAnalytics.trackEvent(event),
+        createEventBuilder: AnalyticsEventBuilder.createEventBuilder,
+        enable: async (enable) => {
+          if (enable === false) {
+            await mockAnalytics.optOut();
+          } else {
+            await mockAnalytics.optIn();
+          }
+        },
+        identify: async (traits) => {
+          mockAnalytics.identify(traits);
+        },
+        isEnabled: () => mockAnalytics.isEnabled(),
+        getAnalyticsId: () => mockAnalytics.getAnalyticsId(),
+      }),
+    );
+    (Device.isMediumDevice as jest.Mock).mockReturnValue(false);
+    (Device.isAndroid as jest.Mock).mockReturnValue(false);
+    (Device.isIos as jest.Mock).mockReturnValue(true);
+    (Device.isLargeDevice as jest.Mock).mockReturnValue(false);
+    (Device.isIphoneX as jest.Mock).mockReturnValue(false);
+  });
+
+  describe('when basic usage data is unchecked', () => {
+    it('does not navigate to the interest questionnaire regardless of eligibility', async () => {
+      mockGetShouldShow.mockResolvedValue(true);
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByText(strings('privacy_policy.gather_basic_usage_title')),
+      );
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(mockNavigate).not.toHaveBeenCalledWith(
+          Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+          expect.anything(),
+        );
+      });
+    });
+  });
+
+  describe('when basic usage data is checked and eligibility returns false', () => {
+    it('calls navigation reset to HomeNav instead of navigating to questionnaire', async () => {
+      mockGetShouldShow.mockResolvedValue(false);
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(mockNavigate).not.toHaveBeenCalledWith(
+          Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+          expect.anything(),
+        );
+        expect(mockReset).toHaveBeenCalledWith(
+          expect.objectContaining({
+            routes: [{ name: Routes.ONBOARDING.HOME_NAV }],
+          }),
+        );
+      });
+    });
+  });
+
+  describe('when basic usage data is checked and eligibility throws', () => {
+    it('falls back to resetting navigation so onboarding is not blocked', async () => {
+      mockGetShouldShow.mockRejectedValue(new Error('eligibility failed'));
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(mockNavigate).not.toHaveBeenCalledWith(
+          Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+          expect.anything(),
+        );
+        expect(mockReset).toHaveBeenCalledWith(
+          expect.objectContaining({
+            routes: [{ name: Routes.ONBOARDING.HOME_NAV }],
+          }),
+        );
+      });
+    });
+
+    it('logs Error rejections from the eligibility check', async () => {
+      mockGetShouldShow.mockRejectedValue(new Error('eligibility failed'));
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(Logger.error).toHaveBeenCalledWith(
+          expect.objectContaining({ message: 'eligibility failed' }),
+          'OptinMetrics: interest questionnaire eligibility check failed',
+        );
+      });
+    });
+
+    it('wraps non-Error rejections before logging', async () => {
+      mockGetShouldShow.mockRejectedValue('string failure');
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(Logger.error).toHaveBeenCalledWith(
+          expect.objectContaining({ message: 'string failure' }),
+          'OptinMetrics: interest questionnaire eligibility check failed',
+        );
+      });
+    });
+  });
+
+  describe('when basic usage data is checked and eligibility returns true', () => {
+    it('navigates to the interest questionnaire with onComplete callback', async () => {
+      mockGetShouldShow.mockResolvedValue(true);
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(mockNavigate).toHaveBeenCalledWith(
+          Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+          expect.objectContaining({
+            onComplete: expect.any(Function),
+          }),
+        );
+      });
+    });
+
+    it('includes accountType in navigation params when onboarding account type is set in Redux', async () => {
+      mockGetShouldShow.mockResolvedValue(true);
+      mockOptinMetricsTestOnboardingSlice.accountType = 'imported';
+
+      renderScreen(OptinMetrics, { name: 'OptinMetrics' }, { state: {} });
+
+      fireEvent.press(
+        screen.getByRole('button', {
+          name: strings('privacy_policy.continue'),
+        }),
+      );
+
+      await waitFor(() => {
+        expect(mockNavigate).toHaveBeenCalledWith(
+          Routes.ONBOARDING.INTEREST_QUESTIONNAIRE,
+          expect.objectContaining({
+            onComplete: expect.any(Function),
+            accountType: 'imported',
+          }),
+        );
+      });
+    });
+  });
+});