overtime-live-trading-utils 2.1.22 → 2.1.23

package/src/utils/opticOdds.ts

@@ -1,71 +1,71 @@
-import { Fixture, OddsObject, ScoresObject } from '../types/odds';
-
-export const mapOpticOddsApiFixtures = (fixturesData: any[]): Fixture[] =>
-    fixturesData.map(
-        (fixtureData) =>
-            ({
-                gameId: fixtureData.id, // fixture_id
-                startDate: fixtureData.start_date,
-                homeTeam: fixtureData.home_team_display,
-                awayTeam: fixtureData.away_team_display,
-            } as Fixture)
-    );
-
-export const mapOpticOddsApiResults = (resultsData: any[]): ScoresObject[] =>
-    resultsData.map(
-        (resultData) =>
-            ({
-                gameId: resultData.fixture.id, // fixture_id
-                sport: resultData.sport.name,
-                league: resultData.league.name.toLowerCase(),
-                status: resultData.fixture.status ? resultData.fixture.status.toLowerCase() : resultData.fixture.status,
-                isLive: resultData.fixture.is_live,
-                clock: resultData.in_play.clock,
-                period: resultData.in_play.period ? resultData.in_play.period.toLowerCase() : resultData.in_play.period,
-                homeTeam: resultData.fixture.home_team_display,
-                awayTeam: resultData.fixture.away_team_display,
-                homeTotal: resultData.scores.home.total,
-                awayTotal: resultData.scores.away.total,
-                ...mapScorePeriods(resultData.scores.home.periods, 'home'),
-                ...mapScorePeriods(resultData.scores.away.periods, 'away'),
-            } as ScoresObject)
-    );
-
-export const mapOpticOddsApiFixtureOdds = (oddsDataArray: any[]): OddsObject[] =>
-    oddsDataArray.map(
-        (oddsData) =>
-            ({
-                gameId: oddsData.id, // fixture_id
-                startDate: oddsData.start_date,
-                homeTeam: oddsData.home_team_display,
-                awayTeam: oddsData.away_team_display,
-                isLive: oddsData.is_live,
-                status: oddsData.status,
-                sport: oddsData.sport.id,
-                league: oddsData.league.name,
-                odds: oddsData.odds.map((oddsObj: any) => ({
-                    id: oddsObj.id, // 39920-20584-2024-35:draftkings:2nd_set_moneyline:francisco_comesana
-                    sportsBookName: oddsObj.sportsbook,
-                    name: oddsObj.name,
-                    price: oddsObj.price,
-                    timestamp: oddsObj.timestamp,
-                    points: oddsObj.points,
-                    isMain: oddsObj.is_main,
-                    isLive: oddsData.is_live,
-                    marketName: oddsObj.market.toLowerCase(),
-                    playerId: oddsObj.player_id,
-                    selection: oddsObj.selection,
-                    selectionLine: oddsObj.selection_line,
-                })),
-            } as OddsObject)
-    );
-
-const mapScorePeriods = (periods: any, homeAwayType: string) =>
-    Object.entries(periods).reduce((acc, period) => {
-        const periodKey = period[0].split('_')[1];
-        const periodValue = period[1];
-        return {
-            ...acc,
-            [`${homeAwayType}Period${periodKey}`]: periodValue,
-        };
-    }, {});
+import { Fixture, OddsObject, ScoresObject } from '../types/odds';
+
+export const mapOpticOddsApiFixtures = (fixturesData: any[]): Fixture[] =>
+    fixturesData.map(
+        (fixtureData) =>
+            ({
+                gameId: fixtureData.id, // fixture_id
+                startDate: fixtureData.start_date,
+                homeTeam: fixtureData.home_team_display,
+                awayTeam: fixtureData.away_team_display,
+            } as Fixture)
+    );
+
+export const mapOpticOddsApiResults = (resultsData: any[]): ScoresObject[] =>
+    resultsData.map(
+        (resultData) =>
+            ({
+                gameId: resultData.fixture.id, // fixture_id
+                sport: resultData.sport.name,
+                league: resultData.league.name.toLowerCase(),
+                status: resultData.fixture.status ? resultData.fixture.status.toLowerCase() : resultData.fixture.status,
+                isLive: resultData.fixture.is_live,
+                clock: resultData.in_play.clock,
+                period: resultData.in_play.period ? resultData.in_play.period.toLowerCase() : resultData.in_play.period,
+                homeTeam: resultData.fixture.home_team_display,
+                awayTeam: resultData.fixture.away_team_display,
+                homeTotal: resultData.scores.home.total,
+                awayTotal: resultData.scores.away.total,
+                ...mapScorePeriods(resultData.scores.home.periods, 'home'),
+                ...mapScorePeriods(resultData.scores.away.periods, 'away'),
+            } as ScoresObject)
+    );
+
+export const mapOpticOddsApiFixtureOdds = (oddsDataArray: any[]): OddsObject[] =>
+    oddsDataArray.map(
+        (oddsData) =>
+            ({
+                gameId: oddsData.id, // fixture_id
+                startDate: oddsData.start_date,
+                homeTeam: oddsData.home_team_display,
+                awayTeam: oddsData.away_team_display,
+                isLive: oddsData.is_live,
+                status: oddsData.status,
+                sport: oddsData.sport.id,
+                league: oddsData.league.name,
+                odds: oddsData.odds.map((oddsObj: any) => ({
+                    id: oddsObj.id, // 39920-20584-2024-35:draftkings:2nd_set_moneyline:francisco_comesana
+                    sportsBookName: oddsObj.sportsbook,
+                    name: oddsObj.name,
+                    price: oddsObj.price,
+                    timestamp: oddsObj.timestamp,
+                    points: oddsObj.points,
+                    isMain: oddsObj.is_main,
+                    isLive: oddsData.is_live,
+                    marketName: oddsObj.market.toLowerCase(),
+                    playerId: oddsObj.player_id,
+                    selection: oddsObj.selection,
+                    selectionLine: oddsObj.selection_line,
+                })),
+            } as OddsObject)
+    );
+
+const mapScorePeriods = (periods: any, homeAwayType: string) =>
+    Object.entries(periods).reduce((acc, period) => {
+        const periodKey = period[0].split('_')[1];
+        const periodValue = period[1];
+        return {
+            ...acc,
+            [`${homeAwayType}Period${periodKey}`]: periodValue,
+        };
+    }, {});

package/src/utils/resolution.ts

@@ -1,229 +1,275 @@
-import {
-    PeriodResolutionData,
-    PeriodScores,
-    OpticOddsEvent,
-    SportPeriodType,
-    HALVES_PERIOD_TYPE_ID_MAPPING,
-    QUARTERS_PERIOD_TYPE_ID_MAPPING,
-    INNINGS_PERIOD_TYPE_ID_MAPPING,
-    PERIOD_BASED_TYPE_ID_MAPPING,
-    FULL_GAME_TYPE_IDS,
-} from '../types/resolution';
-
-/**
- * Detects completed periods for a game based on OpticOdds API event data
- * A period is considered complete if the next period (period + 1) exists in the scores
- * @param event - Event object from OpticOdds API
- * @returns PeriodResolutionData with completed periods, readiness status, and period scores
- */
-export const detectCompletedPeriods = (
-    event: OpticOddsEvent
-): PeriodResolutionData | null => {
-    const status = (event.fixture?.status || event.status || '').toLowerCase();
-    const isLive = event.fixture?.is_live ?? event.is_live ?? false;
-
-    // Extract period scores from the event
-    const homePeriods = event.scores?.home?.periods || {};
-    const awayPeriods = event.scores?.away?.periods || {};
-
-    const periodScores: PeriodScores = {};
-    const completedPeriods: number[] = [];
-
-    // Parse all available periods
-    const periodKeys = Object.keys(homePeriods)
-        .filter((key) => key.startsWith('period_'))
-        .map((key) => parseInt(key.replace('period_', '')))
-        .sort((a, b) => a - b);
-
-    if (periodKeys.length === 0) {
-        return null; // No period data available
-    }
-
-    // Get current period from in_play if available (only use if numeric)
-    const inPlayPeriod = event.in_play?.period;
-    const currentLivePeriod = inPlayPeriod && !isNaN(parseInt(inPlayPeriod)) ? parseInt(inPlayPeriod) : null;
-
-    // Check if game is in overtime/extra time (non-numeric period indicator)
-    const isInOvertime = inPlayPeriod &&
-        (inPlayPeriod.toLowerCase().includes('overtime') ||
-         inPlayPeriod.toLowerCase().includes('ot') ||
-         inPlayPeriod.toLowerCase().includes('extra'));
-
-    // For each period, check if it's complete
-    for (const periodNum of periodKeys) {
-        const key = `period_${periodNum}`;
-        const homeScore = homePeriods[key];
-        const awayScore = awayPeriods[key];
-
-        // Add this period's score
-        if (homeScore !== undefined && awayScore !== undefined && !isNaN(homeScore) && !isNaN(awayScore)) {
-            periodScores[`period${periodNum}`] = { home: homeScore, away: awayScore };
-
-            // Period is complete if:
-            // 1. Next period exists in periods data, OR
-            // 2. Game is completed, OR
-            // 3. Game is live with numeric period AND current live period is greater than this period, OR
-            // 4. Game is in overtime (all regulation periods are complete)
-            const nextPeriodKey = `period_${periodNum + 1}`;
-            const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
-            const hasNextPeriod = homePeriods[nextPeriodKey] !== undefined && awayPeriods[nextPeriodKey] !== undefined;
-            const isCompletedInLiveGame = isLive && currentLivePeriod !== null && currentLivePeriod > periodNum;
-
-            if (hasNextPeriod || isCompleted || isCompletedInLiveGame || isInOvertime) {
-                completedPeriods.push(periodNum);
-            }
-        }
-    }
-
-    // Determine current period
-    // If we have a numeric in_play period and it's greater than highest period in data, use it
-    // Otherwise use highest period number from the data
-    const highestPeriodInData = periodKeys.length > 0 ? Math.max(...periodKeys) : undefined;
-    const currentPeriod = currentLivePeriod && currentLivePeriod > (highestPeriodInData || 0)
-        ? currentLivePeriod
-        : highestPeriodInData;
-
-    return completedPeriods.length > 0
-        ? {
-              completedPeriods,
-              readyForResolution: true,
-              periodScores,
-              currentPeriod,
-          }
-        : null;
-};
-
-/**
- * Checks if a market can be resolved based on game and sport
- * @param gameId - The game/fixture ID
- * @param event - Event object from OpticOdds API
- * @returns boolean indicating if market can be resolved
- */
-export const canResolveMarketForGameIdAndSport = (
-    gameId: string,
-    event: OpticOddsEvent
-): boolean => {
-    const eventId = event.fixture?.id || event.id || '';
-    if (eventId !== gameId) {
-        return false;
-    }
-
-    const periodData = detectCompletedPeriods(event);
-    return periodData !== null && periodData.readyForResolution;
-};
-
-/**
- * Convenience function to check resolution status via OpticOdds API event
- * @param event - Event object from OpticOdds API
- * @returns PeriodResolutionData if periods are complete, null otherwise
- */
-export const canResolveMarketViaOpticOddsApi = (
-    event: OpticOddsEvent
-): PeriodResolutionData | null => {
-    return detectCompletedPeriods(event);
-};
-
-/**
- * Maps a numeric value to a SportPeriodType enum
- * @param sportTypeNum - Numeric representation of sport type (0 = halves, 1 = quarters, 2 = innings, 3 = period)
- * @returns SportPeriodType enum value
- * @throws Error if invalid number provided
- */
-export function mapNumberToSportPeriodType(sportTypeNum: number): SportPeriodType {
-    switch (sportTypeNum) {
-        case 0:
-            return SportPeriodType.HALVES_BASED;
-        case 1:
-            return SportPeriodType.QUARTERS_BASED;
-        case 2:
-            return SportPeriodType.INNINGS_BASED;
-        case 3:
-            return SportPeriodType.PERIOD_BASED;
-        default:
-            throw new Error(`Invalid sport type number: ${sportTypeNum}. Must be 0 (halves), 1 (quarters), 2 (innings), or 3 (period).`);
-    }
-}
-
-/**
- * Selects the appropriate period-to-typeId mapping based on sport type
- * @param sportType - Sport period structure type
- * @returns Period-to-typeId mapping for the specified sport type
- */
-function selectMappingForSportType(sportType: SportPeriodType): { [period: number]: number[] } {
-    switch (sportType) {
-        case SportPeriodType.HALVES_BASED:
-            return HALVES_PERIOD_TYPE_ID_MAPPING;
-        case SportPeriodType.QUARTERS_BASED:
-            return QUARTERS_PERIOD_TYPE_ID_MAPPING;
-        case SportPeriodType.INNINGS_BASED:
-            return INNINGS_PERIOD_TYPE_ID_MAPPING;
-        case SportPeriodType.PERIOD_BASED:
-            return PERIOD_BASED_TYPE_ID_MAPPING;
-    }
-}
-
-/**
- * Implementation - checks if specific market type(s) can be resolved based on completed periods
- *
- * @example
- * // Check single typeId for NFL (quarters-based)
- * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.QUARTERS_BASED);
- * // Or using number
- * const canResolve = canResolveMarketsForEvent(event, 10021, 1);
- *
- * // Check batch of typeIds for MLB (innings-based)
- * const resolvable = canResolveMarketsForEvent(event, [10021, 10051], SportPeriodType.INNINGS_BASED);
- * // Returns: [10021] if only period 1-4 complete, [10021, 10051] if period 5 complete
- *
- * // Check with period-based (no halves/secondary moneyline)
- * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.PERIOD_BASED);
- * // Or using number
- * const canResolve = canResolveMarketsForEvent(event, 10021, 3);
- */
-export function canResolveMarketsForEvent(
-    event: OpticOddsEvent,
-    typeIdOrTypeIds: number | number[],
-    sportType: SportPeriodType | number
-): boolean | number[] {
-    // Get completed periods
-    const periodData = detectCompletedPeriods(event);
-    if (!periodData) {
-        return Array.isArray(typeIdOrTypeIds) ? [] : false;
-    }
-
-    // Check if game is fully completed
-    const status = (event.fixture?.status || event.status || '').toLowerCase();
-    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
-
-    // Convert number to SportPeriodType if needed
-    const sportTypeEnum = typeof sportType === 'number' ? mapNumberToSportPeriodType(sportType) : sportType;
-
-    // Select appropriate mapping based on sport type
-    const mapping = selectMappingForSportType(sportTypeEnum);
-
-    // Collect all resolvable typeIds based on completed periods
-    const resolvableTypeIds = new Set<number>();
-
-    for (const period of periodData.completedPeriods) {
-        const typeIdsForPeriod = mapping[period] || [];
-        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
-    }
-
-    // Single typeId check
-    if (typeof typeIdOrTypeIds === 'number') {
-        // Full game typeIds can only be resolved when game is completed
-        if (FULL_GAME_TYPE_IDS.includes(typeIdOrTypeIds)) {
-            return isCompleted;
-        }
-        return resolvableTypeIds.has(typeIdOrTypeIds);
-    }
-
-    // Batch typeIds check
-    return typeIdOrTypeIds.filter((id) => {
-        // Full game typeIds can only be resolved when game is completed
-        if (FULL_GAME_TYPE_IDS.includes(id)) {
-            return isCompleted;
-        }
-        return resolvableTypeIds.has(id);
-    });
-};
+import {
+    PeriodResolutionData,
+    PeriodScores,
+    OpticOddsEvent,
+    SportPeriodType,
+    HALVES_PERIOD_TYPE_ID_MAPPING,
+    QUARTERS_PERIOD_TYPE_ID_MAPPING,
+    INNINGS_PERIOD_TYPE_ID_MAPPING,
+    PERIOD_BASED_TYPE_ID_MAPPING,
+    FULL_GAME_TYPE_IDS,
+} from '../types/resolution';
+
+/**
+ * Detects completed periods for a game based on OpticOdds API event data
+ * A period is considered complete if the next period (period + 1) exists in the scores
+ * @param event - Event object from OpticOdds API
+ * @returns PeriodResolutionData with completed periods, readiness status, and period scores
+ */
+export const detectCompletedPeriods = (
+    event: OpticOddsEvent
+): PeriodResolutionData | null => {
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isLive = event.fixture?.is_live ?? event.is_live ?? false;
+
+    // Extract period scores from the event
+    const homePeriods = event.scores?.home?.periods || {};
+    const awayPeriods = event.scores?.away?.periods || {};
+
+    const periodScores: PeriodScores = {};
+    const completedPeriods: number[] = [];
+
+    // Parse all available periods
+    const periodKeys = Object.keys(homePeriods)
+        .filter((key) => key.startsWith('period_'))
+        .map((key) => parseInt(key.replace('period_', '')))
+        .sort((a, b) => a - b);
+
+    if (periodKeys.length === 0) {
+        return null; // No period data available
+    }
+
+    // Get current period from in_play if available (only use if numeric)
+    const inPlayPeriod = event.in_play?.period;
+    const currentLivePeriod = inPlayPeriod && !isNaN(parseInt(inPlayPeriod)) ? parseInt(inPlayPeriod) : null;
+
+    // Check if game is in overtime/extra time (non-numeric period indicator)
+    const isInOvertime = inPlayPeriod &&
+        (inPlayPeriod.toLowerCase().includes('overtime') ||
+         inPlayPeriod.toLowerCase().includes('ot') ||
+         inPlayPeriod.toLowerCase().includes('extra'));
+
+    // For each period, check if it's complete
+    for (const periodNum of periodKeys) {
+        const key = `period_${periodNum}`;
+        const homeScore = homePeriods[key];
+        const awayScore = awayPeriods[key];
+
+        // Add this period's score
+        if (homeScore !== undefined && awayScore !== undefined && !isNaN(homeScore) && !isNaN(awayScore)) {
+            periodScores[`period${periodNum}`] = { home: homeScore, away: awayScore };
+
+            // Period is complete if:
+            // 1. Next period exists in periods data, OR
+            // 2. Game is completed, OR
+            // 3. Game is live with numeric period AND current live period is greater than this period, OR
+            // 4. Game is in overtime (all regulation periods are complete)
+            const nextPeriodKey = `period_${periodNum + 1}`;
+            const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+            const hasNextPeriod = homePeriods[nextPeriodKey] !== undefined && awayPeriods[nextPeriodKey] !== undefined;
+            const isCompletedInLiveGame = isLive && currentLivePeriod !== null && currentLivePeriod > periodNum;
+
+            if (hasNextPeriod || isCompleted || isCompletedInLiveGame || isInOvertime) {
+                completedPeriods.push(periodNum);
+            }
+        }
+    }
+
+    // Determine current period
+    // If we have a numeric in_play period and it's greater than highest period in data, use it
+    // Otherwise use highest period number from the data
+    const highestPeriodInData = periodKeys.length > 0 ? Math.max(...periodKeys) : undefined;
+    const currentPeriod = currentLivePeriod && currentLivePeriod > (highestPeriodInData || 0)
+        ? currentLivePeriod
+        : highestPeriodInData;
+
+    return completedPeriods.length > 0
+        ? {
+              completedPeriods,
+              readyForResolution: true,
+              periodScores,
+              currentPeriod,
+          }
+        : null;
+};
+/**
+ * Maps a numeric value to a SportPeriodType enum
+ * @param sportTypeNum - Numeric representation of sport type (0 = halves, 1 = quarters, 2 = innings, 3 = period)
+ * @returns SportPeriodType enum value
+ * @throws Error if invalid number provided
+ */
+export function mapNumberToSportPeriodType(sportTypeNum: number): SportPeriodType {
+    switch (sportTypeNum) {
+        case 0:
+            return SportPeriodType.HALVES_BASED;
+        case 1:
+            return SportPeriodType.QUARTERS_BASED;
+        case 2:
+            return SportPeriodType.INNINGS_BASED;
+        case 3:
+            return SportPeriodType.PERIOD_BASED;
+        default:
+            throw new Error(`Invalid sport type number: ${sportTypeNum}. Must be 0 (halves), 1 (quarters), 2 (innings), or 3 (period).`);
+    }
+}
+
+/**
+ * Selects the appropriate period-to-typeId mapping based on sport type
+ * @param sportType - Sport period structure type
+ * @returns Period-to-typeId mapping for the specified sport type
+ */
+function selectMappingForSportType(sportType: SportPeriodType): { [period: number]: number[] } {
+    switch (sportType) {
+        case SportPeriodType.HALVES_BASED:
+            return HALVES_PERIOD_TYPE_ID_MAPPING;
+        case SportPeriodType.QUARTERS_BASED:
+            return QUARTERS_PERIOD_TYPE_ID_MAPPING;
+        case SportPeriodType.INNINGS_BASED:
+            return INNINGS_PERIOD_TYPE_ID_MAPPING;
+        case SportPeriodType.PERIOD_BASED:
+            return PERIOD_BASED_TYPE_ID_MAPPING;
+    }
+}
+
+/**
+ * Checks if a specific market type can be resolved based on completed periods
+ *
+ * @example
+ * // Check single typeId for NFL (quarters-based)
+ * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.QUARTERS_BASED);
+ * // Or using number
+ * const canResolve = canResolveMarketsForEvent(event, 10021, 1);
+ *
+ * // Check with period-based (no halves/secondary moneyline)
+ * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.PERIOD_BASED);
+ */
+export function canResolveMarketsForEvent(
+    event: OpticOddsEvent,
+    typeId: number,
+    sportType: SportPeriodType | number
+): boolean {
+    // Get completed periods
+    const periodData = detectCompletedPeriods(event);
+    if (!periodData) {
+        return false;
+    }
+
+    // Check if game is fully completed
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+
+    // Full game typeIds can only be resolved when game is completed
+    if (FULL_GAME_TYPE_IDS.includes(typeId)) {
+        return isCompleted;
+    }
+
+    // Convert number to SportPeriodType if needed
+    const sportTypeEnum = typeof sportType === 'number' ? mapNumberToSportPeriodType(sportType) : sportType;
+
+    // Select appropriate mapping based on sport type
+    const mapping = selectMappingForSportType(sportTypeEnum);
+
+    // Collect all resolvable typeIds based on completed periods
+    const resolvableTypeIds = new Set<number>();
+
+    for (const period of periodData.completedPeriods) {
+        const typeIdsForPeriod = mapping[period] || [];
+        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
+    }
+
+    return resolvableTypeIds.has(typeId);
+}
+
+/**
+ * Checks if multiple market types can be resolved, returning a boolean for each
+ *
+ * @example
+ * // Check multiple typeIds for MLB (innings-based)
+ * const canResolve = canResolveMultipleTypeIdsForEvent(event, [10021, 10051], SportPeriodType.INNINGS_BASED);
+ * // Returns: [true, false] if only 10021 can be resolved
+ */
+export function canResolveMultipleTypeIdsForEvent(
+    event: OpticOddsEvent,
+    typeIds: number[],
+    sportType: SportPeriodType | number
+): boolean[] {
+    // Get completed periods
+    const periodData = detectCompletedPeriods(event);
+    if (!periodData) {
+        return typeIds.map(() => false);
+    }
+
+    // Check if game is fully completed
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+
+    // Convert number to SportPeriodType if needed
+    const sportTypeEnum = typeof sportType === 'number' ? mapNumberToSportPeriodType(sportType) : sportType;
+
+    // Select appropriate mapping based on sport type
+    const mapping = selectMappingForSportType(sportTypeEnum);
+
+    // Collect all resolvable typeIds based on completed periods
+    const resolvableTypeIds = new Set<number>();
+
+    for (const period of periodData.completedPeriods) {
+        const typeIdsForPeriod = mapping[period] || [];
+        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
+    }
+
+    // Map each typeId to a boolean
+    return typeIds.map((id) => {
+        // Full game typeIds can only be resolved when game is completed
+        if (FULL_GAME_TYPE_IDS.includes(id)) {
+            return isCompleted;
+        }
+        return resolvableTypeIds.has(id);
+    });
+}
+
+/**
+ * Filters a list of market types to only those that can be resolved
+ *
+ * @example
+ * // Filter typeIds for MLB (innings-based)
+ * const resolvable = filterMarketsThatCanBeResolved(event, [10021, 10051, 10061], SportPeriodType.INNINGS_BASED);
+ * // Returns: [10021] if only period 1-4 complete, [10021, 10051] if period 5 complete
+ */
+export function filterMarketsThatCanBeResolved(
+    event: OpticOddsEvent,
+    typeIds: number[],
+    sportType: SportPeriodType | number
+): number[] {
+    // Get completed periods
+    const periodData = detectCompletedPeriods(event);
+    if (!periodData) {
+        return [];
+    }
+
+    // Check if game is fully completed
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+
+    // Convert number to SportPeriodType if needed
+    const sportTypeEnum = typeof sportType === 'number' ? mapNumberToSportPeriodType(sportType) : sportType;
+
+    // Select appropriate mapping based on sport type
+    const mapping = selectMappingForSportType(sportTypeEnum);
+
+    // Collect all resolvable typeIds based on completed periods
+    const resolvableTypeIds = new Set<number>();
+
+    for (const period of periodData.completedPeriods) {
+        const typeIdsForPeriod = mapping[period] || [];
+        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
+    }
+
+    // Filter typeIds to only those that can be resolved
+    return typeIds.filter((id) => {
+        // Full game typeIds can only be resolved when game is completed
+        if (FULL_GAME_TYPE_IDS.includes(id)) {
+            return isCompleted;
+        }
+        return resolvableTypeIds.has(id);
+    });
+}