overtime-live-trading-utils 2.1.17 → 2.1.19

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

@@ -0,0 +1,255 @@
+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;
+    }
+}
+
+/**
+ * Checks if a single market type can be resolved based on completed periods
+ * @param event - Event object from OpticOdds API
+ * @param typeId - Single market type ID to check
+ * @param sportType - Sport period structure type - REQUIRED (enum or number: 0=halves, 1=quarters, 2=innings, 3=period)
+ * @returns boolean indicating if that typeId can be resolved
+ */
+export function canResolveMarketsForEvent(
+    event: OpticOddsEvent,
+    typeId: number,
+    sportType: SportPeriodType | number
+): boolean;
+
+/**
+ * Checks which market types can be resolved from a batch based on completed periods
+ * @param event - Event object from OpticOdds API
+ * @param typeIds - Array of market type IDs to check
+ * @param sportType - Sport period structure type - REQUIRED (enum or number: 0=halves, 1=quarters, 2=innings, 3=period)
+ * @returns Array of typeIds that can be resolved
+ */
+export function canResolveMarketsForEvent(
+    event: OpticOddsEvent,
+    typeIds: number[],
+    sportType: SportPeriodType | number
+): number[];
+
+/**
+ * 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);
+    });
+};

package/src/utils/sports.ts

@@ -1,51 +1,51 @@
-import { League } from 'overtime-utils';
-import { LeagueConfigInfo } from '../types/sports';
-
-// Methods are using data from live-markets-map.csv
-export const getLiveSupportedLeagues = (leagueInfoArray: LeagueConfigInfo[]) => {
-    const uniqueId = new Set();
-    leagueInfoArray
-        .filter((leagueInfo) => leagueInfo.enabled === 'true')
-        .map((league) => uniqueId.add(Number(league.sportId)));
-    return Array.from(uniqueId);
-};
-
-export const getBetTypesForLeague = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const uniqueMarketNames = new Set();
-    leagueInfoArray
-        .filter((leagueInfo) => Number(leagueInfo.sportId) === Number(league) && leagueInfo.enabled === 'true')
-        .map((leagueInfo) => uniqueMarketNames.add(leagueInfo.marketName));
-
-    return Array.from(uniqueMarketNames) as string[];
-};
-
-export const getLeagueInfo = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const leagueInfos = leagueInfoArray.filter((leagueInfo) => Number(leagueInfo.sportId) === league);
-    return leagueInfos;
-};
-
-export const getLeagueSpreadTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const betTypes = leagueInfoArray
-        .filter(
-            (leagueInfo) =>
-                Number(leagueInfo.sportId) === Number(league) &&
-                leagueInfo.type === 'Spread' &&
-                leagueInfo.enabled === 'true'
-        )
-        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
-
-    return betTypes;
-};
-
-export const getLeagueTotalTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const betTypes = leagueInfoArray
-        .filter(
-            (leagueInfo) =>
-                Number(leagueInfo.sportId) === Number(league) &&
-                leagueInfo.type === 'Total' &&
-                leagueInfo.enabled === 'true'
-        )
-        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
-
-    return betTypes;
-};
+import { League } from 'overtime-utils';
+import { LeagueConfigInfo } from '../types/sports';
+
+// Methods are using data from live-markets-map.csv
+export const getLiveSupportedLeagues = (leagueInfoArray: LeagueConfigInfo[]) => {
+    const uniqueId = new Set();
+    leagueInfoArray
+        .filter((leagueInfo) => leagueInfo.enabled === 'true')
+        .map((league) => uniqueId.add(Number(league.sportId)));
+    return Array.from(uniqueId);
+};
+
+export const getBetTypesForLeague = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const uniqueMarketNames = new Set();
+    leagueInfoArray
+        .filter((leagueInfo) => Number(leagueInfo.sportId) === Number(league) && leagueInfo.enabled === 'true')
+        .map((leagueInfo) => uniqueMarketNames.add(leagueInfo.marketName));
+
+    return Array.from(uniqueMarketNames) as string[];
+};
+
+export const getLeagueInfo = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const leagueInfos = leagueInfoArray.filter((leagueInfo) => Number(leagueInfo.sportId) === league);
+    return leagueInfos;
+};
+
+export const getLeagueSpreadTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const betTypes = leagueInfoArray
+        .filter(
+            (leagueInfo) =>
+                Number(leagueInfo.sportId) === Number(league) &&
+                leagueInfo.type === 'Spread' &&
+                leagueInfo.enabled === 'true'
+        )
+        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
+
+    return betTypes;
+};
+
+export const getLeagueTotalTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const betTypes = leagueInfoArray
+        .filter(
+            (leagueInfo) =>
+                Number(leagueInfo.sportId) === Number(league) &&
+                leagueInfo.type === 'Total' &&
+                leagueInfo.enabled === 'true'
+        )
+        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
+
+    return betTypes;
+};