overtime-live-trading-utils 1.0.8 → 1.1.0

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

@@ -0,0 +1,77 @@
+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 { mockSoccer } from '../mock/MockSoccerRedis';
+
+describe('Bookmakers', () => {
+    it('Should return zero odds for moneyline when one of the bookmakers has no odds', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneyline));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings', 'bovada'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        const hasOdds = market.odds.some(
+            (odd) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(ZERO_ODDS_MESSAGE);
+    });
+
+    it('Should return zero odds for moneyline when there is quote diff between bookmakers', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneylineWithDifferentSportsbook));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings', 'bovada'],
+            [],
+            true,
+            undefined,
+            5,
+            LeagueMocks.leagueInfoOnlyParent
+        );
+
+        const hasOdds = market.odds.some(
+            (odd) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(DIFF_BETWEEN_BOOKMAKERS_MESSAGE);
+    });
+
+    it('Should return zero odds for moneyline as no matching bookmaker was provided', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneyline));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['bovada', 'draftkings'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        const hasOdds = market.odds.some(
+            (odd) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(ZERO_ODDS_MESSAGE); // should be no matching bookmakers mesage
+    });
+});

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

@@ -0,0 +1,133 @@
+import { processMarket } from '../../utils/markets';
+import { mockSoccer } from '../mock/MockSoccerRedis';
+import { MockOnlyMoneyline, MockOpticSoccer } from '../mock/MockOpticSoccer';
+import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
+import { LeagueMocks } from '../mock/MockLeagueMap';
+import { NO_MARKETS_FOR_LEAGUE_ID } from '../../constants/errors';
+
+describe('Markets', () => {
+    describe('LeagueMap configuration', () => {
+        it('Should return an empty array for child markets when they are not added to list', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+
+            const market = processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoOnlyParent
+            );
+
+            expect(market.childMarkets).toHaveLength(0);
+        });
+
+        it('Should return an empty array for child markets when they are disabled', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+            const market = processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoMockDisabledChilds
+            );
+
+            expect(market.childMarkets).toHaveLength(0);
+        });
+
+        it('Should return only spread child markets without total child markets', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+            const market = processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoEnabledSpreadDisabledTotals
+            );
+
+            const containsSpread = market.childMarkets.some((child) => child.type === 'spread');
+            const containsTotal = market.childMarkets.some((child) => child.type === 'total');
+
+            expect(containsSpread).toBe(true);
+            expect(containsTotal).toBe(false);
+        });
+
+        it('Should return both totals and spread child markets', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+            const market = processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoEnabledSpeadAndTotals
+            );
+
+            const containsSpread = market.childMarkets.some((child) => child.type === 'spread');
+            const containsTotal = market.childMarkets.some((child) => child.type === 'total');
+
+            expect(containsSpread).toBe(true);
+            expect(containsTotal).toBe(true);
+        });
+
+        it('Should return all child markets', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+            const market = processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoEnabledAll
+            );
+
+            const containsSpread = market.childMarkets.some((child) => child.type === 'spread');
+            const containsTotal = market.childMarkets.some((child) => child.type === 'total');
+            const containsChildMoneyline = market.childMarkets.some((child) => child.type === 'moneyline');
+
+            expect(containsSpread).toBe(true);
+            expect(containsTotal).toBe(true);
+            expect(containsChildMoneyline).toBe(true);
+        });
+
+        it('Should return warning message that there are is no configuration available in league map csv', () => {
+            const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+            const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneyline));
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            processMarket(
+                freshMockSoccer,
+                mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                ['draftkings'],
+                [],
+                true,
+                undefined,
+                undefined,
+                LeagueMocks.leagueInfoOnlyParentDiffSportId
+            );
+
+            expect(warnSpy).toHaveBeenCalled();
+            expect(warnSpy).toHaveBeenCalledWith(NO_MARKETS_FOR_LEAGUE_ID);
+
+            // Restore the original implementation
+            warnSpy.mockRestore();
+        });
+    });
+});

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

@@ -0,0 +1,92 @@
+import { ZERO_ODDS_MESSAGE } from '../../constants/errors';
+import { processMarket } from '../../utils/markets';
+import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
+import { LeagueMocks } from '../mock/MockLeagueMap';
+import {
+    MockOnlyMoneyline,
+    MockZeroOdds,
+    MockOddsChildMarketsGoodOdds,
+    MockOddsChildMarketsOddsCut,
+} from '../mock/MockOpticSoccer';
+import { mockSoccer } from '../mock/MockSoccerRedis';
+
+describe('Odds', () => {
+    it('Should return odds for moneyline', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneyline));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoOnlyParent
+        );
+
+        const hasOdds = market.odds.some(
+            (odd) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(true);
+    });
+
+    it('Should return zero odds for moneyline', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockZeroOdds));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        const hasOdds = market.odds.some(
+            (odd) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(ZERO_ODDS_MESSAGE);
+    });
+
+    it('Should contain child markets for good odds', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOddsChildMarketsGoodOdds));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        const hasChildMarkets = market.childMarkets.length > 0;
+        expect(hasChildMarkets).toBe(true);
+    });
+
+    it('Should return empty array for child child markets after odds cut', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOddsChildMarketsOddsCut));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            true,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        expect(market.childMarkets).toHaveLength(0);
+    });
+});

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

@@ -0,0 +1,47 @@
+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.leagueInfoEnabledSpeadAndTotals);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).toContain('Total Goals');
+    });
+
+    it('Should return all enabled bet types for league, and not contain disabled ones', () => {
+        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 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

@@ -0,0 +1,31 @@
+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 } 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) => 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
+    });
+});

package/src/utils/bookmakers.ts

@@ -54,7 +54,7 @@ export const checkOddsFromBookmakers = (
                 (!isTwoPositionalSport && line.drawOdds === 1)
             );
         }
-        return false;
+        return false; // fix for es-lint
     });
 
     if (hasZeroOrOne) {
@@ -128,7 +128,7 @@ export const checkOddsFromBookmakers = (
                 return true;
             }
         }
-        return false;
+        return false; // fix for es-lint
     });
 
     if (hasLargeImpliedPercentageDifference) {
@@ -140,9 +140,6 @@ export const checkOddsFromBookmakers = (
         };
     }
 
-    let lines: any[] = [];
-    arrayOfBookmakers.forEach((bookmaker) => lines.push(oddsMap.get(bookmaker)));
-
     return {
         homeOdds: homeOdd,
         awayOdds: awayOdd,

package/src/utils/constraints.ts

@@ -98,7 +98,7 @@ export const allowSoccerGame = (homeTeam, awayTeam, currentClock, currentPeriod,
     const currentClockNumber = Number(currentClock);
     if (
         (!Number.isNaN(currentClockNumber) && currentClockNumber >= soccerMinuteLimitForLiveTrading) ||
-        (Number.isNaN(currentClockNumber) && currentPeriod != 'HALF')
+        (Number.isNaN(currentClockNumber) && currentPeriod.toLowerCase() != 'half')
     ) {
         return { allow: false, message: `Blocking game ${homeTeam} - ${awayTeam} due to clock: ${currentClock}min` };
     }

package/src/utils/markets.ts

@@ -54,7 +54,7 @@ export const processMarket = (
             if (_odd != 0) {
                 return {
                     american: oddslib.from('impliedProbability', _odd).to('moneyline'),
-                    decimal: oddslib.from('impliedProbability', _odd).to('decimal'),
+                    decimal: Number(oddslib.from('impliedProbability', _odd).to('decimal').toFixed(10)),
                     normalizedImplied: _odd,
                 };
             } else {
@@ -91,7 +91,7 @@ export const processMarket = (
 
                 return {
                     american: oddslib.from('impliedProbability', _odd).to('moneyline'),
-                    decimal: oddslib.from('impliedProbability', _odd).to('decimal'),
+                    decimal: Number(oddslib.from('impliedProbability', _odd).to('decimal').toFixed(10)),
                     normalizedImplied: _odd,
                 };
             });

package/src/utils/odds.ts

@@ -191,7 +191,7 @@ export const createChildMarkets: (
     defaultSpreadForLiveMarkets,
     leagueMap
 ) => {
-    const [spreadOdds, totalOdds, childMarkets]: any[] = [[], [], []];
+    const [spreadOdds, totalOdds, moneylineOdds, childMarkets]: any[] = [[], [], [], []];
     const leagueInfo = getLeagueInfo(leagueId, leagueMap);
     const commonData = {
         homeTeam: apiResponseWithOdds.homeTeam,
@@ -205,19 +205,20 @@ export const createChildMarkets: (
             liveOddsProviders[0]
         );
 
-        const allValidOdds = allChildOdds.filter((odd) => odd && Math.abs(Number(odd.points) % 1) === 0.5) as any;
-
-        allValidOdds.forEach((odd) => {
+        allChildOdds.forEach((odd) => {
             if (odd.type === 'Total') {
-                totalOdds.push(odd);
+                if (Math.abs(Number(odd.points) % 1) === 0.5) totalOdds.push(odd);
             } else if (odd.type === 'Spread') {
-                spreadOdds.push(odd);
+                if (Math.abs(Number(odd.points) % 1) === 0.5) spreadOdds.push(odd);
+            } else if (odd.type === 'Moneyline') {
+                moneylineOdds.push(odd);
             }
         });
 
         const formattedOdds = [
             ...groupAndFormatSpreadOdds(spreadOdds, commonData),
             ...groupAndFormatTotalOdds(totalOdds, commonData),
+            ...groupAndFormatMoneylineOdds(moneylineOdds, commonData),
         ];
 
         const oddsWithSpreadAdjusted = adjustSpreadOnChildOdds(
@@ -231,7 +232,7 @@ export const createChildMarkets: (
                 leagueId: Number(data.sportId),
                 typeId: Number(data.typeId),
                 type: data.type.toLowerCase(),
-                line: Number(data.line),
+                line: Number(data.line || 0),
                 odds: data.odds,
             };
             const leagueInfoByTypeId = leagueInfo.find((league) => Number(league.typeId) === Number(data.typeId));
@@ -266,7 +267,11 @@ export const createChildMarkets: (
  */
 export const filterOddsByMarketNameBookmaker = (oddsArray, leagueInfos: LeagueInfo[], oddsProvider) => {
     const allChildMarketsTypes = leagueInfos
-        .filter((leagueInfo) => leagueInfo.marketName.toLowerCase() !== MoneylineTypes.MONEYLINE.toLowerCase())
+        .filter(
+            (leagueInfo) =>
+                leagueInfo.marketName.toLowerCase() !== MoneylineTypes.MONEYLINE.toLowerCase() &&
+                leagueInfo.enabled === 'true'
+        )
         .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
     return oddsArray
         .filter(
@@ -294,10 +299,10 @@ export const filterOddsByMarketNameBookmaker = (oddsArray, leagueInfos: LeagueIn
 export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
     // Group odds by their selection points and selection
     const groupedOdds = oddsArray.reduce((acc: any, odd: any) => {
-        const { points, price, selection, typeId, sportId, type } = odd;
+        const { points, marketName, price, selection, typeId, sportId, type } = odd;
         const isHomeTeam = selection === commonData.homeTeam;
 
-        const key = isHomeTeam ? points : -points;
+        const key = `${marketName}_${isHomeTeam ? points : -points}`;
 
         if (!acc[key]) {
             acc[key] = { home: null, away: null, typeId: null, sportId: null };
@@ -317,7 +322,8 @@ export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
     }, {}) as any;
     // Format the grouped odds into the desired output
     const formattedOdds = (Object.entries(groupedOdds as any) as any).reduce((acc, [key, value]) => {
-        const line = parseFloat(key);
+        const [_marketName, lineFloat] = key.split('_');
+        const line = parseFloat(lineFloat);
         if ((value as any).home !== null && (value as any).away !== null) {
             acc.push({
                 line: line as any,
@@ -343,7 +349,7 @@ export const groupAndFormatTotalOdds = (oddsArray, commonData) => {
     // Group odds by their selection points and selection
     const groupedOdds = oddsArray.reduce((acc, odd) => {
         if (odd) {
-            const key = `${odd.selection}_${odd.points}`;
+            const key = `${odd.marketName}_${odd.selection}_${odd.points}`;
             if (!acc[key]) {
                 acc[key] = { over: null, under: null };
             }
@@ -363,7 +369,7 @@ export const groupAndFormatTotalOdds = (oddsArray, commonData) => {
 
     // Format the grouped odds into the desired output
     const formattedOdds = (Object.entries(groupedOdds as any) as any).reduce((acc, [key, value]) => {
-        const [selection, selectionLine] = key.split('_');
+        const [_marketName, selection, selectionLine] = key.split('_');
         const line = parseFloat(selectionLine);
 
         // if we have away team in total odds we know the market is team total and we need to increase typeId by one.
@@ -384,12 +390,61 @@ export const groupAndFormatTotalOdds = (oddsArray, commonData) => {
     return formattedOdds;
 };
 
+/**
+ * Groups spread odds by their lines and formats the result.
+ *
+ * @param {Array} oddsArray - The input array of odds objects.
+ * @param {Object} commonData - The common data object containing homeTeam information.
+ * @returns {Array} The grouped and formatted spread odds.
+ */
+export const groupAndFormatMoneylineOdds = (oddsArray, commonData) => {
+    // Group odds by their selection points and selection
+    const groupedOdds = oddsArray.reduce((acc: any, odd: any) => {
+        const { price, selection, typeId, sportId, type } = odd;
+        const key = typeId;
+
+        if (!acc[key]) {
+            acc[key] = { home: null, away: null, draw: null, typeId: null, sportId: null };
+        }
+
+        if (selection.toLowerCase() === commonData.homeTeam.toLowerCase()) acc[key].home = price;
+        else if (selection.toLowerCase() === commonData.awayTeam.toLowerCase()) acc[key].away = price;
+        else if (selection.toLowerCase() === DRAW.toLowerCase()) acc[key].draw = price;
+
+        acc[key].typeId = typeId;
+        acc[key].type = type;
+        acc[key].sportId = sportId;
+
+        return acc;
+    }, {}) as any;
+    // Format the grouped odds into the desired output
+    const formattedOdds = (Object.entries(groupedOdds as any) as any).reduce((acc, [_key, value]) => {
+        if ((value as any).home !== null && (value as any).away !== null) {
+            acc.push({
+                odds: (value as any).draw
+                    ? [(value as any).home, (value as any).away, (value as any).draw]
+                    : [(value as any).home, (value as any).away],
+                typeId: value.typeId,
+                sportId: value.sportId,
+                type: value.type,
+            });
+        }
+        return acc;
+    }, []);
+
+    return formattedOdds;
+};
+
 export const adjustSpreadOnChildOdds = (iterableGroupedOdds, spreadDataForSport, defaultSpreadForLiveMarkets) => {
     const result: any[] = [];
     iterableGroupedOdds.forEach((data) => {
-        let homeTeamOdds = convertOddsToImpl(data.odds[0]) || ZERO;
-        let awayTeamOdds = convertOddsToImpl(data.odds[1]) || ZERO;
-        let isZeroOddsChild = homeTeamOdds === ZERO || awayTeamOdds === ZERO;
+        const hasDrawOdds = data.odds.length === 3;
+        const homeTeamOdds = convertOddsToImpl(data.odds[0]) || ZERO;
+        const awayTeamOdds = convertOddsToImpl(data.odds[1]) || ZERO;
+        const drawOdds = convertOddsToImpl(data.odds[2]) || ZERO;
+        const odds = hasDrawOdds ? [homeTeamOdds, awayTeamOdds, drawOdds] : [homeTeamOdds, awayTeamOdds];
+
+        const isZeroOddsChild = homeTeamOdds === ZERO || awayTeamOdds === ZERO || (hasDrawOdds && drawOdds === ZERO);
         if (!isZeroOddsChild) {
             const spreadData = getSpreadData(
                 spreadDataForSport,
@@ -397,17 +452,14 @@ export const adjustSpreadOnChildOdds = (iterableGroupedOdds, spreadDataForSport,
                 data.typeId,
                 defaultSpreadForLiveMarkets
             );
+
             let adjustedOdds;
             if (spreadData !== null) {
-                adjustedOdds = adjustSpreadOnOdds(
-                    [homeTeamOdds, awayTeamOdds],
-                    spreadData.minSpread,
-                    spreadData.targetSpread
-                );
+                adjustedOdds = adjustSpreadOnOdds(odds, spreadData.minSpread, spreadData.targetSpread);
             } else {
-                adjustedOdds = adjustSpreadOnOdds([homeTeamOdds, awayTeamOdds], defaultSpreadForLiveMarkets, 0);
+                adjustedOdds = adjustSpreadOnOdds(odds, defaultSpreadForLiveMarkets, 0);
             }
-            [homeTeamOdds, awayTeamOdds] = adjustedOdds;
+
             result.push({
                 ...data,
                 odds: adjustedOdds,