overtime-live-trading-utils 2.1.44 → 2.1.45-rc.0

package/src/tests/unit/bookmakers.test.ts

@@ -1,9 +1,18 @@
+import { MAX_IMPLIED_PERCENTAGE_DIFF } from '../../constants/common';
 import { DIFF_BETWEEN_BOOKMAKERS_MESSAGE, ZERO_ODDS_MESSAGE } from '../../constants/errors';
 import { processMarket } from '../../utils/markets';
 import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
 import { LeagueMocks } from '../mock/MockLeagueMap';
-import { MockOnlyMoneyline, MockOnlyMoneylineWithDifferentSportsbook } from '../mock/MockOpticSoccer';
+import {
+    MockOddsChildMarketsDifferentBookmakers,
+    MockOddsChildMarketsDifferentBookmakersPercentageDiff,
+    MockOnlyMoneyline,
+    MockOnlyMoneylineWithDifferentSportsbook,
+} from '../mock/MockOpticSoccer';
 import { mockSoccer } from '../mock/MockSoccerRedis';
+import { getLastPolledMapForBookmakers, MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST } from '../utils/helper';
+
+const lastPolledMap = getLastPolledMapForBookmakers();
 
 describe('Bookmakers', () => {
     it('Should return zero odds for moneyline when one of the bookmakers has no odds', () => {
@@ -16,8 +25,10 @@ describe('Bookmakers', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -27,7 +38,6 @@ describe('Bookmakers', () => {
         expect(hasOdds).toBe(false);
         expect(market).toHaveProperty('errorMessage');
         expect(market.errorMessage).toBe(ZERO_ODDS_MESSAGE);
-        expect(market.childMarkets.length).toBe(0);
     });
 
     it('Should return zero odds for moneyline when there is quote diff between bookmakers', () => {
@@ -41,7 +51,9 @@ describe('Bookmakers', () => {
             true,
             undefined,
             5,
-            LeagueMocks.leagueInfoOnlyParent
+            LeagueMocks.leagueInfoOnlyParent,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -51,7 +63,6 @@ describe('Bookmakers', () => {
         expect(hasOdds).toBe(false);
         expect(market).toHaveProperty('errorMessage');
         expect(market.errorMessage).toBe(DIFF_BETWEEN_BOOKMAKERS_MESSAGE);
-        expect(market.childMarkets.length).toBe(0);
     });
 
     it('Should return zero odds for moneyline as no matching bookmaker was provided', () => {
@@ -64,8 +75,10 @@ describe('Bookmakers', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -76,4 +89,61 @@ describe('Bookmakers', () => {
         expect(market).toHaveProperty('errorMessage');
         expect(market.errorMessage).toBe(ZERO_ODDS_MESSAGE); // should be no matching bookmakers mesage
     });
+
+    it('Should return odds that have both bookmakers', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOddsChildMarketsDifferentBookmakers));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['bovada', 'draftkings'],
+            [],
+            true,
+            undefined,
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+        );
+
+        expect(market.childMarkets.length).toBe(2);
+    });
+
+    it('Should return all odds from draftkings', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOddsChildMarketsDifferentBookmakers));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['bovada', 'draftkings'],
+            [],
+            true,
+            undefined,
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leaguInfoDifferentPrimaryBookmaker,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+        );
+
+        expect(market.childMarkets.length).toBe(3);
+    });
+
+    it('Should cut odds that are different between bookmakers', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOddsChildMarketsDifferentBookmakersPercentageDiff));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['bovada', 'draftkings'],
+            [],
+            true,
+            undefined,
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+        );
+
+        expect(market.childMarkets.length).toBe(1);
+    });
 });

package/src/tests/unit/markets.test.ts

@@ -1,9 +1,13 @@
+import { MAX_IMPLIED_PERCENTAGE_DIFF } from '../../constants/common';
 import { NO_MARKETS_FOR_LEAGUE_ID } from '../../constants/errors';
 import { processMarket } from '../../utils/markets';
 import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
 import { LeagueMocks } from '../mock/MockLeagueMap';
 import { MockOnlyMoneyline, MockOpticSoccer } from '../mock/MockOpticSoccer';
 import { mockSoccer } from '../mock/MockSoccerRedis';
+import { getLastPolledMapForBookmakers, MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST } from '../utils/helper';
+
+const lastPolledMap = getLastPolledMapForBookmakers();
 
 describe('Markets', () => {
     describe('LeagueMap configuration', () => {
@@ -18,8 +22,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoOnlyParent
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoOnlyParent,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             expect(market.childMarkets).toHaveLength(0);
@@ -35,8 +41,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoMockDisabledChilds
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoMockDisabledChilds,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             expect(market.childMarkets).toHaveLength(0);
@@ -52,8 +60,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoEnabledSpreadDisabledTotals
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoEnabledSpreadDisabledTotals,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             const containsSpread = market.childMarkets.some((child: any) => child.type === 'spread');
@@ -73,8 +83,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoEnabledSpeadAndTotals
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             const containsSpread = market.childMarkets.some((child: any) => child.type === 'spread');
@@ -94,8 +106,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoEnabledAll
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoEnabledAll,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             const containsSpread = market.childMarkets.some((child: any) => child.type === 'spread');
@@ -117,6 +131,9 @@ describe('Markets', () => {
                 (child: any) => child.type === 'willThereBeOvertime'
             );
 
+            const containsTeamTotalHome = market.childMarkets.some((child: any) => child.type === 'totalHomeTeam');
+            const containsTeamTotalAway = market.childMarkets.some((child: any) => child.type === 'totalAwayTeam');
+
             expect(containsChildGG).toBe(true);
             expect(containsChildGG1stHalf).toBe(true);
             expect(containsChildGG2ndHalf).toBe(true);
@@ -128,6 +145,8 @@ describe('Markets', () => {
             expect(containsChildGG).toBe(true);
             expect(containsChildDrawNoBet).toBe(true);
             expect(containsWillThereBeOvertime).toBe(true);
+            expect(containsTeamTotalHome).toBe(true);
+            expect(containsTeamTotalAway).toBe(true);
         });
 
         it('Should return warning message that there are is no configuration available in league map csv', () => {
@@ -142,8 +161,10 @@ describe('Markets', () => {
                 [],
                 true,
                 undefined,
-                undefined,
-                LeagueMocks.leagueInfoOnlyParentDiffSportId
+                MAX_IMPLIED_PERCENTAGE_DIFF,
+                LeagueMocks.leagueInfoOnlyParentDiffSportId,
+                lastPolledMap,
+                MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
             );
 
             expect(warnSpy).toHaveBeenCalled();

package/src/tests/unit/odds.test.ts

@@ -1,3 +1,4 @@
+import { MAX_IMPLIED_PERCENTAGE_DIFF } from '../../constants/common';
 import { ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER } from '../../constants/errors';
 import { processMarket } from '../../utils/markets';
 import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
@@ -9,6 +10,9 @@ import {
     MockZeroOdds,
 } from '../mock/MockOpticSoccer';
 import { mockSoccer } from '../mock/MockSoccerRedis';
+import { getLastPolledMapForBookmakers, MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST } from '../utils/helper';
+
+const lastPolledMap = getLastPolledMapForBookmakers();
 
 describe('Odds', () => {
     it('Should return odds for moneyline', () => {
@@ -21,8 +25,10 @@ describe('Odds', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoOnlyParent
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoOnlyParent,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -42,8 +48,10 @@ describe('Odds', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -65,8 +73,10 @@ describe('Odds', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasChildMarkets = market.childMarkets.length > 0;
@@ -83,8 +93,10 @@ describe('Odds', () => {
             [],
             true,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         expect(market.childMarkets).toHaveLength(0);

package/src/tests/unit/spread.test.ts

@@ -1,9 +1,13 @@
+import { MAX_IMPLIED_PERCENTAGE_DIFF } from '../../constants/common';
 import { ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT } from '../../constants/errors';
 import { processMarket } from '../../utils/markets';
 import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
 import { LeagueMocks } from '../mock/MockLeagueMap';
 import { MockAfterSpreadZeroOdds1, MockOnlyMoneylineFavorite, MockOpticSoccer } from '../mock/MockOpticSoccer';
 import { mockSoccer } from '../mock/MockSoccerRedis';
+import { getLastPolledMapForBookmakers, MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST } from '../utils/helper';
+
+const lastPolledMap = getLastPolledMapForBookmakers();
 
 describe('Spread configuration', () => {
     it('Should return zero odds for quotes that sum up total probability above 1', () => {
@@ -16,8 +20,10 @@ describe('Spread configuration', () => {
             [],
             false,
             undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            MAX_IMPLIED_PERCENTAGE_DIFF,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
         );
 
         const hasOdds = market.odds.some(
@@ -41,8 +47,10 @@ describe('Spread configuration', () => {
                     [],
                     true,
                     undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
+                    MAX_IMPLIED_PERCENTAGE_DIFF,
+                    LeagueMocks.leagueInfoOnlyParent,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
                 )
             )
         );
@@ -56,8 +64,10 @@ describe('Spread configuration', () => {
                     [],
                     true,
                     undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
+                    MAX_IMPLIED_PERCENTAGE_DIFF,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
                 )
             )
         );
@@ -91,8 +101,10 @@ describe('Spread configuration', () => {
                     [],
                     true,
                     undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
+                    MAX_IMPLIED_PERCENTAGE_DIFF,
+                    LeagueMocks.leagueInfoOnlyParent,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
                 )
             )
         );
@@ -106,8 +118,10 @@ describe('Spread configuration', () => {
                     [],
                     true,
                     undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
+                    MAX_IMPLIED_PERCENTAGE_DIFF,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
                 )
             )
         );

package/src/tests/utils/helper.ts

@@ -0,0 +1,10 @@
+import { LastPolledArray } from '../../types/sports';
+
+export const getLastPolledMapForBookmakers = () => {
+    const lastPolledMap: LastPolledArray = [];
+    lastPolledMap.push({ sportsbook: 'draftkings', timestamp: Date.now() });
+    lastPolledMap.push({ sportsbook: 'bovada', timestamp: Date.now() });
+    return lastPolledMap;
+};
+
+export const MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST = 30000; // 30 seconds

package/src/types/bookmakers.ts

@@ -0,0 +1,7 @@
+export type BookmakersConfig = {
+    sportName: string;
+    sportId: number;
+    primaryBookmaker: string;
+    secondaryBookmaker: string;
+    tertiaryBookmaker: string;
+};

package/src/types/odds.ts

@@ -1,3 +1,5 @@
+import { LeagueConfigInfo } from './sports';
+
 export type Fixture = {
     gameId: string;
     startDate: number;
@@ -34,6 +36,23 @@ export type OddsObject = {
     odds: Odds;
 };
 
+export type OddsWithLeagueInfo = [
+    {
+        id: string;
+        sportsBookName: string;
+        name: string;
+        price: number;
+        timestamp: number;
+        points: number;
+        isMain: boolean;
+        isLive: boolean;
+        marketName: string;
+        playerId: string;
+        selection: string;
+        selectionLine: string;
+    } & LeagueConfigInfo
+];
+
 export type ScoresObject = {
     gameId: string;
     sport: string;

package/src/types/sports.ts

@@ -1,4 +1,3 @@
-
 export type LeagueConfigInfo = {
     sportId: number;
     typeId: number;
@@ -8,6 +7,8 @@ export type LeagueConfigInfo = {
     minOdds: number;
     maxOdds: number;
     addedSpread?: number;
+    primaryBookmaker?: string;
+    secondaryBookmaker?: string;
 };
 
 export type ChildMarket = {
@@ -17,3 +18,5 @@ export type ChildMarket = {
     line: number;
     odds: Array<number>;
 };
+
+export type LastPolledArray = { sportsbook: string; timestamp: number }[];

package/src/utils/bookmakers.ts

@@ -1,12 +1,20 @@
 import * as oddslib from 'oddslib';
+import { MIN_ODDS_FOR_DIFF_CHECKING } from '../constants/common';
 import {
     DIFF_BETWEEN_BOOKMAKERS_MESSAGE,
     NO_MATCHING_BOOKMAKERS_MESSAGE,
     ZERO_ODDS_MESSAGE,
     ZERO_ODDS_MESSAGE_SINGLE_BOOKMAKER,
 } from '../constants/errors';
+import { BookmakersConfig } from '../types/bookmakers';
+import { OddsWithLeagueInfo } from '../types/odds';
+import { LastPolledArray, LeagueConfigInfo } from '../types/sports';
 
-export const getBookmakersArray = (bookmakersData: any[], sportId: any, backupLiveOddsProviders: string[]) => {
+export const getBookmakersArray = (
+    bookmakersData: BookmakersConfig[],
+    sportId: any,
+    backupLiveOddsProviders: string[]
+) => {
     const sportBookmakersData = bookmakersData.find((data) => Number(data.sportId) === Number(sportId));
     if (sportBookmakersData) {
         if (sportBookmakersData.primaryBookmaker == '') {
@@ -23,6 +31,45 @@ export const getBookmakersArray = (bookmakersData: any[], sportId: any, backupLi
     return backupLiveOddsProviders;
 };
 
+export const getBookmakersFromLeagueConfig = (sportId: string | number, leagueInfoArray: LeagueConfigInfo[]) => {
+    const uniqueBookmakers = [];
+
+    for (const leagueInfo of leagueInfoArray) {
+        if (Number(leagueInfo.sportId) === Number(sportId) && leagueInfo.enabled === 'true') {
+            const primary = leagueInfo.primaryBookmaker?.toLowerCase();
+            const secondary = leagueInfo.secondaryBookmaker?.toLowerCase();
+            if (primary) {
+                uniqueBookmakers.push(primary);
+            }
+            if (secondary && secondary !== primary) {
+                uniqueBookmakers.push(secondary);
+            }
+            break;
+        }
+    }
+
+    return uniqueBookmakers;
+};
+
+export const getBookmakersForLeague = (
+    sportId: string | number,
+    configPerMarket: LeagueConfigInfo[],
+    configPerLeague: BookmakersConfig[],
+    defaultBookmakers: string[],
+    maxNumOfBookmakers = 5
+) => {
+    // bookmakers defined per market for league
+    const bookmakersPerMarket = getBookmakersFromLeagueConfig(sportId, configPerMarket);
+    // bookmakers defined generally per league
+    const bookmakersPerLeague = getBookmakersArray(configPerLeague, sportId, defaultBookmakers);
+    // all unique bookmakers defined from both configs
+    const uniqueBookmakers = [...new Set([...bookmakersPerMarket, ...bookmakersPerLeague])];
+
+    const bookmakers = uniqueBookmakers.filter((s) => s.length).slice(0, maxNumOfBookmakers);
+
+    return bookmakers;
+};
+
 export const checkOddsFromBookmakers = (
     oddsMap: Map<string, any>,
     arrayOfBookmakers: string[],
@@ -153,6 +200,122 @@ export const checkOddsFromBookmakers = (
     };
 };
 
+export const checkOddsFromBookmakersForChildMarkets = (
+    odds: any,
+    leagueInfos: LeagueConfigInfo[],
+    oddsProviders: string[],
+    lastPolledMap: LastPolledArray,
+    maxAllowedProviderDataStaleDelay: number,
+    maxImpliedPercentageDifference: number
+): OddsWithLeagueInfo => {
+    const formattedOdds = Object.entries(odds as any).reduce((acc: any, [key, value]: [string, any]) => {
+        const [sportsBookName, marketName, points, selection, selectionLine] = key.split('_');
+        const info = leagueInfos.find((leagueInfo) => leagueInfo.marketName.toLowerCase() === marketName.toLowerCase());
+        if (info) {
+            const { primaryBookmaker, secondaryBookmaker } = getPrimaryAndSecondaryBookmakerForTypeId(
+                oddsProviders,
+                leagueInfos,
+                Number(info.typeId)
+            );
+
+            const isValidLastPolled = isLastPolledForBookmakersValid(
+                lastPolledMap,
+                maxAllowedProviderDataStaleDelay,
+                primaryBookmaker,
+                secondaryBookmaker
+            );
+
+            if (isValidLastPolled) {
+                if (primaryBookmaker && !secondaryBookmaker) {
+                    if (sportsBookName.toLowerCase() === primaryBookmaker.toLowerCase()) {
+                        acc.push(value);
+                    }
+                } else {
+                    if (sportsBookName.toLowerCase() === primaryBookmaker) {
+                        const secondaryBookmakerObject =
+                            odds[
+                                `${secondaryBookmaker}_${marketName.toLowerCase()}_${points}_${selection}_${selectionLine}`
+                            ];
+                        if (secondaryBookmakerObject) {
+                            const primaryOdds = oddslib.from('decimal', value.price).to('impliedProbability');
+                            const secondaryOdds = oddslib
+                                .from('decimal', secondaryBookmakerObject.price)
+                                .to('impliedProbability');
+                            if (
+                                primaryOdds >= MIN_ODDS_FOR_DIFF_CHECKING &&
+                                secondaryOdds >= MIN_ODDS_FOR_DIFF_CHECKING
+                            ) {
+                                const homeOddsDifference = calculateImpliedOddsDifference(primaryOdds, secondaryOdds);
+                                if (Number(homeOddsDifference) <= Number(maxImpliedPercentageDifference)) {
+                                    acc.push(value);
+                                }
+                            } else {
+                                acc.push(value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return acc;
+    }, []);
+    return formattedOdds;
+};
+
+export const getPrimaryAndSecondaryBookmakerForTypeId = (
+    defaultProviders: string[],
+    leagueInfos: LeagueConfigInfo[], // LeagueConfigInfo for specific sport, not the entire list from csv
+    typeId: number
+): { primaryBookmaker: string; secondaryBookmaker: string | undefined } => {
+    const info = leagueInfos.find((leagueInfo) => Number(leagueInfo.typeId) === typeId);
+    let primaryBookmaker = defaultProviders[0].toLowerCase();
+    let secondaryBookmaker = defaultProviders[1] ? defaultProviders[1].toLowerCase() : undefined;
+    if (info) {
+        if (info.primaryBookmaker) {
+            primaryBookmaker = info.primaryBookmaker.toLowerCase();
+            secondaryBookmaker = info.secondaryBookmaker ? info.secondaryBookmaker.toLowerCase() : undefined;
+        }
+    }
+    return { primaryBookmaker, secondaryBookmaker };
+};
+
+export const isLastPolledForBookmakersValid = (
+    lastPolledMap: LastPolledArray,
+    maxAllowedProviderDataStaleDelay: number,
+    primaryBookmaker: string,
+    secondaryBookmaker?: string
+): boolean => {
+    const lastPolledTimePrimary = lastPolledMap.find(
+        (entry) => entry.sportsbook.toLowerCase() === primaryBookmaker.toLowerCase()
+    )?.timestamp;
+    if (typeof lastPolledTimePrimary !== 'number') {
+        return false;
+    }
+
+    const now = new Date();
+    if (secondaryBookmaker) {
+        const lastPolledTimeSecondary = lastPolledMap.find(
+            (entry) => entry.sportsbook.toLowerCase() === secondaryBookmaker.toLowerCase()
+        )?.timestamp;
+
+        if (typeof lastPolledTimeSecondary !== 'number') {
+            return false;
+        }
+
+        const oddsDate = new Date(lastPolledTimeSecondary * 1000);
+        const timeDiff = now.getTime() - oddsDate.getTime();
+        if (timeDiff > maxAllowedProviderDataStaleDelay) {
+            return false;
+        }
+    }
+
+    const oddsDate = new Date(lastPolledTimePrimary * 1000);
+    const timeDiff = now.getTime() - oddsDate.getTime();
+
+    return timeDiff <= maxAllowedProviderDataStaleDelay;
+};
+
 export const calculateImpliedOddsDifference = (impliedOddsA: number, impliedOddsB: number): number => {
     const percentageDifference = (Math.abs(impliedOddsA - impliedOddsB) / impliedOddsA) * 100;
     return percentageDifference;