overtime-live-trading-utils 0.2.10 → 0.3.1

package/src/enums/sports.ts

@@ -16,6 +16,7 @@ export enum Sport {
     GOLF = 'Golf',
     TABLE_TENNIS = 'TableTennis',
     POLITICS = 'Politics',
+    FUTURES = 'Futures',
     EMPTY = '',
 }
 
@@ -128,6 +129,9 @@ export enum League {
     ENGLAND_LEGAUE_1 = 20126,
     URUGUAY_PRIMERA_DIVISION = 20127,
     EUROCUP = 20200,
+    NFL_FUTURES = 30002,
+    NBA_FUTURES = 30004,
+    EPL_FUTURES = 30011,
     GOLF_H2H = 100021,
     GOLF_WINNER = 100121,
     TENNIS_GRAND_SLAM_LIVE_MAPPING_V2_1 = 15312,

package/src/types/sports.ts

@@ -0,0 +1,17 @@
+export type LeagueInfo = {
+    sportId: number;
+    typeId: number;
+    marketName: string;
+    type: string;
+    enabled: string;
+    minOdds: number;
+    maxOdds: number;
+};
+
+export type ChildMarket = {
+    leagueId: number;
+    typeId: number;
+    type: string;
+    line: number;
+    odds: Array<number>;
+};

package/src/utils/markets.ts

@@ -1,7 +1,5 @@
 import * as oddslib from 'oddslib';
-import { TAG_CHILD_SPREAD, TAG_CHILD_TOTALS } from '../constants/common';
-import { filterOddsByMarketNameBookmaker, formatSpreadOdds, getParentOdds, processTotalOdds } from './odds';
-import { getLeagueSpreadType, getLeagueTotalType } from './sports';
+import { createChildMarkets, getParentOdds } from './odds';
 /**
  * Processes a single sports event. This function maps event data to a specific format,
  * filters invalid events, and optionally fetches player properties if the sport supports it.
@@ -25,7 +23,7 @@ export const processMarket = (
     isDrawAvailable,
     defaultSpreadForLiveMarkets,
     maxPercentageDiffBetwenOdds,
-    isTestnet
+    leagueMap
 ) => {
     const sportSpreadData = spreadData.filter((data) => data.sportId === String(market.leagueId));
 
@@ -62,13 +60,13 @@ export const processMarket = (
             });
     }
 
-    const childMarkets = getChildMarkets(
-        market.leagueId,
-        sportSpreadData,
+    const childMarkets = createChildMarkets(
         apiResponseWithOdds,
+        sportSpreadData,
+        market.leagueId,
         liveOddsProviders,
         defaultSpreadForLiveMarkets,
-        isTestnet
+        leagueMap
     );
 
     const packedChildMarkets = childMarkets.map((childMarket: any) => {
@@ -96,144 +94,3 @@ export const processMarket = (
 
     return market;
 };
-
-/**
- * Retrieves the child markets for the given event.
- *
- * @param {Object} market - The market object from the API
- * @param {Array} spreadDataForSport - Spread data for sport.
- * @param {Object} apiResponseWithOdds - API response from the provider
- * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets
- * @param {Boolean} isTestnet - Flag showing should we process for testnet or mainnet
- * @returns {Array} The child markets for the event.
- */
-const getChildMarkets = (
-    leagueId,
-    spreadDataForSport,
-    apiResponseWithOdds,
-    liveOddsProviders,
-    defaultSpreadForLiveMarkets,
-    isTestnet
-) => {
-    let childMarkets = [];
-
-    // Create Spread Child Markets
-    childMarkets = childMarkets.concat(
-        createSpreadChildMarkets(
-            apiResponseWithOdds,
-            leagueId,
-            spreadDataForSport,
-            liveOddsProviders,
-            defaultSpreadForLiveMarkets,
-            isTestnet
-        )
-    );
-
-    // Create Total Child Markets
-    childMarkets = childMarkets.concat(
-        createTotalChildMarkets(
-            apiResponseWithOdds,
-            leagueId,
-            spreadDataForSport,
-            liveOddsProviders,
-            defaultSpreadForLiveMarkets,
-            isTestnet
-        )
-    );
-
-    return childMarkets;
-};
-
-/**
- * Creates spread child markets based on the given parameters.
- *
- * @param {Object} market - The market object from the API
- * @param {Array} spreadDataForSport - Spread data for sport.
- * @param {Object} apiResponseWithOdds - API response from the provider
- * @param {Array} liveOddsProviders - Odds providers for live odds
- * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets
- * @param {Boolean} isTestnet - Flag showing should we process for testnet or mainnet
- * @returns {Array} The spread child markets.
- */
-export const createSpreadChildMarkets = (
-    apiResponseWithOdds,
-    leagueId,
-    spreadDataForSport,
-    liveOddsProviders,
-    defaultSpreadForLiveMarkets,
-    isTestnet
-) => {
-    const childMarkets = [] as any;
-    const spreadType = getLeagueSpreadType(leagueId, isTestnet);
-    const commonData = {
-        homeTeam: apiResponseWithOdds.home_team,
-        awayTeam: apiResponseWithOdds.away_team,
-    };
-    if (spreadType) {
-        // TODO ADD ODDS COMPARISON BETWEEN BOOKMAKERS
-        const allSpreadOdds = filterOddsByMarketNameBookmaker(
-            apiResponseWithOdds.odds,
-            spreadType,
-            liveOddsProviders[0]
-        );
-
-        if (allSpreadOdds.length > 0) {
-            const formattedSpreadOdds = formatSpreadOdds(
-                allSpreadOdds,
-                commonData,
-                leagueId,
-                spreadDataForSport,
-                TAG_CHILD_SPREAD,
-                defaultSpreadForLiveMarkets
-            );
-
-            childMarkets.push(...formattedSpreadOdds);
-        }
-    } else {
-        console.warn(`Spread type for sport ID ${leagueId} not found.`);
-    }
-    return childMarkets;
-};
-
-/**
- * Creates total child markets based on the given parameters.
- *
- * @param {Object} market - The market object from the API
- * @param {Array} spreadDataForSport - Spread data for sport.
- * @param {Object} apiResponseWithOdds - API response from the provider
- * @param {Array} liveOddsProviders - Odds providers for live odds
- * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets
- * @param {Boolean} isTestnet - Flag showing should we process for testnet or mainnet
- * @returns {Array} The total child markets.
- */
-export const createTotalChildMarkets = (
-    apiResponseWithOdds,
-    leagueId,
-    spreadDataForSport,
-    liveOddsProviders,
-    defaultSpreadForLiveMarkets,
-    isTestnet
-) => {
-    const childMarkets = [] as any;
-    const totalType = getLeagueTotalType(leagueId, isTestnet);
-
-    if (totalType) {
-        // TODO ADD ODDS COMPARISON BETWEEN BOOKMAKERS
-        const totalOdds = filterOddsByMarketNameBookmaker(apiResponseWithOdds.odds, totalType, liveOddsProviders[0]);
-
-        if (totalOdds.length > 0) {
-            childMarkets.push(
-                ...processTotalOdds(
-                    totalOdds,
-                    leagueId,
-                    spreadDataForSport,
-                    TAG_CHILD_TOTALS,
-                    defaultSpreadForLiveMarkets
-                )
-            );
-        }
-    } else {
-        console.warn(`Configuration (totals) for sport ID ${leagueId} not found.`);
-    }
-    return childMarkets;
-};

package/src/utils/odds.ts

@@ -1,9 +1,10 @@
 import * as oddslib from 'oddslib';
-import { DRAW, LIVE_TYPE_ID_BASE, MIN_ODDS_FOR_DIFF_CHECKING, ZERO } from '../constants/common';
-import { statusCodes } from '../enums/statuses';
+import { DRAW, MIN_ODDS_FOR_DIFF_CHECKING, MONEYLINE_TYPE_ID, ZERO } from '../constants/common';
 import { checkOddsFromBookmakers } from './bookmakers';
 import { adjustSpreadOnOdds, getSpreadData } from './spread';
 import { MoneylineTypes } from '../enums/sports';
+import { ChildMarket, LeagueInfo } from '../types/sports';
+import { getLeagueInfo } from './sports';
 
 /**
  * Converts a given odds value from one format to another.
@@ -152,7 +153,7 @@ export const getParentOdds = (
         : [oddsObject.homeOdds, oddsObject.awayOdds, oddsObject.drawOdds];
 
     let parentOdds = primaryBookmakerOdds.map((odd) => convertOddsToImpl(odd));
-    const spreadData = getSpreadData(sportSpreadData, sportId, LIVE_TYPE_ID_BASE, defaultSpreadForLiveMarkets);
+    const spreadData = getSpreadData(sportSpreadData, sportId, MONEYLINE_TYPE_ID, defaultSpreadForLiveMarkets);
 
     if (spreadData !== null) {
         parentOdds = adjustSpreadOnOdds(parentOdds, spreadData.minSpread, spreadData.targetSpread);
@@ -163,102 +164,123 @@ export const getParentOdds = (
     return { odds: parentOdds };
 };
 
-// TODO: Expand this method to support multiple marketNames
 /**
- * Filters the odds array to find entries matching the specified market name.
- *
- * @param {Array} oddsArray - The array of odds objects.
- * @param {string} marketName - The market name to filter by.
- * @param {string} oddsProvider - The main odds provider to filter by.
- * @returns {Array} The filtered odds array.
- */
-export const filterOddsByMarketNameBookmaker = (oddsArray, marketName, oddsProvider) => {
-    return oddsArray.filter(
-        (odd) =>
-            odd.market_name.toLowerCase() === marketName.toLowerCase() &&
-            odd.sports_book_name.toLowerCase() == oddsProvider.toLowerCase()
-    );
-};
-
-// TODO: Unify the same code from formatSpreadOdds method and from processTotalOdds method
-/**
- * Formats the spread odds and creates market objects.
+ * Creates  child markets based on the given parameters.
  *
- * @param {Array} spreadOdds - The spread odds array.
- * @param {Object} commonData - The common data object.
- * @param {Object} market - The sport ID from the API.
- * @param {Array} spreadDataForSport - Spread data for the sport.
- * @param {Number} typeId - typeID
- * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets,
- * @returns {Array} The formatted spread markets.
+ * @param {Object} leagueId - leagueId AKA sportId
+ * @param {Array} spreadDataForSport - Spread data for sport.
+ * @param {Object} apiResponseWithOdds - API response from the provider
+ * @param {Array} liveOddsProviders - Odds providers for live odds
+ * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets
+ * @param {Boolean} leagueMap - League Map info
+ * @returns {Array} The child markets.
  */
-export const formatSpreadOdds = (
-    spreadOdds,
-    commonData,
-    leagueId,
+export const createChildMarkets: (
+    apiResponseWithOdds: any,
+    spreadDataForSport: any,
+    leagueId: number,
+    liveOddsProviders: any,
+    defaultSpreadForLiveMarkets: any,
+    leagueMap: any
+) => ChildMarket[] = (
+    apiResponseWithOdds,
     spreadDataForSport,
-    typeId,
-    defaultSpreadForLiveMarkets
+    leagueId,
+    liveOddsProviders,
+    defaultSpreadForLiveMarkets,
+    leagueMap
 ) => {
-    const childMarkets = [] as any;
-    const validSpreadOdds = spreadOdds.filter((odd) => odd && Math.abs(odd.selection_points % 1) === 0.5) as any;
-    const formattedSpreadOdds = groupAndFormatSpreadOdds(validSpreadOdds, commonData);
+    const [spreadOdds, totalOdds, childMarkets]: any[] = [[], [], []];
+    const leagueInfo = getLeagueInfo(leagueId, leagueMap);
+    const commonData = {
+        homeTeam: apiResponseWithOdds.home_team,
+        awayTeam: apiResponseWithOdds.away_team,
+    };
+    if (leagueInfo.length > 0) {
+        // TODO ADD ODDS COMPARISON BETWEEN BOOKMAKERS
+        const allChildOdds = filterOddsByMarketNameBookmaker(
+            apiResponseWithOdds.odds,
+            leagueInfo,
+            liveOddsProviders[0]
+        );
 
-    formattedSpreadOdds.forEach(({ line, odds }) => {
-        let homeTeamOdds = convertOddsToImpl(odds[0]) || ZERO;
-        let awayTeamOdds = convertOddsToImpl(odds[1]) || ZERO;
-        let isZeroOddsChild = homeTeamOdds === ZERO || awayTeamOdds === ZERO;
+        const allValidOdds = allChildOdds.filter((odd) => odd && Math.abs(odd.selection_points % 1) === 0.5) as any;
 
-        if (!isZeroOddsChild) {
-            const spreadData = getSpreadData(spreadDataForSport, leagueId, typeId, defaultSpreadForLiveMarkets);
-            if (spreadData !== null) {
-                let adjustedOdds = adjustSpreadOnOdds(
-                    [homeTeamOdds, awayTeamOdds],
-                    spreadData.minSpread,
-                    spreadData.targetSpread
-                );
-                if (adjustedOdds.some((prob) => prob === ZERO)) {
-                    isZeroOddsChild = true;
-                } else {
-                    [homeTeamOdds, awayTeamOdds] = adjustedOdds;
-                }
-            } else {
-                let adjustedOdds = adjustSpreadOnOdds([homeTeamOdds, awayTeamOdds], defaultSpreadForLiveMarkets, 0);
-                if (adjustedOdds.some((prob) => prob === ZERO)) {
-                    isZeroOddsChild = true;
-                } else {
-                    [homeTeamOdds, awayTeamOdds] = adjustedOdds;
-                }
+        allValidOdds.forEach((odd) => {
+            if (odd.type === 'Total') {
+                totalOdds.push(odd);
+            } else if (odd.type === 'Spread') {
+                spreadOdds.push(odd);
             }
-        }
+        });
 
-        const minOdds = process.env.MIN_ODDS_FOR_CHILD_MARKETS_FOR_LIVE;
-        const maxOdds = process.env.MAX_ODDS_FOR_CHILD_MARKETS_FOR_LIVE;
-
-        if (
-            !(
-                minOdds &&
-                maxOdds &&
-                (homeTeamOdds >= minOdds ||
-                    homeTeamOdds <= maxOdds ||
-                    awayTeamOdds >= minOdds ||
-                    awayTeamOdds <= maxOdds)
-            )
-        ) {
-            childMarkets.push({
-                leagueId,
-                typeId: typeId,
-                type: 'spread',
-                results: [],
-                status: isZeroOddsChild ? statusCodes.PAUSED : statusCodes.OPEN,
-                line: line,
-                odds: [homeTeamOdds, awayTeamOdds],
-            });
-        }
-    });
+        const formattedOdds = [
+            ...groupAndFormatSpreadOdds(spreadOdds, commonData),
+            ...groupAndFormatTotalOdds(totalOdds, commonData),
+        ];
+
+        const oddsWithSpreadAdjusted = adjustSpreadOnChildOdds(
+            formattedOdds,
+            spreadDataForSport,
+            defaultSpreadForLiveMarkets
+        );
+
+        oddsWithSpreadAdjusted.forEach((data) => {
+            const childMarket = {
+                leagueId: Number(data.sportId),
+                typeId: Number(data.typeId),
+                type: data.type.toLowerCase(),
+                line: Number(data.line),
+                odds: data.odds,
+            };
+            const leagueInfoByTypeId = leagueInfo.find((league) => Number(league.typeId) === Number(data.typeId));
+            const minOdds = leagueInfoByTypeId?.minOdds;
+            const maxOdds = leagueInfoByTypeId?.maxOdds;
+            if (
+                !(
+                    minOdds &&
+                    maxOdds &&
+                    (data.odds[0] >= minOdds ||
+                        data.odds[0] <= maxOdds ||
+                        data.odds[1] >= minOdds ||
+                        data.odds[1] <= maxOdds)
+                )
+            ) {
+                childMarkets.push(childMarket);
+            }
+        });
+    } else {
+        console.warn(`No child markets for leagueID: ${Number(leagueId)}`);
+    }
     return childMarkets;
 };
 
+/**
+ * Filters the odds array to find entries matching the specified market name.
+ *
+ * @param {Array} oddsArray - The array of odds objects.
+ * @param {string} leagueInfos - The market names to filter by.
+ * @param {string} oddsProvider - The main odds provider to filter by.
+ * @returns {Array} The filtered odds array.
+ */
+export const filterOddsByMarketNameBookmaker = (oddsArray, leagueInfos: LeagueInfo[], oddsProvider) => {
+    const allChildMarketsTypes = leagueInfos
+        .filter((leagueInfo) => leagueInfo.marketName.toLowerCase() !== MoneylineTypes.MONEYLINE.toLowerCase())
+        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
+    return oddsArray
+        .filter(
+            (odd) =>
+                allChildMarketsTypes.includes(odd.market_name.toLowerCase()) &&
+                odd.sports_book_name.toLowerCase() == oddsProvider.toLowerCase()
+        )
+        .map((odd) => {
+            return {
+                ...odd,
+                ...leagueInfos.find((leagueInfo) => leagueInfo.marketName === odd.market_name), // using .find() for team totals means that we will always assign 10017 as typeID at this point
+            };
+        });
+};
+
 /**
  * Groups spread odds by their lines and formats the result.
  *
@@ -269,13 +291,13 @@ export const formatSpreadOdds = (
 export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
     // Group odds by their selection points and selection
     const groupedOdds = oddsArray.reduce((acc: any, odd: any) => {
-        const { selection_points, price, selection } = odd;
+        const { selection_points, price, selection, typeId, sportId, type } = odd;
         const isHomeTeam = selection === commonData.homeTeam;
 
         const key = isHomeTeam ? selection_points : -selection_points;
 
         if (!acc[key]) {
-            acc[key] = { home: null, away: null };
+            acc[key] = { home: null, away: null, typeId: null, sportId: null };
         }
 
         if (isHomeTeam) {
@@ -284,6 +306,10 @@ export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
             acc[key].away = 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
@@ -293,6 +319,9 @@ export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
             acc.push({
                 line: line as any,
                 odds: [(value as any).home, (value as any).away],
+                typeId: value.typeId,
+                sportId: value.sportId,
+                type: value.type,
             });
         }
         return acc;
@@ -301,89 +330,15 @@ export const groupAndFormatSpreadOdds = (oddsArray, commonData) => {
     return formattedOdds;
 };
 
-/**
- * Processes total odds to create market objects.
- *
- * @param {Array} totalOdds - The total odds array.
- * @param {Object} commonData - The common data object.
- * @param {Object} market - The sport ID from the API.
- * @param {Array} spreadDataForSport - Spread data for the sport.
- * @param {Number} typeId - typeID
- * @param {Number} defaultSpreadForLiveMarkets - Default spread for live markets,
- * @returns {Array} The processed total odds market objects.
- */
-export const processTotalOdds = (totalOdds, leagueId, spreadDataForSport, typeId, defaultSpreadForLiveMarkets) => {
-    const childMarkets = [] as any;
-    const validTotalOdds = totalOdds.filter((odd) => odd && Math.abs(odd.selection_points % 1) === 0.5);
-    const groupedOdds = groupOddsBySelectionAndPoints(validTotalOdds);
-    const iterableGroupedOdds = Object.entries(groupedOdds) as any;
-
-    iterableGroupedOdds.forEach(([key, { over, under }]) => {
-        const [_, selection_points] = key.split('_');
-
-        let overOdds = convertOddsToImpl(over) || ZERO;
-        let underOdds = convertOddsToImpl(under) || ZERO;
-        let isZeroOddsChild = overOdds === ZERO || underOdds === ZERO;
-
-        if (!isZeroOddsChild) {
-            const spreadData = getSpreadData(spreadDataForSport, leagueId, typeId, defaultSpreadForLiveMarkets);
-            if (spreadData !== null) {
-                let adjustedOdds = adjustSpreadOnOdds(
-                    [overOdds, underOdds],
-                    spreadData.minSpread,
-                    spreadData.targetSpread
-                );
-                if (adjustedOdds.some((prob) => prob === ZERO)) {
-                    isZeroOddsChild = true;
-                } else {
-                    [overOdds, underOdds] = adjustedOdds;
-                }
-            } else {
-                // Use min spread by sport if available, otherwise use default min spread
-                let adjustedOdds = adjustSpreadOnOdds([overOdds, underOdds], defaultSpreadForLiveMarkets, 0);
-                if (adjustedOdds.some((prob) => prob === ZERO)) {
-                    isZeroOddsChild = true;
-                } else {
-                    [overOdds, underOdds] = adjustedOdds;
-                }
-            }
-        }
-
-        const minOdds = process.env.MIN_ODDS_FOR_CHILD_MARKETS_FOR_LIVE;
-        const maxOdds = process.env.MAX_ODDS_FOR_CHILD_MARKETS_FOR_LIVE;
-
-        const childMarket = {
-            leagueId,
-            typeId: typeId,
-            type: 'total',
-            results: [],
-            status: isZeroOddsChild ? statusCodes.PAUSED : statusCodes.OPEN,
-            line: parseFloat(selection_points),
-            odds: [overOdds, underOdds],
-        };
-
-        if (
-            !(
-                minOdds &&
-                maxOdds &&
-                (overOdds >= minOdds || overOdds <= maxOdds || underOdds >= minOdds || underOdds <= maxOdds)
-            )
-        ) {
-            childMarkets.push(childMarket);
-        }
-    });
-
-    return childMarkets;
-};
-
 /**
  * Groups odds by selection and points over/under.
  *
  * @param {Array} oddsArray - The array of odds objects.
  * @returns {Object} The grouped odds.
  */
-export const groupOddsBySelectionAndPoints = (oddsArray) => {
-    return oddsArray.reduce((acc, odd) => {
+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.selection_points}`;
             if (!acc[key]) {
@@ -394,8 +349,67 @@ export const groupOddsBySelectionAndPoints = (oddsArray) => {
             } else if (odd.selection_line === 'under') {
                 acc[key].under = odd.price;
             }
+
+            acc[key].typeId = odd.typeId;
+            acc[key].type = odd.type;
+            acc[key].sportId = odd.sportId;
         }
 
         return acc;
     }, {});
+
+    // 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 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.
+        // if this is false typeId is already mapped correctly
+        const isAwayTeam = selection === commonData.awayTeam;
+        if ((value as any).over !== null && (value as any).under !== null) {
+            acc.push({
+                line: line as any,
+                odds: [(value as any).over, (value as any).under],
+                typeId: !isAwayTeam ? value.typeId : Number(value.typeId) + 1,
+                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;
+        if (!isZeroOddsChild) {
+            const spreadData = getSpreadData(
+                spreadDataForSport,
+                data.sportId,
+                data.typeId,
+                defaultSpreadForLiveMarkets
+            );
+            let adjustedOdds;
+            if (spreadData !== null) {
+                adjustedOdds = adjustSpreadOnOdds(
+                    [homeTeamOdds, awayTeamOdds],
+                    spreadData.minSpread,
+                    spreadData.targetSpread
+                );
+            } else {
+                adjustedOdds = adjustSpreadOnOdds([homeTeamOdds, awayTeamOdds], defaultSpreadForLiveMarkets, 0);
+            }
+            [homeTeamOdds, awayTeamOdds] = adjustedOdds;
+            result.push({
+                ...data,
+                odds: adjustedOdds,
+            });
+        }
+    });
+    return result;
 };