MetaMask
diff --git a/‎app/components/UI/Predict/controllers/PredictController-method-action-types.ts‎
Lines changed: 6 additions & 0 deletions b/‎app/components/UI/Predict/controllers/PredictController-method-action-types.ts‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/controllers/PredictController.test.ts‎
Lines changed: 53 additions & 0 deletions b/‎app/components/UI/Predict/controllers/PredictController.test.ts‎
Lines changed: 53 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/controllers/PredictController.ts‎
Lines changed: 6 additions & 0 deletions b/‎app/components/UI/Predict/controllers/PredictController.ts‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/hooks/usePredictSeries.test.ts‎
Lines changed: 141 additions & 0 deletions b/‎app/components/UI/Predict/hooks/usePredictSeries.test.ts‎
Lines changed: 141 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/hooks/usePredictSeries.ts‎
Lines changed: 44 additions & 0 deletions b/‎app/components/UI/Predict/hooks/usePredictSeries.ts‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts‎
Lines changed: 87 additions & 0 deletions b/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts‎
Lines changed: 87 additions & 0 deletions
@@ -18,6 +18,11 @@ export type PredictControllerGetMarketAction = {
   handler: PredictController['getMarket'];
 };
 
+export type PredictControllerGetMarketSeriesAction = {
+  type: `PredictController:getMarketSeries`;
+  handler: PredictController['getMarketSeries'];
+};
+
 export type PredictControllerGetPriceHistoryAction = {
   type: `PredictController:getPriceHistory`;
   handler: PredictController['getPriceHistory'];
@@ -232,6 +237,7 @@ export type PredictControllerClearWithdrawTransactionAction = {
 export type PredictControllerMethodActions =
   | PredictControllerGetMarketsAction
   | PredictControllerGetMarketAction
+  | PredictControllerGetMarketSeriesAction
   | PredictControllerGetPriceHistoryAction
   | PredictControllerGetPricesAction
   | PredictControllerGetPositionsAction
 
@@ -9317,4 +9317,57 @@ describe('PredictController', () => {
       });
     });
   });
+
+  describe('getMarketSeries', () => {
+    it('delegates the params to the provider', async () => {
+      const params = {
+        seriesId: '10684',
+        endDateMin: '2026-04-06T00:00:00.000Z',
+        endDateMax: '2026-04-07T00:00:00.000Z',
+        limit: 10,
+      };
+
+      await withController(async ({ controller }) => {
+        mockPolymarketProvider.getMarketSeries = jest
+          .fn()
+          .mockResolvedValue([]);
+
+        await controller.getMarketSeries(params);
+
+        expect(mockPolymarketProvider.getMarketSeries).toHaveBeenCalledWith(
+          params,
+        );
+      });
+    });
+
+    it('returns the provider result', async () => {
+      const params = {
+        seriesId: '10684',
+        endDateMin: '2026-04-06T00:00:00.000Z',
+        endDateMax: '2026-04-07T00:00:00.000Z',
+      };
+      const mockMarkets = [
+        {
+          id: 'series-market-1',
+          title: 'BTC Up or Down 5m',
+          series: {
+            id: '10684',
+            slug: 'btc-up-or-down-5m',
+            title: 'BTC Up or Down 5m',
+            recurrence: '5m',
+          },
+        },
+      ];
+
+      await withController(async ({ controller }) => {
+        mockPolymarketProvider.getMarketSeries = jest
+          .fn()
+          .mockResolvedValue(mockMarkets);
+
+        const result = await controller.getMarketSeries(params);
+
+        expect(result).toEqual(mockMarkets);
+      });
+    });
+  });
 });
@@ -75,6 +75,7 @@ import {
   GetPriceHistoryParams,
   GetPriceParams,
   GetPriceResponse,
+  GetSeriesParams,
   OrderPreview,
   PlaceOrderParams,
   PredictAccountMeta,
@@ -354,6 +355,7 @@ const MESSENGER_EXPOSED_METHODS = [
   'getBalance',
   'getConnectionStatus',
   'getMarket',
+  'getMarketSeries',
   'getMarkets',
   'getPositions',
   'getPriceHistory',
@@ -686,6 +688,10 @@ export class PredictController extends BaseController<
     );
   }
 
+  async getMarketSeries(params: GetSeriesParams): Promise<PredictMarket[]> {
+    return this.provider.getMarketSeries(params);
+  }
+
   async getPriceHistory(
     params: GetPriceHistoryParams,
   ): Promise<PredictPriceHistoryPoint[]> {
 
@@ -0,0 +1,141 @@
+import React from 'react';
+import { renderHook, waitFor } from '@testing-library/react-native';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { usePredictSeries } from './usePredictSeries';
+import { predictMarketKeys } from '../queries/market';
+import { predictSeriesKeys } from '../queries/series';
+import { Recurrence, type GetSeriesParams, type PredictMarket } from '../types';
+
+jest.mock('../../../../util/Logger', () => ({
+  __esModule: true,
+  default: {
+    error: jest.fn(),
+  },
+}));
+
+const mockGetMarketSeries = jest.fn();
+
+jest.mock('../../../../core/Engine', () => ({
+  context: {
+    PredictController: {
+      getMarketSeries: (...args: unknown[]) => mockGetMarketSeries(...args),
+    },
+  },
+}));
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+        cacheTime: Infinity,
+      },
+    },
+  });
+
+  const Wrapper = ({ children }: { children: React.ReactNode }) =>
+    React.createElement(QueryClientProvider, { client: queryClient }, children);
+
+  return { Wrapper, queryClient };
+};
+
+const createMockMarket = (id: string): PredictMarket =>
+  ({
+    id,
+    title: `Market ${id}`,
+    slug: `market-${id}`,
+    providerId: 'polymarket',
+    description: `Description for ${id}`,
+    image: `https://example.com/${id}.png`,
+    status: 'open',
+    recurrence: Recurrence.NONE,
+    category: 'crypto',
+    tags: [],
+    outcomes: [],
+    liquidity: 100,
+    volume: 200,
+  }) as PredictMarket;
+
+describe('usePredictSeries', () => {
+  const params: GetSeriesParams = {
+    seriesId: 'series-1',
+    endDateMin: '2026-01-01T00:00:00.000Z',
+    endDateMax: '2026-12-31T23:59:59.999Z',
+    limit: 3,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns series events', async () => {
+    const { Wrapper } = createWrapper();
+    const marketA = createMockMarket('market-a');
+    const marketB = createMockMarket('market-b');
+    const marketC = createMockMarket('market-c');
+    mockGetMarketSeries.mockResolvedValue([marketA, marketB, marketC]);
+
+    const { result } = renderHook(() => usePredictSeries(params), {
+      wrapper: Wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.isFetching).toBe(false);
+    });
+
+    expect(result.current.data).toEqual([marketA, marketB, marketC]);
+    expect(mockGetMarketSeries).toHaveBeenCalledWith(params);
+  });
+
+  it('seeds individual market cache entries', async () => {
+    const { Wrapper, queryClient } = createWrapper();
+    const marketA = createMockMarket('market-a');
+    const marketB = createMockMarket('market-b');
+    const marketC = createMockMarket('market-c');
+    mockGetMarketSeries.mockResolvedValue([marketA, marketB, marketC]);
+
+    renderHook(() => usePredictSeries(params), {
+      wrapper: Wrapper,
+    });
+
+    await waitFor(() => {
+      expect(
+        queryClient.getQueryData(predictMarketKeys.detail(marketA.id)),
+      ).toEqual(marketA);
+    });
+
+    expect(queryClient.getQueryData(['predict', 'market', marketA.id])).toEqual(
+      marketA,
+    );
+  });
+
+  it('registers query under correct cache key', async () => {
+    const { Wrapper, queryClient } = createWrapper();
+    const marketA = createMockMarket('market-a');
+    const marketB = createMockMarket('market-b');
+    const marketC = createMockMarket('market-c');
+    const seriesEvents = [marketA, marketB, marketC];
+    mockGetMarketSeries.mockResolvedValue(seriesEvents);
+
+    renderHook(() => usePredictSeries(params), {
+      wrapper: Wrapper,
+    });
+
+    await waitFor(() => {
+      expect(
+        queryClient.getQueryData(predictSeriesKeys.detail(params)),
+      ).toEqual(seriesEvents);
+    });
+
+    expect(
+      queryClient.getQueryData([
+        'predict',
+        'series',
+        params.seriesId,
+        params.endDateMin,
+        params.endDateMax,
+        params.limit,
+      ]),
+    ).toEqual(seriesEvents);
+  });
+});
@@ -0,0 +1,44 @@
+import { useEffect } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import Logger from '../../../../util/Logger';
+import { PREDICT_CONSTANTS } from '../constants/errors';
+import { ensureError } from '../utils/predictErrorHandler';
+import { predictQueries } from '../queries';
+import { predictMarketKeys } from '../queries/market';
+import type { GetSeriesParams } from '../types';
+
+export const usePredictSeries = (params: GetSeriesParams) => {
+  const queryClient = useQueryClient();
+
+  const query = useQuery(predictQueries.series.options(params));
+
+  useEffect(() => {
+    if (!query.data) return;
+
+    query.data.forEach((event) => {
+      queryClient.setQueryData(predictMarketKeys.detail(event.id), event);
+    });
+  }, [query.data, queryClient]);
+
+  useEffect(() => {
+    if (!query.error) return;
+
+    Logger.error(ensureError(query.error), {
+      tags: {
+        feature: PREDICT_CONSTANTS.FEATURE_NAME,
+        component: 'usePredictSeries',
+      },
+      context: {
+        name: 'usePredictSeries',
+        data: {
+          method: 'queryFn',
+          action: 'series_load',
+          operation: 'data_fetching',
+          seriesId: params.seriesId,
+        },
+      },
+    });
+  }, [query.error, params.seriesId]);
+
+  return query;
+};
@@ -7940,4 +7940,91 @@ describe('PolymarketProvider', () => {
       });
     });
   });
+
+  describe('getMarketSeries', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      global.fetch = jest.fn();
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('calls the series events endpoint with the requested params', async () => {
+      const provider = createProvider();
+      const mockEvents = [{ id: 'event-1' }];
+      const parsedMarkets = [{ id: 'market-1' }];
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue(mockEvents),
+      };
+      (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+      mockParsePolymarketEvents.mockReturnValue(parsedMarkets);
+
+      await provider.getMarketSeries({
+        seriesId: '10684',
+        endDateMin: '2026-04-06T00:00:00.000Z',
+        endDateMax: '2026-04-07T00:00:00.000Z',
+        limit: 10,
+      });
+
+      const requestUrl = new URL((global.fetch as jest.Mock).mock.calls[0][0]);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('series_id=10684'),
+      );
+      expect(requestUrl.origin + requestUrl.pathname).toBe(
+        'https://gamma-api.polymarket.com/events',
+      );
+      expect(requestUrl.searchParams.get('series_id')).toBe('10684');
+      expect(requestUrl.searchParams.get('end_date_min')).toBe(
+        '2026-04-06T00:00:00.000Z',
+      );
+      expect(requestUrl.searchParams.get('end_date_max')).toBe(
+        '2026-04-07T00:00:00.000Z',
+      );
+      expect(requestUrl.searchParams.get('limit')).toBe('10');
+      expect(requestUrl.searchParams.get('order')).toBe('endDate');
+      expect(requestUrl.searchParams.get('ascending')).toBe('true');
+    });
+
+    it('returns an empty array when the API returns no events', async () => {
+      const provider = createProvider();
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue([]),
+      };
+      (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await provider.getMarketSeries({
+        seriesId: '10684',
+        endDateMin: '2026-04-06T00:00:00.000Z',
+        endDateMax: '2026-04-07T00:00:00.000Z',
+      });
+
+      expect(result).toEqual([]);
+      expect(mockParsePolymarketEvents).not.toHaveBeenCalled();
+    });
+
+    it('uses the default limit when one is not provided', async () => {
+      const provider = createProvider();
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue([{ id: 'event-1' }]),
+      };
+      (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+      mockParsePolymarketEvents.mockReturnValue([]);
+
+      await provider.getMarketSeries({
+        seriesId: '10684',
+        endDateMin: '2026-04-06T00:00:00.000Z',
+        endDateMax: '2026-04-07T00:00:00.000Z',
+      });
+
+      const requestUrl = new URL((global.fetch as jest.Mock).mock.calls[0][0]);
+
+      expect(requestUrl.searchParams.get('limit')).toBe('50');
+    });
+  });
 });