overtime-live-trading-utils 2.1.35 → 2.1.37-rc.0

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

@@ -1,58 +1,58 @@
-import {
-    getBetTypesForLeague,
-    getLeagueSpreadTypes,
-    getLeagueTotalTypes,
-    getLiveSupportedLeagues,
-} from '../../utils/sports';
-import { LeagueMocks } from '../mock/MockLeagueMap';
-
-describe('Sports', () => {
-    it('Should return all enabled leagues for LIVE', () => {
-        const supportedLeageus = getLiveSupportedLeagues(LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(supportedLeageus).toContain(9806);
-    });
-
-    it('Should return all enabled bet types for league', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledAll);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).toContain('Total Goals');
-        expect(betTypes).toContain('Double Chance');
-        expect(betTypes).toContain('Correct Score');
-    });
-
-    it('Should return all enabled bet types for league, and not contain disabled ones (Totals)', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledSpreadDisabledTotals);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).not.toContain('Total Goals');
-    });
-
-    it('Should return all enabled bet types for league, and not contain disabled ones (Double Chance and Correct Score)', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoDisabledCorrectScoreAndDoubleChance);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).not.toContain('Double Chance');
-        expect(betTypes).not.toContain('Correct Score');
-    });
-
-    it('Should return all enabled spread bet types for league', () => {
-        const betTypes = getLeagueSpreadTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(betTypes).not.toContain('moneyline');
-        expect(betTypes).toContain('goal spread');
-        expect(betTypes).not.toContain('total goals');
-    });
-
-    it('Should return all enabled total bet types for league', () => {
-        const betTypes = getLeagueTotalTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(betTypes).not.toContain('moneyline');
-        expect(betTypes).not.toContain('goal spread');
-        expect(betTypes).toContain('total goals');
-    });
-});
+import {
+    getBetTypesForLeague,
+    getLeagueSpreadTypes,
+    getLeagueTotalTypes,
+    getLiveSupportedLeagues,
+} from '../../utils/sports';
+import { LeagueMocks } from '../mock/MockLeagueMap';
+
+describe('Sports', () => {
+    it('Should return all enabled leagues for LIVE', () => {
+        const supportedLeageus = getLiveSupportedLeagues(LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(supportedLeageus).toContain(9806);
+    });
+
+    it('Should return all enabled bet types for league', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledAll);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).toContain('Total Goals');
+        expect(betTypes).toContain('Double Chance');
+        expect(betTypes).toContain('Correct Score');
+    });
+
+    it('Should return all enabled bet types for league, and not contain disabled ones (Totals)', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledSpreadDisabledTotals);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).not.toContain('Total Goals');
+    });
+
+    it('Should return all enabled bet types for league, and not contain disabled ones (Double Chance and Correct Score)', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoDisabledCorrectScoreAndDoubleChance);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).not.toContain('Double Chance');
+        expect(betTypes).not.toContain('Correct Score');
+    });
+
+    it('Should return all enabled spread bet types for league', () => {
+        const betTypes = getLeagueSpreadTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(betTypes).not.toContain('moneyline');
+        expect(betTypes).toContain('goal spread');
+        expect(betTypes).not.toContain('total goals');
+    });
+
+    it('Should return all enabled total bet types for league', () => {
+        const betTypes = getLeagueTotalTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(betTypes).not.toContain('moneyline');
+        expect(betTypes).not.toContain('goal spread');
+        expect(betTypes).toContain('total goals');
+    });
+});

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

@@ -1,131 +1,144 @@
-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';
-
-describe('Spread configuration', () => {
-    it('Should return zero odds for quotes that sum up total probability above 1', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockAfterSpreadZeroOdds1));
-        const market = processMarket(
-            freshMockSoccer,
-            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-            ['draftkings'],
-            [],
-            false,
-            undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
-        );
-
-        const hasOdds = market.odds.some(
-            (odd: any) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
-        );
-
-        expect(hasOdds).toBe(false);
-        expect(market).toHaveProperty('errorMessage');
-        expect(market.errorMessage).toBe(ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT); // should be no matching bookmakers mesage
-    });
-
-    it('Should have diff between odds equal to 3%', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
-        const market = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
-                )
-            )
-        );
-
-        const marketWithAddedSpread = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
-                )
-            )
-        );
-
-        const diff1 =
-            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
-            100;
-
-        const diff2 =
-            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
-            100;
-
-        const diff3 =
-            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
-            100;
-
-        expect(Math.round(diff1)).toBe(3);
-        expect(Math.round(diff2)).toBe(3);
-        expect(Math.round(diff3)).toBe(3);
-    });
-
-    it('Should have diff between odds equal to 3%, and one odd should stay the same', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneylineFavorite));
-        const market = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
-                )
-            )
-        );
-
-        const marketWithAddedSpread = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
-                )
-            )
-        );
-
-        const diff1 =
-            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
-            100;
-
-        const diff2 =
-            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
-            100;
-
-        const diff3 =
-            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
-            100;
-
-        expect(Math.round(diff1)).toBe(0);
-        expect(Math.round(diff2)).toBe(3);
-        expect(Math.round(diff3)).toBe(3);
-    });
-});
+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', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockAfterSpreadZeroOdds1));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            false,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals,
+            lastPolledMap,
+            MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+        );
+
+        const hasOdds = market.odds.some(
+            (odd: any) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT); // should be no matching bookmakers mesage
+    });
+
+    it('Should have diff between odds equal to 3%', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+        const market = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParent,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+                )
+            )
+        );
+
+        const marketWithAddedSpread = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+                )
+            )
+        );
+
+        const diff1 =
+            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
+            100;
+
+        const diff2 =
+            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
+            100;
+
+        const diff3 =
+            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
+            100;
+
+        expect(Math.round(diff1)).toBe(3);
+        expect(Math.round(diff2)).toBe(3);
+        expect(Math.round(diff3)).toBe(3);
+    });
+
+    it('Should have diff between odds equal to 3%, and one odd should stay the same', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneylineFavorite));
+        const market = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParent,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+                )
+            )
+        );
+
+        const marketWithAddedSpread = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded,
+                    lastPolledMap,
+                    MAX_ALLOWED_PROVIDER_DATA_STALE_DELAY_TEST
+                )
+            )
+        );
+
+        const diff1 =
+            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
+            100;
+
+        const diff2 =
+            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
+            100;
+
+        const diff3 =
+            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
+            100;
+
+        expect(Math.round(diff1)).toBe(0);
+        expect(Math.round(diff2)).toBe(3);
+        expect(Math.round(diff3)).toBe(3);
+    });
+});

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/missing-types.d.ts

@@ -1,2 +1,2 @@
-declare module 'oddslib';
-declare module 'bytes32';
+declare module 'oddslib';
+declare module 'bytes32';

package/src/types/odds.ts

@@ -1,61 +1,80 @@
-export type Fixture = {
-    gameId: string;
-    startDate: number;
-    homeTeam: string;
-    awayTeam: string;
-};
-
-export type Odds = [
-    {
-        id: string;
-        sportsBookName: string;
-        name: string;
-        price: number;
-        timestamp: number;
-        points: number;
-        isMain: boolean;
-        isLive: boolean;
-        marketName: string;
-        playerId: string;
-        selection: string;
-        selectionLine: string;
-    }
-];
-
-export type OddsObject = {
-    gameId: string;
-    startDate: number;
-    homeTeam: string;
-    awayTeam: string;
-    isLive: boolean;
-    status: string;
-    sport: string;
-    league: string;
-    odds: Odds;
-};
-
-export type ScoresObject = {
-    gameId: string;
-    sport: string;
-    league: string;
-    status: string;
-    isLive: boolean;
-    clock: string;
-    period: string;
-    homeTeam: string;
-    awayTeam: string;
-    homeTotal: string;
-    awayTotal: string;
-    homePeriod1: string;
-    awayPeriod1: string;
-    homePeriod2: string;
-    awayPeriod2: string;
-    homePeriod3: string;
-    awayPeriod3: string;
-    homePeriod4: string;
-    awayPeriod4: string;
-    homePeriod5: string;
-    awayPeriod5: string;
-};
-
-export type HomeAwayTeams = { homeTeam: string; awayTeam: string };
+import { LeagueConfigInfo } from './sports';
+
+export type Fixture = {
+    gameId: string;
+    startDate: number;
+    homeTeam: string;
+    awayTeam: string;
+};
+
+export type Odds = [
+    {
+        id: string;
+        sportsBookName: string;
+        name: string;
+        price: number;
+        timestamp: number;
+        points: number;
+        isMain: boolean;
+        isLive: boolean;
+        marketName: string;
+        playerId: string;
+        selection: string;
+        selectionLine: string;
+    }
+];
+
+export type OddsObject = {
+    gameId: string;
+    startDate: number;
+    homeTeam: string;
+    awayTeam: string;
+    isLive: boolean;
+    status: string;
+    sport: string;
+    league: string;
+    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;
+    league: string;
+    status: string;
+    isLive: boolean;
+    clock: string;
+    period: string;
+    homeTeam: string;
+    awayTeam: string;
+    homeTotal: string;
+    awayTotal: string;
+    homePeriod1: string;
+    awayPeriod1: string;
+    homePeriod2: string;
+    awayPeriod2: string;
+    homePeriod3: string;
+    awayPeriod3: string;
+    homePeriod4: string;
+    awayPeriod4: string;
+    homePeriod5: string;
+    awayPeriod5: string;
+};
+
+export type HomeAwayTeams = { homeTeam: string; awayTeam: string };