overtime-live-trading-utils 2.1.22 → 2.1.23

package/src/types/resolution.ts

@@ -1,96 +1,96 @@
-export type PeriodScores = {
-    [key: string]: { home: number; away: number };
-};
-
-export type PeriodResolutionData = {
-    completedPeriods: number[];
-    readyForResolution: boolean;
-    periodScores: PeriodScores;
-    currentPeriod?: number;
-};
-
-/**
- * OpticOdds Event type from their API response
- * Uses 'any' for flexibility as API structure may vary
- */
-export type OpticOddsEvent = any;
-
-/**
- * Sport period structure types
- * Different sports have different period structures that affect how typeIds are resolved
- */
-export enum SportPeriodType {
-    /** Sports with 2 halves (Soccer, NCAAB) */
-    HALVES_BASED = 'halves_based',
-    /** Sports with 4 quarters (NFL, NBA) */
-    QUARTERS_BASED = 'quarters_based',
-    /** Sports with 9+ innings (MLB, NPB, KBO, College Baseball, etc.) */
-    INNINGS_BASED = 'innings_based',
-    /** Sports with 9 periods without halves or secondary moneyline types */
-    PERIOD_BASED = 'period_based',
-}
-
-/**
- * Halves-based sports period-to-typeId mapping (Soccer, NCAAB)
- * Period 1 = 1st half
- * Period 2 = 2nd half
- */
-export const HALVES_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
-    1: [10021, 10031, 10041, 10051, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st half
-    2: [10022, 10032, 10042, 10052, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd half
-};
-
-/**
- * Quarters-based sports period-to-typeId mapping (NFL, NBA)
- * Period 1 = 1st quarter
- * Period 2 = 2nd quarter (also completes 1st half - typeId 10051)
- * Period 3 = 3rd quarter
- * Period 4 = 4th quarter (also completes 2nd half - typeId 10052)
- * Period 5+ = Overtime
- */
-export const QUARTERS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
-    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st quarter
-    2: [10022, 10032, 10042, 10051, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd quarter + 1st half
-    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd quarter
-    4: [10024, 10034, 10044, 10052, 10064, 10074, 10084, 10411, 10412, 10124], // 4th quarter + 2nd half
-    5: [10025, 10035, 10045, 10055, 10065, 10075, 10085, 10511, 10512], // Overtime/5th period
-};
-
-/**
- * Innings-based sports period-to-typeId mapping (MLB, NPB, KBO, College Baseball)
- * Period 1-5 = Innings 1-5 (period 5 completes 1st half - typeId 10051)
- * Period 6-9 = Innings 6-9 (period 9 completes 2nd half - typeId 10052)
- */
-export const INNINGS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
-    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st inning
-    2: [10022, 10032, 10042, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd inning
-    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd inning
-    4: [10024, 10034, 10044, 10064, 10074, 10084, 10411, 10412, 10124], // 4th inning
-    5: [10025, 10035, 10045, 10051, 10065, 10075, 10085, 10511, 10512], // 5th inning + 1st half
-    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086, 10611, 10612], // 6th inning
-    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087, 10711, 10712], // 7th inning
-    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088, 10811, 10812], // 8th inning
-    9: [10029, 10039, 10049, 10052, 10069, 10079, 10089], // 9th inning + 2nd half
-};
-
-/**
- * Period-based sports period-to-typeId mapping (9 periods)
- * Excludes halves types (10051, 10052) and secondary moneyline types (ending in 11/12)
- */
-export const PERIOD_BASED_TYPE_ID_MAPPING: { [period: number]: number[] } = {
-    1: [10021, 10031, 10041, 10061, 10071, 10081, 10121, 10163], // 1st period
-    2: [10022, 10032, 10042, 10062, 10072, 10082, 10122], // 2nd period
-    3: [10023, 10033, 10043, 10063, 10073, 10083, 10123], // 3rd period
-    4: [10024, 10034, 10044, 10064, 10074, 10084, 10124], // 4th period
-    5: [10025, 10035, 10045, 10065, 10075, 10085], // 5th period
-    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086], // 6th period
-    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087], // 7th period
-    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088], // 8th period
-    9: [10029, 10039, 10049, 10069, 10079, 10089], // 9th period
-};
-
-/**
- * Full game type IDs that should NOT be resolved during live games
- * These can only be resolved when the game status is "completed"
- */
-export const FULL_GAME_TYPE_IDS: number[] = [0, 10001, 10002, 10003, 10004, 10010, 10011, 10012];
+export type PeriodScores = {
+    [key: string]: { home: number; away: number };
+};
+
+export type PeriodResolutionData = {
+    completedPeriods: number[];
+    readyForResolution: boolean;
+    periodScores: PeriodScores;
+    currentPeriod?: number;
+};
+
+/**
+ * OpticOdds Event type from their API response
+ * Uses 'any' for flexibility as API structure may vary
+ */
+export type OpticOddsEvent = any;
+
+/**
+ * Sport period structure types
+ * Different sports have different period structures that affect how typeIds are resolved
+ */
+export enum SportPeriodType {
+    /** Sports with 2 halves (Soccer, NCAAB) */
+    HALVES_BASED = 'halves_based',
+    /** Sports with 4 quarters (NFL, NBA) */
+    QUARTERS_BASED = 'quarters_based',
+    /** Sports with 9+ innings (MLB, NPB, KBO, College Baseball, etc.) */
+    INNINGS_BASED = 'innings_based',
+    /** Sports with 9 periods without halves or secondary moneyline types */
+    PERIOD_BASED = 'period_based',
+}
+
+/**
+ * Halves-based sports period-to-typeId mapping (Soccer, NCAAB)
+ * Period 1 = 1st half
+ * Period 2 = 2nd half
+ */
+export const HALVES_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10051, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st half
+    2: [10022, 10032, 10042, 10052, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd half
+};
+
+/**
+ * Quarters-based sports period-to-typeId mapping (NFL, NBA)
+ * Period 1 = 1st quarter
+ * Period 2 = 2nd quarter (also completes 1st half - typeId 10051)
+ * Period 3 = 3rd quarter
+ * Period 4 = 4th quarter (also completes 2nd half - typeId 10052)
+ * Period 5+ = Overtime
+ */
+export const QUARTERS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st quarter
+    2: [10022, 10032, 10042, 10051, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd quarter + 1st half
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd quarter
+    4: [10024, 10034, 10044, 10052, 10064, 10074, 10084, 10411, 10412, 10124], // 4th quarter + 2nd half
+    5: [10025, 10035, 10045, 10055, 10065, 10075, 10085, 10511, 10512], // Overtime/5th period
+};
+
+/**
+ * Innings-based sports period-to-typeId mapping (MLB, NPB, KBO, College Baseball)
+ * Period 1-5 = Innings 1-5 (period 5 completes 1st half - typeId 10051)
+ * Period 6-9 = Innings 6-9 (period 9 completes 2nd half - typeId 10052)
+ */
+export const INNINGS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st inning
+    2: [10022, 10032, 10042, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd inning
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd inning
+    4: [10024, 10034, 10044, 10064, 10074, 10084, 10411, 10412, 10124], // 4th inning
+    5: [10025, 10035, 10045, 10051, 10065, 10075, 10085, 10511, 10512], // 5th inning + 1st half
+    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086, 10611, 10612], // 6th inning
+    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087, 10711, 10712], // 7th inning
+    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088, 10811, 10812], // 8th inning
+    9: [10029, 10039, 10049, 10052, 10069, 10079, 10089], // 9th inning + 2nd half
+};
+
+/**
+ * Period-based sports period-to-typeId mapping (9 periods)
+ * Excludes halves types (10051, 10052) and secondary moneyline types (ending in 11/12)
+ */
+export const PERIOD_BASED_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10121, 10163], // 1st period
+    2: [10022, 10032, 10042, 10062, 10072, 10082, 10122], // 2nd period
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10123], // 3rd period
+    4: [10024, 10034, 10044, 10064, 10074, 10084, 10124], // 4th period
+    5: [10025, 10035, 10045, 10065, 10075, 10085], // 5th period
+    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086], // 6th period
+    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087], // 7th period
+    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088], // 8th period
+    9: [10029, 10039, 10049, 10069, 10079, 10089], // 9th period
+};
+
+/**
+ * Full game type IDs that should NOT be resolved during live games
+ * These can only be resolved when the game status is "completed"
+ */
+export const FULL_GAME_TYPE_IDS: number[] = [0, 10001, 10002, 10003, 10004, 10010, 10011, 10012];

package/src/types/sports.ts

@@ -1,19 +1,19 @@
-
-export type LeagueConfigInfo = {
-    sportId: number;
-    typeId: number;
-    marketName: string;
-    type: string;
-    enabled: string;
-    minOdds: number;
-    maxOdds: number;
-    addedSpread?: number;
-};
-
-export type ChildMarket = {
-    leagueId: number;
-    typeId: number;
-    type: string;
-    line: number;
-    odds: Array<number>;
-};
+
+export type LeagueConfigInfo = {
+    sportId: number;
+    typeId: number;
+    marketName: string;
+    type: string;
+    enabled: string;
+    minOdds: number;
+    maxOdds: number;
+    addedSpread?: number;
+};
+
+export type ChildMarket = {
+    leagueId: number;
+    typeId: number;
+    type: string;
+    line: number;
+    odds: Array<number>;
+};

package/src/utils/bookmakers.ts

@@ -1,159 +1,159 @@
-import * as oddslib from 'oddslib';
-import {
-    DIFF_BETWEEN_BOOKMAKERS_MESSAGE,
-    NO_MATCHING_BOOKMAKERS_MESSAGE,
-    ZERO_ODDS_MESSAGE,
-    ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER,
-} from '../constants/errors';
-
-export const getBookmakersArray = (bookmakersData: any[], sportId: any, backupLiveOddsProviders: string[]) => {
-    const sportBookmakersData = bookmakersData.find((data) => Number(data.sportId) === Number(sportId));
-    if (sportBookmakersData) {
-        if (sportBookmakersData.primaryBookmaker == '') {
-            return backupLiveOddsProviders;
-        }
-        const bookmakersArray: string[] = [];
-
-        sportBookmakersData.primaryBookmaker ? bookmakersArray.push(sportBookmakersData.primaryBookmaker) : '';
-        sportBookmakersData.secondaryBookmaker ? bookmakersArray.push(sportBookmakersData.secondaryBookmaker) : '';
-        sportBookmakersData.tertiaryBookmaker ? bookmakersArray.push(sportBookmakersData.tertiaryBookmaker) : '';
-
-        return bookmakersArray;
-    }
-    return backupLiveOddsProviders;
-};
-
-export const checkOddsFromBookmakers = (
-    oddsMap: Map<string, any>,
-    arrayOfBookmakers: string[],
-    isTwoPositionalSport: boolean,
-    maxImpliedPercentageDifference: number,
-    minOddsForDiffChecking: number
-) => {
-    // Main bookmaker odds
-    const firstBookmakerOdds = oddsMap.get(arrayOfBookmakers[0].toLowerCase());
-
-    if (!firstBookmakerOdds) {
-        // If no matching bookmakers are found, return zero odds
-        return {
-            homeOdds: 0,
-            awayOdds: 0,
-            drawOdds: 0,
-            errorMessage: NO_MATCHING_BOOKMAKERS_MESSAGE,
-        };
-    }
-
-    const homeOdd = firstBookmakerOdds.homeOdds;
-    const awayOdd = firstBookmakerOdds.awayOdds;
-    const drawOdd = isTwoPositionalSport ? 0 : firstBookmakerOdds.drawOdds;
-
-    // Check if any bookmaker has odds of 0 or 0.0001
-    const hasZeroOrOne = arrayOfBookmakers.some((bookmakerId) => {
-        const line = oddsMap.get(bookmakerId);
-        if (line) {
-            return (
-                line.homeOdds === 0 ||
-                line.awayOdds === 0 ||
-                (!isTwoPositionalSport && line.drawOdds === 0) ||
-                line.homeOdds === 1 ||
-                line.awayOdds === 1 ||
-                (!isTwoPositionalSport && line.drawOdds === 1)
-            );
-        }
-        return false; // fix for es-lint
-    });
-
-    if (hasZeroOrOne) {
-        // If any bookmaker has zero odds, return zero odds
-        return {
-            homeOdds: 0,
-            awayOdds: 0,
-            drawOdds: 0,
-            errorMessage: arrayOfBookmakers.length === 1 ? ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER : ZERO_ODDS_MESSAGE,
-            // TODO: Return sportsbook name with zero odds
-        };
-    }
-
-    if (arrayOfBookmakers.length == 1) {
-        return {
-            homeOdds: homeOdd,
-            awayOdds: awayOdd,
-            drawOdds: isTwoPositionalSport ? 0 : drawOdd,
-        };
-    }
-
-    // If none of the bookmakers have zero odds, check implied odds percentage difference
-    const hasLargeImpliedPercentageDifference = arrayOfBookmakers.slice(1).some((bookmakerId) => {
-        const line = oddsMap.get(bookmakerId);
-        if (line) {
-            const otherHomeOdd = line.homeOdds;
-            const otherAwayOdd = line.awayOdds;
-            const otherDrawOdd = line.drawOdds;
-
-            const homeOddsImplied = oddslib.from('decimal', homeOdd).to('impliedProbability');
-
-            const awayOddsImplied = oddslib.from('decimal', awayOdd).to('impliedProbability');
-
-            // Calculate implied odds for the "draw" if it's not a two-positions sport
-            const drawOddsImplied = isTwoPositionalSport
-                ? 0
-                : oddslib.from('decimal', drawOdd).to('impliedProbability');
-
-            const otherHomeOddImplied = oddslib.from('decimal', otherHomeOdd).to('impliedProbability');
-
-            const otherAwayOddImplied = oddslib.from('decimal', otherAwayOdd).to('impliedProbability');
-
-            // Calculate implied odds for the "draw" if it's not a two-positions sport
-            const otherDrawOddImplied = isTwoPositionalSport
-                ? 0
-                : oddslib.from('decimal', otherDrawOdd).to('impliedProbability');
-
-            // Calculate the percentage difference for implied odds
-            const homeOddsDifference = calculateImpliedOddsDifference(homeOddsImplied, otherHomeOddImplied);
-
-            const awayOddsDifference = calculateImpliedOddsDifference(awayOddsImplied, otherAwayOddImplied);
-
-            // Check implied odds difference for the "draw" only if it's not a two-positions sport
-            const drawOddsDifference = isTwoPositionalSport
-                ? 0
-                : calculateImpliedOddsDifference(drawOddsImplied, otherDrawOddImplied);
-
-            // Check if the percentage difference exceeds the threshold
-            if (
-                (homeOddsDifference > maxImpliedPercentageDifference &&
-                    homeOddsImplied > minOddsForDiffChecking &&
-                    otherHomeOddImplied > minOddsForDiffChecking) ||
-                (awayOddsDifference > maxImpliedPercentageDifference &&
-                    awayOddsImplied > minOddsForDiffChecking &&
-                    otherAwayOddImplied > minOddsForDiffChecking) ||
-                (!isTwoPositionalSport &&
-                    drawOddsDifference > maxImpliedPercentageDifference &&
-                    drawOddsImplied > minOddsForDiffChecking &&
-                    otherDrawOddImplied > minOddsForDiffChecking)
-            ) {
-                return true;
-            }
-        }
-        return false;
-    });
-
-    if (hasLargeImpliedPercentageDifference) {
-        return {
-            homeOdds: 0,
-            awayOdds: 0,
-            drawOdds: 0,
-            errorMessage: DIFF_BETWEEN_BOOKMAKERS_MESSAGE,
-        };
-    }
-
-    return {
-        homeOdds: homeOdd,
-        awayOdds: awayOdd,
-        drawOdds: isTwoPositionalSport ? 0 : drawOdd,
-    };
-};
-
-export const calculateImpliedOddsDifference = (impliedOddsA: number, impliedOddsB: number): number => {
-    const percentageDifference = (Math.abs(impliedOddsA - impliedOddsB) / impliedOddsA) * 100;
-    return percentageDifference;
-};
+import * as oddslib from 'oddslib';
+import {
+    DIFF_BETWEEN_BOOKMAKERS_MESSAGE,
+    NO_MATCHING_BOOKMAKERS_MESSAGE,
+    ZERO_ODDS_MESSAGE,
+    ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER,
+} from '../constants/errors';
+
+export const getBookmakersArray = (bookmakersData: any[], sportId: any, backupLiveOddsProviders: string[]) => {
+    const sportBookmakersData = bookmakersData.find((data) => Number(data.sportId) === Number(sportId));
+    if (sportBookmakersData) {
+        if (sportBookmakersData.primaryBookmaker == '') {
+            return backupLiveOddsProviders;
+        }
+        const bookmakersArray: string[] = [];
+
+        sportBookmakersData.primaryBookmaker ? bookmakersArray.push(sportBookmakersData.primaryBookmaker) : '';
+        sportBookmakersData.secondaryBookmaker ? bookmakersArray.push(sportBookmakersData.secondaryBookmaker) : '';
+        sportBookmakersData.tertiaryBookmaker ? bookmakersArray.push(sportBookmakersData.tertiaryBookmaker) : '';
+
+        return bookmakersArray;
+    }
+    return backupLiveOddsProviders;
+};
+
+export const checkOddsFromBookmakers = (
+    oddsMap: Map<string, any>,
+    arrayOfBookmakers: string[],
+    isTwoPositionalSport: boolean,
+    maxImpliedPercentageDifference: number,
+    minOddsForDiffChecking: number
+) => {
+    // Main bookmaker odds
+    const firstBookmakerOdds = oddsMap.get(arrayOfBookmakers[0].toLowerCase());
+
+    if (!firstBookmakerOdds) {
+        // If no matching bookmakers are found, return zero odds
+        return {
+            homeOdds: 0,
+            awayOdds: 0,
+            drawOdds: 0,
+            errorMessage: NO_MATCHING_BOOKMAKERS_MESSAGE,
+        };
+    }
+
+    const homeOdd = firstBookmakerOdds.homeOdds;
+    const awayOdd = firstBookmakerOdds.awayOdds;
+    const drawOdd = isTwoPositionalSport ? 0 : firstBookmakerOdds.drawOdds;
+
+    // Check if any bookmaker has odds of 0 or 0.0001
+    const hasZeroOrOne = arrayOfBookmakers.some((bookmakerId) => {
+        const line = oddsMap.get(bookmakerId);
+        if (line) {
+            return (
+                line.homeOdds === 0 ||
+                line.awayOdds === 0 ||
+                (!isTwoPositionalSport && line.drawOdds === 0) ||
+                line.homeOdds === 1 ||
+                line.awayOdds === 1 ||
+                (!isTwoPositionalSport && line.drawOdds === 1)
+            );
+        }
+        return false; // fix for es-lint
+    });
+
+    if (hasZeroOrOne) {
+        // If any bookmaker has zero odds, return zero odds
+        return {
+            homeOdds: 0,
+            awayOdds: 0,
+            drawOdds: 0,
+            errorMessage: arrayOfBookmakers.length === 1 ? ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER : ZERO_ODDS_MESSAGE,
+            // TODO: Return sportsbook name with zero odds
+        };
+    }
+
+    if (arrayOfBookmakers.length == 1) {
+        return {
+            homeOdds: homeOdd,
+            awayOdds: awayOdd,
+            drawOdds: isTwoPositionalSport ? 0 : drawOdd,
+        };
+    }
+
+    // If none of the bookmakers have zero odds, check implied odds percentage difference
+    const hasLargeImpliedPercentageDifference = arrayOfBookmakers.slice(1).some((bookmakerId) => {
+        const line = oddsMap.get(bookmakerId);
+        if (line) {
+            const otherHomeOdd = line.homeOdds;
+            const otherAwayOdd = line.awayOdds;
+            const otherDrawOdd = line.drawOdds;
+
+            const homeOddsImplied = oddslib.from('decimal', homeOdd).to('impliedProbability');
+
+            const awayOddsImplied = oddslib.from('decimal', awayOdd).to('impliedProbability');
+
+            // Calculate implied odds for the "draw" if it's not a two-positions sport
+            const drawOddsImplied = isTwoPositionalSport
+                ? 0
+                : oddslib.from('decimal', drawOdd).to('impliedProbability');
+
+            const otherHomeOddImplied = oddslib.from('decimal', otherHomeOdd).to('impliedProbability');
+
+            const otherAwayOddImplied = oddslib.from('decimal', otherAwayOdd).to('impliedProbability');
+
+            // Calculate implied odds for the "draw" if it's not a two-positions sport
+            const otherDrawOddImplied = isTwoPositionalSport
+                ? 0
+                : oddslib.from('decimal', otherDrawOdd).to('impliedProbability');
+
+            // Calculate the percentage difference for implied odds
+            const homeOddsDifference = calculateImpliedOddsDifference(homeOddsImplied, otherHomeOddImplied);
+
+            const awayOddsDifference = calculateImpliedOddsDifference(awayOddsImplied, otherAwayOddImplied);
+
+            // Check implied odds difference for the "draw" only if it's not a two-positions sport
+            const drawOddsDifference = isTwoPositionalSport
+                ? 0
+                : calculateImpliedOddsDifference(drawOddsImplied, otherDrawOddImplied);
+
+            // Check if the percentage difference exceeds the threshold
+            if (
+                (homeOddsDifference > maxImpliedPercentageDifference &&
+                    homeOddsImplied > minOddsForDiffChecking &&
+                    otherHomeOddImplied > minOddsForDiffChecking) ||
+                (awayOddsDifference > maxImpliedPercentageDifference &&
+                    awayOddsImplied > minOddsForDiffChecking &&
+                    otherAwayOddImplied > minOddsForDiffChecking) ||
+                (!isTwoPositionalSport &&
+                    drawOddsDifference > maxImpliedPercentageDifference &&
+                    drawOddsImplied > minOddsForDiffChecking &&
+                    otherDrawOddImplied > minOddsForDiffChecking)
+            ) {
+                return true;
+            }
+        }
+        return false;
+    });
+
+    if (hasLargeImpliedPercentageDifference) {
+        return {
+            homeOdds: 0,
+            awayOdds: 0,
+            drawOdds: 0,
+            errorMessage: DIFF_BETWEEN_BOOKMAKERS_MESSAGE,
+        };
+    }
+
+    return {
+        homeOdds: homeOdd,
+        awayOdds: awayOdd,
+        drawOdds: isTwoPositionalSport ? 0 : drawOdd,
+    };
+};
+
+export const calculateImpliedOddsDifference = (impliedOddsA: number, impliedOddsB: number): number => {
+    const percentageDifference = (Math.abs(impliedOddsA - impliedOddsB) / impliedOddsA) * 100;
+    return percentageDifference;
+};