feat(predict): add feed grouping logic for Crypto Up/Down series (#28500)

## **Description**

The Crypto Up/Down feature (Epic PRED-777) needs feed-level
deduplication so that recurring series events (e.g., "BTC Up or Down 5m"
repeating every 5 minutes) don't show multiple cards. This PR implements
the Feed Grouping Logic (PRED-785), which ensures only the first
occurrence of each Crypto Up/Down series slug appears in any market
list.

**Architecture:**

Deduplication is implemented as a `refine` callback on
`usePredictMarketData`, running during data accumulation (not after).
This prevents pagination under-fill — the data layer itself produces
deduplicated results, so the FlashList never sees duplicates.

**What this adds:**
- **Predicate**: `isCryptoUpDown(market)` — type guard returning true
when a market has both `series` metadata AND the `up-or-down` tag.
Narrows to `PredictMarket & { series: PredictSeries }`.
- **Filter**: `deduplicateSeriesMarkets(markets)` — pure function that
keeps only the first occurrence of each Up/Down series slug, preserving
feed order for all other markets.
- **Data hook extension**: `usePredictMarketData` now accepts an
optional `refine` callback that post-processes accumulated data during
fetch. Both the feed and search overlay pass `deduplicateSeriesMarkets`
when the flag is on.
- **Feature flag**: `predictUpDownEnabled` resolved via
`resolvePredictFeatureFlags()`, version-gated, defaults to `false`
(off).

**What's NOT in scope:**
- `PredictUpDownCard` component (renders the consolidated card —
separate ticket)
- `PredictUpDownDetails` detail screen (separate ticket)
- `isCryptoUpDown` branch in `PredictMarket.tsx` (ships with the card
component)

## **Changelog**

CHANGELOG entry: null

## **Related issues**

Fixes: https://consensyssoftware.atlassian.net/browse/PRED-785

## **Manual testing steps**

```gherkin
Feature: Crypto Up/Down Feed Deduplication

  Background:
    Given I am logged into MetaMask Mobile
    And Predict feature is enabled
    And predictUpDownEnabled feature flag is enabled

  Scenario: duplicate Crypto Up/Down events are removed from the feed
    Given I am on the Predict feed
    And the feed contains multiple events from the same Crypto Up/Down series

    When the feed loads
    Then only the first occurrence of each series slug appears in the list
    And non-series markets are unaffected

  Scenario: duplicate Crypto Up/Down events are removed from search
    Given I open the search overlay
    And I search for a term matching Crypto Up/Down series events

    When results load
    Then only the first occurrence of each series slug appears
    And non-series search results are unaffected

  Scenario: feed renders normally when flag is disabled
    Given predictUpDownEnabled feature flag is disabled
    And I am on the Predict feed

    When the feed loads
    Then all markets render as individual cards (no deduplication)
    And no regressions in existing feed behavior

  Scenario: pagination does not produce duplicate series cards
    Given I am on the Predict feed
    And I scroll to trigger infinite scroll loading

    When new pages of data are fetched
    Then no duplicate series cards appear regardless of page boundaries
```

## **Screenshots/Recordings**

**Note:** changed the crypt tab to show only 5m markets for testing
purposes

### **Before**

<img width="400" alt="Simulator Screenshot - mm-blue - 2026-04-08 at 13
09 54"
src="https://github.com/user-attachments/assets/2c66f266-a920-461f-94a8-782a433f0683"
/>

### **After**

<img width="400" alt="Simulator Screenshot - mm-blue - 2026-04-08 at 13
09 20"
src="https://github.com/user-attachments/assets/649e7ec3-3d83-47a4-bf4f-a9155b85b95c"
/>


## **Pre-merge author checklist**

- [x] 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).
- [x] I've completed the PR template to the best of my ability
- [x] I've included tests if applicable
- [x] I've documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [x] 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]
> **Medium Risk**
> Changes how Predict market lists are accumulated/paginated by adding
an optional `refine` post-processor, which can affect ordering and
pagination behavior when enabled. Guarded by a new version-gated remote
flag, but mistakes could hide markets or cause inconsistent list
contents.
> 
> **Overview**
> Adds an optional `refine(markets)` callback to `usePredictMarketData`
so callers can post-process both initial results and accumulated
pagination data.
> 
> Introduces Crypto Up/Down feed deduplication utilities
(`isCryptoUpDown`, `deduplicateSeriesMarkets`) and wires them into the
Predict feed and search results when the new version-gated remote flag
`predictUpDown`/`predictUpDownEnabled` is on.
> 
> Extends Predict feature-flag plumbing (types, resolver, selector,
registry) and adds/updates unit tests to cover the new flag behavior and
deduplication logic.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
c0c2051. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: matallui

app/components/UI/Predict/hooks/usePredictMarketData.tsx

@@ -13,6 +13,7 @@ export interface UsePredictMarketDataOptions {
   category?: PredictCategory;
   pageSize?: number;
   customQueryParams?: string;
+  refine?: (markets: PredictMarket[]) => PredictMarket[];
 }
 
 export interface UsePredictMarketDataResult {
@@ -37,6 +38,7 @@ export const usePredictMarketData = (
     q,
     pageSize = 20,
     customQueryParams,
+    refine,
   } = options;
   const [marketData, setMarketData] = useState<PredictMarket[]>([]);
   const [isLoading, setIsLoading] = useState(true);
@@ -119,18 +121,19 @@ export const usePredictMarketData = (
 
             if (isLoadMore) {
               setMarketData((prevData) => {
-                // Use a Map to efficiently deduplicate by ID
+                // Use a Set to efficiently deduplicate by ID
                 const existingIds = new Set(prevData.map((event) => event.id));
                 const newEvents = markets.filter(
                   (event) => !existingIds.has(event.id),
                 );
-                return [...prevData, ...newEvents];
+                const accumulated = [...prevData, ...newEvents];
+                return refine ? refine(accumulated) : accumulated;
               });
               setCurrentOffset((prev) => prev + pageSize);
               currentOffsetRef.current += pageSize;
             } else {
               // Replace data for initial load or refresh
-              setMarketData(markets);
+              setMarketData(refine ? refine(markets) : markets);
               setCurrentOffset(pageSize);
               currentOffsetRef.current = pageSize;
             }
@@ -188,7 +191,7 @@ export const usePredictMarketData = (
         setIsLoadingMore(false);
       }
     },
-    [category, q, pageSize, customQueryParams],
+    [category, q, pageSize, customQueryParams, refine],
   );
 
   const loadMore = useCallback(async () => {

app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts

@@ -259,6 +259,7 @@ describe('PolymarketProvider', () => {
     },
     fakOrdersEnabled: false,
     predictWithAnyTokenEnabled: false,
+    predictUpDownEnabled: false,
   };
   const createProvider = (
     featureFlagsOverride?: Partial<PredictFeatureFlags>,

app/components/UI/Predict/selectors/featureFlags/index.test.ts

@@ -6,6 +6,7 @@ import {
   selectPredictGtmOnboardingModalEnabledFlag,
   selectPredictHomeFeaturedVariant,
   selectPredictHotTabFlag,
+  selectPredictUpDownEnabledFlag,
   selectPredictWithAnyTokenEnabledFlag,
 } from '.';
 import mockedEngine from '../../../../../core/__mocks__/MockedEngine';
@@ -1122,4 +1123,136 @@ describe('Predict Feature Flag Selectors', () => {
       expect(result).toBe('carousel');
     });
   });
+
+  describe('selectPredictUpDownEnabledFlag', () => {
+    it('returns true when remote flag is enabled and version check passes', () => {
+      mockHasMinimumRequiredVersion.mockReturnValue(true);
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: {
+              remoteFeatureFlags: {
+                predictUpDown: {
+                  enabled: true,
+                  minimumVersion: '1.0.0',
+                },
+              },
+              cacheTimestamp: 0,
+            },
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(true);
+    });
+
+    it('returns false when remote flag is disabled', () => {
+      mockHasMinimumRequiredVersion.mockReturnValue(true);
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: {
+              remoteFeatureFlags: {
+                predictUpDown: {
+                  enabled: false,
+                  minimumVersion: '1.0.0',
+                },
+              },
+              cacheTimestamp: 0,
+            },
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when app version is below minimum required version', () => {
+      mockHasMinimumRequiredVersion.mockReturnValue(false);
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: {
+              remoteFeatureFlags: {
+                predictUpDown: {
+                  enabled: true,
+                  minimumVersion: '99.0.0',
+                },
+              },
+              cacheTimestamp: 0,
+            },
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(false);
+    });
+
+    it('defaults to false when remote flag is null', () => {
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: {
+              remoteFeatureFlags: {
+                predictUpDown: null,
+              },
+              cacheTimestamp: 0,
+            },
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(false);
+    });
+
+    it('defaults to false when remote feature flags are empty', () => {
+      const result = selectPredictUpDownEnabledFlag(mockedEmptyFlagsState);
+
+      expect(result).toBe(false);
+    });
+
+    it('defaults to false when controller is undefined', () => {
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: undefined,
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(false);
+    });
+
+    it('defaults to false when remote flag is invalid', () => {
+      const state = {
+        engine: {
+          backgroundState: {
+            RemoteFeatureFlagController: {
+              remoteFeatureFlags: {
+                predictUpDown: {
+                  enabled: 'invalid',
+                  minimumVersion: 123,
+                },
+              },
+              cacheTimestamp: 0,
+            },
+          },
+        },
+      };
+
+      const result = selectPredictUpDownEnabledFlag(state);
+
+      expect(result).toBe(false);
+    });
+  });
 });

app/components/UI/Predict/selectors/featureFlags/index.ts

@@ -137,6 +137,11 @@ export const selectPredictWithAnyTokenEnabledFlag = createSelector(
   (flags) => flags.predictWithAnyTokenEnabled,
 );
 
+export const selectPredictUpDownEnabledFlag = createSelector(
+  selectPredictFeatureFlags,
+  (flags) => flags.predictUpDownEnabled,
+);
+
 export const selectPredictFeaturedCarouselEnabledFlag = createSelector(
   selectRemoteFeatureFlags,
   (remoteFeatureFlags) =>

app/components/UI/Predict/types/flags.ts

@@ -24,6 +24,7 @@ export interface PredictFeatureFlags {
   marketHighlightsFlag: PredictMarketHighlightsFlag;
   fakOrdersEnabled: boolean;
   predictWithAnyTokenEnabled: boolean;
+  predictUpDownEnabled: boolean;
 }
 
 export interface PredictHotTabFlag extends VersionGatedFeatureFlag {

app/components/UI/Predict/utils/cryptoUpDown.test.ts

@@ -0,0 +1,118 @@
+import { isCryptoUpDown, UP_OR_DOWN_TAG } from './cryptoUpDown';
+import { Recurrence, type PredictMarket } from '../types';
+
+const createMockMarket = (
+  overrides: Partial<PredictMarket> = {},
+): PredictMarket =>
+  ({
+    id: 'market-1',
+    providerId: 'polymarket',
+    slug: 'market-1',
+    title: 'Market 1',
+    description: 'Description',
+    image: 'https://example.com/img.png',
+    status: 'open',
+    recurrence: Recurrence.NONE,
+    category: 'crypto',
+    tags: [],
+    outcomes: [],
+    liquidity: 100,
+    volume: 200,
+    ...overrides,
+  }) as PredictMarket;
+
+describe('cryptoUpDown utilities', () => {
+  describe('UP_OR_DOWN_TAG', () => {
+    it('equals "up-or-down"', () => {
+      expect(UP_OR_DOWN_TAG).toBe('up-or-down');
+    });
+  });
+
+  describe('isCryptoUpDown', () => {
+    it('returns true when market has series and up-or-down tag', () => {
+      const market = createMockMarket({
+        series: {
+          id: 's1',
+          slug: 'btc-up-or-down-5m',
+          title: 'BTC Up or Down',
+          recurrence: '5m',
+        },
+        tags: ['crypto', 'up-or-down'],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(true);
+    });
+
+    it('returns false when market has series but no up-or-down tag', () => {
+      const market = createMockMarket({
+        series: {
+          id: 's1',
+          slug: 'elon-tweets-monthly',
+          title: 'Elon Tweets',
+          recurrence: 'monthly',
+        },
+        tags: ['crypto', 'entertainment'],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when market has up-or-down tag but no series', () => {
+      const market = createMockMarket({
+        series: undefined,
+        tags: ['crypto', 'up-or-down'],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when market has neither series nor up-or-down tag', () => {
+      const market = createMockMarket({
+        series: undefined,
+        tags: ['politics'],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when market has empty tags array and series', () => {
+      const market = createMockMarket({
+        series: {
+          id: 's1',
+          slug: 'btc-up-or-down-5m',
+          title: 'BTC',
+          recurrence: '5m',
+        },
+        tags: [],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns true when up-or-down tag is among many tags', () => {
+      const market = createMockMarket({
+        series: {
+          id: 's1',
+          slug: 'eth-up-or-down-1h',
+          title: 'ETH Up or Down',
+          recurrence: '1h',
+        },
+        tags: ['crypto', 'trending', 'up-or-down', 'featured'],
+      });
+
+      const result = isCryptoUpDown(market);
+
+      expect(result).toBe(true);
+    });
+  });
+});

app/components/UI/Predict/utils/cryptoUpDown.ts

@@ -0,0 +1,14 @@
+import type { PredictMarket, PredictSeries } from '../types';
+
+export const UP_OR_DOWN_TAG = 'up-or-down';
+
+/**
+ * Type guard: narrows to a market with a guaranteed `series` field.
+ * Returns true when a market has series metadata AND the "up-or-down" tag.
+ * Regular series markets (e.g., recurring tweet counts) are excluded.
+ */
+export function isCryptoUpDown(
+  market: PredictMarket,
+): market is PredictMarket & { series: PredictSeries } {
+  return market.series != null && market.tags.includes(UP_OR_DOWN_TAG);
+}