fix(predict): hide child more-market cards from feed (#30154)

# **Description**

Filters Polymarket "more market" child events out of Predict feed
surfaces without changing raw pagination behavior.

Polymarket marks child/more-market events with `parentEventId`. This PR
maps that API field to `PredictMarket.parentMarketId`, then filters
parented markets from feed and featured carousel render data. Pagination
still uses the raw page size before filtering, so infinite scroll can
continue even when a page contains hidden child markets.

## **Changelog**

CHANGELOG entry: Fixed child prediction markets appearing as standalone
cards in the Predict feed.

## **Related issues**

Fixes: PRED-865

## **Manual testing steps**

```gherkin
Feature: Predict feed more-market filtering

  Scenario: user scrolls the Predict feed
    Given Polymarket returns feed events that include child events with parentEventId

    When user opens the Predict feed
    Then child more-market cards are not rendered as standalone cards

    When user scrolls to the end of the visible feed page
    Then the feed continues loading the next raw page when available
```

## **Screenshots/Recordings**

N/A. Logic-only feed filtering change covered by unit tests.

### **Before**

N/A

### **After**

N/A

## **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
- [ ] 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.

#### Performance checks (if applicable)

- [ ] I've tested on Android
- [ ] I've tested with a power user scenario
- [ ] I've instrumented key operations with Sentry traces for production
performance metrics

## **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 which markets are surfaced in the Predict feed/carousel by
filtering out events with `parentMarketId`, which could inadvertently
hide valid markets or impact pagination edge-cases despite added tests.
> 
> **Overview**
> Filters Polymarket “more-market” child events out of Predict feed
surfaces.
> 
> This maps Polymarket `parentEventId` onto
`PredictMarket.parentMarketId` (now nullable) during event parsing, then
adds `filterStandaloneMarkets` and applies it in `usePredictMarketData`
and `useFeaturedCarouselData` so only standalone markets render.
Pagination/`hasMore` behavior continues to use the *raw* page size
before filtering, with new unit tests covering filtering and offset
handling.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
7c7379a. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: caieu

app/components/UI/Predict/hooks/useFeaturedCarouselData.test.ts

@@ -103,6 +103,26 @@ describe('useFeaturedCarouselData', () => {
     expect(result.current.error).toBeNull();
   });
 
+  it('filters child more-market cards', async () => {
+    const { Wrapper } = createWrapper();
+    const parentMarket = createMockMarket({ id: 'parent-market' });
+    const childMarket = createMockMarket({
+      id: 'child-market',
+      parentMarketId: 'parent-market',
+    });
+    mockGetCarouselMarkets.mockResolvedValue([parentMarket, childMarket]);
+
+    const { result } = renderHook(() => useFeaturedCarouselData(), {
+      wrapper: Wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.markets).toEqual([parentMarket]);
+  });
+
   it('returns error when controller throws', async () => {
     const { Wrapper } = createWrapper();
     mockGetCarouselMarkets.mockRejectedValue(new Error('Network error'));

app/components/UI/Predict/hooks/useFeaturedCarouselData.ts

@@ -7,6 +7,7 @@ import { predictQueries } from '../queries';
 import { selectPredictUpDownEnabledFlag } from '../selectors/featureFlags';
 import type { PredictMarket } from '../types';
 import { isCryptoUpDown } from '../utils/cryptoUpDown';
+import { filterStandaloneMarkets } from '../utils/feed';
 import { ensureError } from '../utils/predictErrorHandler';
 
 export interface UseFeaturedCarouselDataResult {
@@ -40,7 +41,7 @@ export const useFeaturedCarouselData = (): UseFeaturedCarouselDataResult => {
   }, [query.error]);
 
   const markets = useMemo(() => {
-    const data = query.data ?? [];
+    const data = filterStandaloneMarkets(query.data ?? []);
     if (upDownEnabled) {
       return data;
     }

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

@@ -219,6 +219,63 @@ describe('usePredictMarketData', () => {
     );
   });
 
+  it('filters child more-market cards without disabling pagination', async () => {
+    const rawMarkets = Array.from({ length: 20 }, (_, index) => ({
+      ...mockMarketData[0],
+      id: `market-${index}`,
+      slug: `market-${index}`,
+      parentMarketId: index >= 18 ? 'parent-market' : undefined,
+    }));
+    mockGetMarkets.mockResolvedValue(rawMarkets);
+
+    const { result } = renderHook(() => usePredictMarketData({ pageSize: 20 }));
+
+    await waitFor(() => {
+      expect(result.current.isFetching).toBe(false);
+    });
+
+    expect(result.current.marketData).toHaveLength(18);
+    expect(result.current.marketData.map((market) => market.id)).toEqual(
+      rawMarkets.slice(0, 18).map((market) => market.id),
+    );
+    expect(result.current.hasMore).toBe(true);
+  });
+
+  it('uses raw page offsets when loading more after child cards are filtered', async () => {
+    const firstRawPage = Array.from({ length: 20 }, (_, index) => ({
+      ...mockMarketData[0],
+      id: `first-page-market-${index}`,
+      slug: `first-page-market-${index}`,
+      parentMarketId: index >= 18 ? 'parent-market' : undefined,
+    }));
+    const secondRawPage = Array.from({ length: 5 }, (_, index) => ({
+      ...mockMarketData[0],
+      id: `second-page-market-${index}`,
+      slug: `second-page-market-${index}`,
+    }));
+
+    mockGetMarkets
+      .mockResolvedValueOnce(firstRawPage)
+      .mockResolvedValueOnce(secondRawPage);
+
+    const { result } = renderHook(() => usePredictMarketData({ pageSize: 20 }));
+
+    await waitFor(() => {
+      expect(result.current.isFetching).toBe(false);
+    });
+
+    await act(async () => {
+      await result.current.fetchMore();
+    });
+
+    expect(mockGetMarkets).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ limit: 20, offset: 20 }),
+    );
+    expect(result.current.marketData).toHaveLength(23);
+    expect(result.current.hasMore).toBe(false);
+  });
+
   it('handle null market data', async () => {
     mockGetMarkets.mockResolvedValue(null);
 

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

@@ -13,6 +13,7 @@ import Logger from '../../../../util/Logger';
 import { PREDICT_CONSTANTS } from '../constants/errors';
 import { ensureError } from '../utils/predictErrorHandler';
 import { PredictCategory, PredictMarket } from '../types';
+import { filterStandaloneMarkets } from '../utils/feed';
 
 export interface UsePredictMarketDataOptions {
   q?: string;
@@ -147,12 +148,13 @@ export const usePredictMarketData = (
 
             const hasMoreData = markets.length >= pageSize;
             setHasMore(hasMoreData);
+            const visibleMarkets = filterStandaloneMarkets(markets);
 
             if (isLoadMore) {
               setMarketData((prevData) => {
                 // Use a Set to efficiently deduplicate by ID
                 const existingIds = new Set(prevData.map((event) => event.id));
-                const newEvents = markets.filter(
+                const newEvents = visibleMarkets.filter(
                   (event) => !existingIds.has(event.id),
                 );
                 const accumulated = [...prevData, ...newEvents];
@@ -162,7 +164,7 @@ export const usePredictMarketData = (
               currentOffsetRef.current += pageSize;
             } else {
               // Replace data for initial load or refresh
-              setMarketData(refine ? refine(markets) : markets);
+              setMarketData(refine ? refine(visibleMarkets) : visibleMarkets);
               setCurrentOffset(pageSize);
               currentOffsetRef.current = pageSize;
             }

app/components/UI/Predict/providers/polymarket/types.ts

@@ -124,7 +124,7 @@ export interface PolymarketApiEvent {
   period?: PredictGamePeriod;
   live?: boolean;
   ended?: boolean;
-  parentEventId?: string | number;
+  parentEventId?: string | number | null;
 }
 
 export interface PolymarketApiActivity {

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

@@ -746,4 +746,28 @@ describe('polymarket utils', () => {
       }),
     ).resolves.toBe(false);
   });
+
+  it('preserves parent market id when parsing Polymarket events', () => {
+    const event: PolymarketApiEvent = {
+      id: 'child-event',
+      slug: 'child-event',
+      title: 'Child Event',
+      description: 'Child event description',
+      icon: '',
+      closed: false,
+      series: [],
+      markets: [],
+      tags: [],
+      liquidity: 0,
+      volume: 0,
+      parentEventId: 'parent-market',
+    };
+
+    expect(parsePolymarketEvents([event], 'trending')).toEqual([
+      expect.objectContaining({
+        id: 'child-event',
+        parentMarketId: 'parent-market',
+      }),
+    ]);
+  });
 });

app/components/UI/Predict/providers/polymarket/utils.ts

@@ -1112,6 +1112,9 @@ export const parsePolymarketEvents = (
         volume: event.volume,
         game,
         ...(seriesData && { series: seriesData }),
+        ...(event.parentEventId !== undefined && {
+          parentMarketId: event.parentEventId,
+        }),
       };
     },
   );

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

@@ -116,6 +116,7 @@ export type PredictMarket = {
   volume: number;
   game?: PredictMarketGame;
   series?: PredictSeries;
+  parentMarketId?: string | number | null;
   childMarketIds?: string[];
 };
 

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

@@ -1,4 +1,4 @@
-import { deduplicateSeriesMarkets } from './feed';
+import { deduplicateSeriesMarkets, filterStandaloneMarkets } from './feed';
 import { Recurrence, type PredictMarket } from '../types';
 
 const createMockMarket = (
@@ -122,3 +122,31 @@ describe('deduplicateSeriesMarkets', () => {
     expect(result).toEqual([single]);
   });
 });
+
+describe('filterStandaloneMarkets', () => {
+  it('removes markets with a parent market id', () => {
+    const parent = createMockMarket('parent');
+    const emptyParent = createMockMarket('empty-parent', {
+      parentMarketId: '',
+    });
+    const nullParent = createMockMarket('null-parent', {
+      parentMarketId: null,
+    });
+    const child = createMockMarket('child', {
+      parentMarketId: 'parent',
+    });
+    const numericChild = createMockMarket('numeric-child', {
+      parentMarketId: 123,
+    });
+
+    const result = filterStandaloneMarkets([
+      parent,
+      emptyParent,
+      nullParent,
+      child,
+      numericChild,
+    ]);
+
+    expect(result).toEqual([parent, emptyParent, nullParent]);
+  });
+});

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

@@ -1,6 +1,21 @@
 import type { PredictMarket } from '../types';
 import { isCryptoUpDown } from './cryptoUpDown';
 
+export function isStandaloneMarket(market: PredictMarket): boolean {
+  const { parentMarketId } = market;
+  return (
+    parentMarketId === undefined ||
+    parentMarketId === null ||
+    String(parentMarketId).trim() === ''
+  );
+}
+
+export function filterStandaloneMarkets(
+  markets: PredictMarket[],
+): PredictMarket[] {
+  return markets.filter(isStandaloneMarket);
+}
+
 /**
  * Keeps only the first occurrence of each Crypto Up/Down series slug.
  * Non-Up/Down markets pass through unchanged.