overtime-live-trading-utils 2.0.56 → 2.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "overtime-live-trading-utils",
-    "version": "2.0.56",
+    "version": "2.0.57",
     "description": "",
     "main": "main.js",
     "scripts": {

package/src/constants/sports.ts

@@ -76,350 +76,3 @@ export const LEAGUES_NO_FORMAL_HOME_AWAY = [
 ];
 
 export const UFC_LEAGUE_IDS = [701, 702, 703, 704];
-
-export const LeagueIdMapRundown = {
-    1: 1, // NCAAF
-    2: 2, // NFL
-    3: 3, // MLB
-    4: 4, // NBA
-    5: 5, // NCAAB
-    6: 6, // NHL
-    7: 7, // UFC
-    8: 8, // WNBA
-    10: 10, // MLS
-    11: 11, // EPL
-    12: 12, // France League 1
-    13: 13, // Bundesliga
-    14: 14, // La Liga
-    15: 15, // Seria A
-    16: 16, // Champions League
-    17: 17, // Europa League
-    18: 18, // FIFA WC
-    19: 19, // J1
-    20: 20, // IPL
-    21: 21, // T20
-};
-
-export const LeagueIdMapEnetpulse = {
-    320: 18, // Hockey Norway
-    6: 24, // NHL
-    33: 33, // Hockey World Championship
-    16: 42, // Champions League
-    44: 44, // Copa America
-    45: 45, // Copa Libertadores
-    11: 47, // EPL
-    50: 50, // UEFA EURO
-    12: 53, // France League 1
-    13: 54, // Bundesliga
-    15: 55, // Seria A
-    57: 57, // Netherlands League 1
-    61: 61, // Portugal League 1
-    65: 65, // Summer Olympics Soccer Women
-    66: 66, // Summer Olympics Soccer
-    17: 73, // Europa League
-    76: 76, // World Cup Woman
-    14: 87, // La Liga
-    152: 152, // Tennis WTA
-    153: 153, // Tennis GS
-    156: 156, // Tennis Masters 1000
-    158: 158, // Summer Olympics Tennnis
-    132: 132, // FA Cup
-    134: 134, // Coupe de France
-    138: 138, // Copa del Rey
-    141: 141, // Coppa Italia
-    209: 209, // DFB Pokal
-    230: 230, // LIGA MX
-    268: 268, // Brazil Football League
-    288: 288, // EURO U21
-    296: 296, // FIFA WC U20
-    310: 310, // Hockey Czech
-    319: 319, // Hockey Finland
-    322: 322, // Hockey Germany
-    327: 327, // Hockey Switzerland
-    380: 380, // Summer Olympics Handball Women
-    381: 381, // Summer Olympics Handball
-    399: 399, // EuroLeague
-    406: 406, // Summer Olympics Basketball
-    407: 407, // Summer Olympics Basketball Women
-    409: 409, // FIBA World Cup
-    445: 445, // F1
-    453: 453, // Summer Olympics Beach Voleyball Women
-    454: 454, // Summer Olympics Beach Voleyball
-    497: 497, // Moto GP
-    536: 536, // Saudi Arabia Football League
-    8881: 8881, // Summer Olympics Water Polo
-    8893: 8893, // Summer Olympics Voleyball Women
-    8894: 8894, // Summer Olympics Voleyball
-    8910: 8910, // Summer Olympics Table Tennnis
-    9196: 9196, // Boxing
-    9578: 9578, // Summer Olympics Rugby
-    9588: 9588, // Summer Olympics Rugby Women
-    9698: 9698, // Summer Olympics Hockey Women
-    9699: 9699, // Summer Olympics Hockey
-    9806: 9806, // UEFA League of Nations
-    9821: 9821, // CONCACAF League of Nations
-    9977: 9977, // CsGo
-    9983: 9983, // Dota
-    10071: 10071, // Summer Olympics Basketball 3x3
-    10072: 10072, // Summer Olympics Basketball 3x3 Women
-    10502: 10502, // Summer Olympics Basketball Qualification
-    10138: 10138, // LOL
-    10199: 10199, // World Cup Qualifications CONMBOL
-    10216: 10216, // Europa Conference League
-    10595: 10595, // Non-Title Boxing
-    10611: 10611, // Champions League Qualification
-    10613: 10613, // Europa League Qualification
-    10615: 10615, // Conference League Qualification
-};
-
-export const LeagueIdMapOpticOdds: Record<number, string> = {
-    1: 'NCAAF',
-    2: 'NFL',
-    3: 'MLB',
-    4: 'NBA',
-    5: 'NCAAB',
-    6: 'NHL',
-    7: 'UFC',
-    8: 'WNBA',
-    9: 'PFL',
-    10: 'USA - Major League Soccer',
-    11: 'England - Premier League',
-    12: 'France - Ligue 1',
-    13: 'Germany - Bundesliga',
-    14: 'Spain - La Liga',
-    15: 'Italy - Serie A',
-    16: 'UEFA - Champions League',
-    17: 'UEFA - Europa League',
-    18: 'FIFA - World Cup Qualifiers',
-    19: 'Japan - J1 League',
-    20: 'India - IPL',
-    21: 'England - T20 Blast',
-    33: 'IIHF - World Championship',
-    45: 'CONMEBOL - Copa Libertadores',
-    57: 'Netherlands - Eredivisie',
-    61: 'Portugal - Primeira Liga',
-    132: 'England - FA Cup',
-    134: 'France - Coupe de France',
-    138: 'Spain - Copa del Rey',
-    152: 'WTA',
-    156: 'ATP',
-    157: 'ATP Challenger',
-    141: 'Italy - Coppa Italia',
-    209: 'Germany - DFB Pokal',
-    230: 'Mexico - Liga MX',
-    268: 'Brazil - Serie A',
-    301: 'NPB',
-    302: 'KBO',
-    303: 'College Baseball',
-    304: 'CPBL',
-    310: 'Czech Republic - Extraliga',
-    319: 'Finland - SM Liiga',
-    321: 'Russia - KHL',
-    322: 'Germany - DEL',
-    323: 'Austria - Ice Hockey League',
-    324: 'Sweden - SHL',
-    327: 'Switzerland - National League',
-    328: 'USA - AHL',
-    379: 'North Macedonia - Super Liga',
-    382: 'Croatia - HB Premijer Liga',
-    383: 'EHF - Champions League',
-    384: 'EHF - Champions League Women',
-    385: 'EHF - European League',
-    386: 'France - LNH Division 1',
-    387: 'Germany - HBL',
-    388: 'Hungary - HNB I',
-    389: 'Iceland - Urvalsdeild',
-    390: 'IHF - World Championship',
-    391: 'Norway - HB 1. Divisjon',
-    392: 'Poland - Superliga',
-    393: 'Russia - Super League',
-    394: 'Serbia - Superliga',
-    395: 'Slovakia - HB Extraliga',
-    396: 'Slovenia - 1. Liga',
-    397: 'Spain - ASOBAL',
-    398: 'Sweden - Handbollsligan',
-    399: 'Euroleague',
-    400: 'USA - NBA Summer League',
-    536: 'Saudi Arabia - Saudi League',
-    8909: 'Olympics Table Tennis Women',
-    8910: 'Olympics Table Tennis Men',
-    8911: 'Czech Republic - TT Cup Men',
-    8912: 'Czech Republic - TT Liga Pro Men',
-    8913: 'Poland - TT Elite Series Men',
-    8914: 'WTT Men',
-    9500: 'Australia - NRL',
-    9501: 'England - Super League',
-    9502: 'Oceania - Super Rugby',
-    9503: 'International - Six Nations',
-    9510: 'AFL',
-    9520: 'CFL',
-    9521: 'UFL',
-    9806: 'UEFA - Nations League',
-    9977: 'CS2',
-    9983: 'Dota 2',
-    10138: 'League of Legends',
-    10216: 'UEFA - Europa Conference League',
-    20001: 'UEFA - Super Cup',
-    20002: 'Brazil - Copa do Brasil',
-    20011: 'England - Championship',
-    20101: 'Scotland - Premiership',
-    20102: 'Belgium - Jupiler Pro League',
-    20103: 'Czech Republic - FNL',
-    20104: 'Chile - Primera Division',
-    20105: 'Finland - Veikkausliiga',
-    20106: 'Argentina - Primera Division',
-    20107: 'Russia - Premier League',
-    20108: 'Turkey - Super Lig',
-    20109: 'Serbia - Super Liga',
-    20110: 'Greece - Super League',
-    20111: 'India - Calcutta Premier Division',
-    20112: 'China - Super League',
-    20113: 'Australia - A-League',
-    20114: 'Switzerland - Super League',
-    20115: 'Germany - Bundesliga 2',
-    20116: 'Spain - La Liga 2',
-    20117: 'Italy - Serie B',
-    20118: 'India - Super League',
-    20119: 'France - Ligue 2',
-    20120: 'Austria - Bundesliga',
-    20121: 'Denmark - Superliga',
-    20122: 'Poland - Ekstraklasa',
-    20123: 'Sweden - Allsvenskan',
-    20124: 'Colombia - Primera A',
-    20125: 'England - EFL Cup',
-    20126: 'England - League 1',
-    20127: 'Uruguay - Primera Division',
-    20128: 'AFC - Champions League',
-    20129: 'Italy - Supercoppa',
-    20130: 'France - Super Cup',
-    20131: 'Spain - Supercopa',
-    20132: 'Germany - Super Cup',
-    20133: 'Portugal - League Cup',
-    20134: 'Thailand - Thai League 1',
-    20135: 'Netherlands - KNVB Beker',
-    20136: 'Portugal - Taca de Portugal',
-    20137: 'England - Womens Super League',
-    20138: 'Italy - Serie A Femminile',
-    20139: 'France - Premiere Ligue',
-    20140: 'Germany - Frauen Bundesliga',
-    20141: 'Spain - Liga F',
-    20142: 'Netherlands - Vrouwen Eredivisie',
-    20143: 'Belgium - Womens Super League',
-    20144: 'UEFA - Champions League Women',
-    20145: 'USA - NWSL',
-    20146: 'Australia - A-League Women',
-    20147: 'CONCACAF - Champions Cup',
-    20148: 'UEFA - Nations League Women',
-    20149: 'Canada - Premier League',
-    20150: 'Norway - Eliteserien',
-    20151: 'USA - Open Cup',
-    20152: 'FIFA - Club World Cup',
-    20200: 'Eurocup',
-    20201: 'Spain - Liga ACB',
-    20202: 'Italy - Lega Basket Serie A',
-    20203: 'Germany - BBL',
-    20204: 'France - LNB Pro A',
-    20205: 'China - CBA',
-    20206: 'Australia - NBL',
-    20210: 'BIG3',
-    20211: 'NCAAW',
-    20212: 'FIBA - Americup Qualifiers',
-    20213: 'FIBA - Asia Cup Qualifiers',
-    20214: 'FIBA - Eurobasket Qualifiers',
-    20215: 'FIBA - World Cup Qualifiers',
-    20216: 'FIBA - AfroBasket Qualifiers',
-    20217: 'Greece - A1 League',
-    20218: 'International - Champions League',
-    20219: 'Turkey - BSL',
-    20220: 'FIBA - Eurobasket Women',
-    20221: 'Philippines - Phillipine Cup',
-    20222: 'FIBA - World Cup U19',
-    20223: 'FIBA - Americup Women',
-    20296: 'Overwatch',
-    20297: 'Rocket League',
-    20298: 'Call of Duty',
-    20299: 'Starcraft',
-    20300: 'Valorant',
-    20293: 'Rainbow Six Siege',
-    20294: 'Starcraft 2',
-    20295: 'Mobile Legends Bang Bang',
-    20301: 'ICC - T20 World Cup',
-    20302: 'Australia - Big Bash League',
-    20303: 'USA - Major League Cricket',
-    20304: 'Australia - Big Bash League Women',
-    20305: 'Pakistan - Super League',
-    20320: 'England - Premier League Darts',
-    20321: 'PDC - World Cup of Darts',
-    20400: 'Argentina - Liga Argentina',
-    20401: 'Argentina - Liga Argentina Women',
-    20402: 'Austria - AVL',
-    20403: 'Austria - WVL',
-    20404: 'Belgium - Liga Dames',
-    20405: 'Belgium - Liga Heren',
-    20406: 'Brazil - Superliga',
-    20407: 'Brazil - Superliga Women',
-    20408: 'CEV - Champions League',
-    20409: 'CEV - Champions League Women',
-    20410: 'CEV - Cup',
-    20411: 'CEV - Cup Women',
-    20412: 'China - CVL',
-    20413: 'China - CVL Women',
-    20414: 'Czech Republic - VEL',
-    20415: 'Czech Republic - VEL Women',
-    20416: 'Denmark - Volleyligaen',
-    20417: 'Denmark - Volleyligaen Women',
-    20418: 'Finland - Mestaruusliiga',
-    20419: 'Finland - Mestaruusliiga Women',
-    20420: 'FIVB - Nations League',
-    20421: 'FIVB - Nations League Women',
-    20422: 'France - Ligue A',
-    20423: 'France - Ligue A Women',
-    20424: 'Germany - 1st Bundesliga',
-    20425: 'Germany - 1st Bundesliga Women',
-    20426: 'Iran - Super League',
-    20427: 'Italy - Coppa Italia A1 Women',
-    20428: 'Italy - Coppa Italia Superlega',
-    20429: 'Italy - Serie A1 Women',
-    20430: 'Italy - Superlega',
-    20431: 'Japan - SV League',
-    20432: 'Japan - SV League Women',
-    20433: 'Norway - NVBF',
-    20434: 'Philippines - PVL Women',
-    20435: 'Poland - PlusLiga',
-    20436: 'Russia - Superliga',
-    20437: 'Russia - Superliga Women',
-    20438: 'South Korea - V League',
-    20439: 'South Korea - V League Women',
-    20516: 'CONCACAF - Gold Cup',
-    20535: 'Ecuador - Serie A',
-    20555: 'COSAFA - Cup',
-    20578: 'Iceland - Besta Deild Karla',
-    20603: 'Korea - K1 League',
-    20651: 'Peru - Primera Division',
-    20712: 'UEFA - European Championship U21',
-    20713: 'UEFA - European Championship Women',
-    20870: 'FINA - World Championship',
-    20871: 'FINA - World Championship Women',
-    305: 'USA - MLB All Star',
-    20310: 'USA - National Lacrosse League',
-    20311: 'USA - Premier Lacrosse League',
-    20507: 'Bulgaria - Parva Liga',
-    20520: 'Croatia - 1. HNL',
-    20572: 'Hungary - NB I',
-    20590: 'Ireland - Premier League',
-    20612: 'Latvia - Virsliga',
-    20616: 'Lithuania - A Lyga',
-    20661: 'Romania - Liga I',
-    20682: 'Slovenia - PrvaLiga',
-    20714: 'Slovakia - Superliga',
-    20715: 'China - FA Cup',
-    20529: 'Czech Republic - First League',
-    20637: 'North America - Leagues Cup',
-    20503: 'Brazil - Serie B',
-    20166: 'Australia - Cup',
-    20600: 'Kazakhstan - Premier League',
-    20549: 'Estonia - Premium Liiga',
-    20702: 'USA - USL Championship',
-    20519: 'Costa Rica - Primera Division',
-    20663: 'Russia - Cup',
-};

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

@@ -0,0 +1,296 @@
+import { 
+    mapFromOpticOddsToOvertimeFormat, 
+    formatOpticOddsLeagueName,
+    mapFromOvertimeToOpticOddsFormat,
+    mapFromOpticOddsFormatToBytes32,
+    mapFromBytes32ToOpticOddsFormat,
+    convertFromBytes32
+} from '../../utils/opticOdds';
+import { OPTIC_ODDS_ID_SEPARATOR, OVERTIME_ID_SEPARATOR } from '../../constants/common';
+
+// Mock the overtime-utils module
+jest.mock('overtime-utils', () => ({
+    LeagueMap: {
+        9002: {
+            id: 9002,
+            name: 'Premier League',
+            opticOddsName: 'English Premier League',
+        },
+        9001: {
+            id: 9001,
+            name: 'Bundesliga',
+            opticOddsName: 'German Bundesliga',
+        },
+        9003: {
+            id: 9003,
+            name: 'La Liga',
+            opticOddsName: 'Spanish La Liga',
+        },
+        9005: {
+            id: 9005,
+            name: 'Champions League',
+            opticOddsName: 'UEFA Champions League',
+        },
+        9006: {
+            id: 9006,
+            name: 'NBA',
+            opticOddsName: 'National Basketball Association',
+        }
+    },
+    getLeagueOpticOddsName: jest.fn((leagueId: number) => {
+        const leagueMap: { [key: number]: string } = {
+            9002: 'English Premier League',
+            9001: 'German Bundesliga',
+            9003: 'Spanish La Liga',
+            9005: 'UEFA Champions League',
+            9006: 'National Basketball Association',
+        };
+        return leagueMap[leagueId];
+    }),
+}));
+
+// Mock bytes32 module
+jest.mock('bytes32', () => {
+    return jest.fn((options: { input: string }) => {
+        // Simple mock that converts string to a padded format
+        const paddedString = options.input.padEnd(32, '\0');
+        return paddedString;
+    });
+});
+
+describe('OpticOdds Utils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('formatOpticOddsLeagueName', () => {
+        it('should convert spaces to underscores and make lowercase', () => {
+            expect(formatOpticOddsLeagueName('English Premier League')).toBe('english_premier_league');
+            expect(formatOpticOddsLeagueName('UEFA Champions League')).toBe('uefa_champions_league');
+            expect(formatOpticOddsLeagueName('German Bundesliga')).toBe('german_bundesliga');
+        });
+
+        it('should handle empty string', () => {
+            expect(formatOpticOddsLeagueName('')).toBe('');
+        });
+
+        it('should handle single words', () => {
+            expect(formatOpticOddsLeagueName('NBA')).toBe('nba');
+        });
+    });
+
+    describe('mapFromOpticOddsToOvertimeFormat', () => {
+        describe('when fixture ID does not contain separator', () => {
+            it('should return the fixture ID unchanged', () => {
+                const fixtureId = 'simple-fixture-id-123';
+                const result = mapFromOpticOddsToOvertimeFormat(fixtureId);
+                expect(result).toBe(fixtureId);
+            });
+
+            it('should return numeric fixture ID unchanged', () => {
+                const fixtureId = '12345';
+                const result = mapFromOpticOddsToOvertimeFormat(fixtureId);
+                expect(result).toBe(fixtureId);
+            });
+        });
+
+        describe('when fixture ID contains separator and league is mapped', () => {
+            it('should convert Premier League fixture ID correctly', () => {
+                const leagueName = formatOpticOddsLeagueName('English Premier League');
+                const fixtureId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}12345`;
+                const result = mapFromOpticOddsToOvertimeFormat(fixtureId);
+                expect(result).toBe(`9002${OVERTIME_ID_SEPARATOR}12345`);
+            });
+
+            it('should convert Bundesliga fixture ID correctly', () => {
+                const leagueName = formatOpticOddsLeagueName('German Bundesliga');
+                const fixtureId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}67890`;
+                const result = mapFromOpticOddsToOvertimeFormat(fixtureId);
+                expect(result).toBe(`9001${OVERTIME_ID_SEPARATOR}67890`);
+            });
+
+            it('should convert Champions League fixture ID correctly', () => {
+                const leagueName = formatOpticOddsLeagueName('UEFA Champions League');
+                const fixtureId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}match-001`;
+                const result = mapFromOpticOddsToOvertimeFormat(fixtureId);
+                expect(result).toBe(`9005${OVERTIME_ID_SEPARATOR}match-001`);
+            });
+        });
+
+        describe('when fixture ID contains separator but league is not mapped', () => {
+            it('should throw error for unmapped league name', () => {
+                const unmappedLeague = 'unknown_league';
+                const fixtureId = `${unmappedLeague}${OPTIC_ODDS_ID_SEPARATOR}12345`;
+                
+                expect(() => {
+                    mapFromOpticOddsToOvertimeFormat(fixtureId);
+                }).toThrow('Optic Odds league unknown_league not mapped.');
+            });
+
+            it('should throw error for empty league name', () => {
+                const fixtureId = `${OPTIC_ODDS_ID_SEPARATOR}12345`;
+                
+                expect(() => {
+                    mapFromOpticOddsToOvertimeFormat(fixtureId);
+                }).toThrow('Optic Odds league  not mapped.');
+            });
+        });
+    });
+
+    describe('mapFromOvertimeToOpticOddsFormat', () => {
+        describe('when game ID does not contain separator', () => {
+            it('should return the game ID unchanged', () => {
+                const gameId = 'simple-game-id-123';
+                const result = mapFromOvertimeToOpticOddsFormat(gameId);
+                expect(result).toBe(gameId);
+            });
+
+            it('should return numeric game ID unchanged', () => {
+                const gameId = '12345';
+                const result = mapFromOvertimeToOpticOddsFormat(gameId);
+                expect(result).toBe(gameId);
+            });
+        });
+
+        describe('when game ID contains separator and league is mapped', () => {
+            it('should convert Premier League game ID correctly', () => {
+                const gameId = `9002${OVERTIME_ID_SEPARATOR}12345`;
+                const result = mapFromOvertimeToOpticOddsFormat(gameId);
+                const expectedLeagueName = formatOpticOddsLeagueName('English Premier League');
+                expect(result).toBe(`${expectedLeagueName}${OPTIC_ODDS_ID_SEPARATOR}12345`);
+            });
+
+            it('should convert Bundesliga game ID correctly', () => {
+                const gameId = `9001${OVERTIME_ID_SEPARATOR}67890`;
+                const result = mapFromOvertimeToOpticOddsFormat(gameId);
+                const expectedLeagueName = formatOpticOddsLeagueName('German Bundesliga');
+                expect(result).toBe(`${expectedLeagueName}${OPTIC_ODDS_ID_SEPARATOR}67890`);
+            });
+
+            it('should convert Champions League game ID correctly', () => {
+                const gameId = `9005${OVERTIME_ID_SEPARATOR}match-001`;
+                const result = mapFromOvertimeToOpticOddsFormat(gameId);
+                const expectedLeagueName = formatOpticOddsLeagueName('UEFA Champions League');
+                expect(result).toBe(`${expectedLeagueName}${OPTIC_ODDS_ID_SEPARATOR}match-001`);
+            });
+        });
+
+        describe('when game ID contains separator but league is not mapped', () => {
+            it('should throw error for unmapped league ID', () => {
+                const gameId = `9999${OVERTIME_ID_SEPARATOR}12345`;
+                
+                expect(() => {
+                    mapFromOvertimeToOpticOddsFormat(gameId);
+                }).toThrow('Overtime league ID 9999 not mapped.');
+            });
+
+            it('should throw error for invalid league ID', () => {
+                const gameId = `invalid${OVERTIME_ID_SEPARATOR}12345`;
+                
+                expect(() => {
+                    mapFromOvertimeToOpticOddsFormat(gameId);
+                }).toThrow('Overtime league ID invalid not mapped.');
+            });
+        });
+    });
+
+    describe('convertFromBytes32', () => {
+        it('should remove null characters from bytes32 string', () => {
+            const input = 'test\0\0\0\0';
+            const result = convertFromBytes32(input);
+            expect(result).toBe('test');
+        });
+
+        it('should handle string without null characters', () => {
+            const input = 'teststring';
+            const result = convertFromBytes32(input);
+            expect(result).toBe('teststring');
+        });
+
+        it('should handle empty string', () => {
+            const input = '';
+            const result = convertFromBytes32(input);
+            expect(result).toBe('');
+        });
+    });
+
+    describe('mapFromOpticOddsFormatToBytes32', () => {
+        it('should convert optic odds format to bytes32', () => {
+            const leagueName = formatOpticOddsLeagueName('English Premier League');
+            const fixtureId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}12345`;
+            const result = mapFromOpticOddsFormatToBytes32(fixtureId);
+            
+            // Should first convert to overtime format, then to bytes32
+            const expectedOvertimeFormat = `9002${OVERTIME_ID_SEPARATOR}12345`;
+            const expectedBytes32 = expectedOvertimeFormat.padEnd(32, '\0');
+            expect(result).toBe(expectedBytes32);
+        });
+
+        it('should handle fixture ID without separator', () => {
+            const fixtureId = '12345';
+            const result = mapFromOpticOddsFormatToBytes32(fixtureId);
+            
+            const expectedBytes32 = fixtureId.padEnd(32, '\0');
+            expect(result).toBe(expectedBytes32);
+        });
+    });
+
+    describe('mapFromBytes32ToOpticOddsFormat', () => {
+        it('should convert bytes32 to optic odds format', () => {
+            const overtimeFormat = `9002${OVERTIME_ID_SEPARATOR}12345`;
+            const bytes32Input = overtimeFormat.padEnd(32, '\0');
+            const result = mapFromBytes32ToOpticOddsFormat(bytes32Input);
+            
+            const expectedLeagueName = formatOpticOddsLeagueName('English Premier League');
+            const expectedResult = `${expectedLeagueName}${OPTIC_ODDS_ID_SEPARATOR}12345`;
+            expect(result).toBe(expectedResult);
+        });
+
+        it('should handle bytes32 without separator', () => {
+            const gameId = '12345';
+            const bytes32Input = gameId.padEnd(32, '\0');
+            const result = mapFromBytes32ToOpticOddsFormat(bytes32Input);
+            
+            expect(result).toBe(gameId);
+        });
+    });
+
+    describe('integration tests', () => {
+        it('should convert from optic odds to bytes32 and back', () => {
+            const leagueName = formatOpticOddsLeagueName('English Premier League');
+            const originalFixtureId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}12345`;
+            
+            // Convert to bytes32
+            const bytes32Result = mapFromOpticOddsFormatToBytes32(originalFixtureId);
+            
+            // Convert back to optic odds format
+            const backToOpticOdds = mapFromBytes32ToOpticOddsFormat(bytes32Result);
+            
+            expect(backToOpticOdds).toBe(originalFixtureId);
+        });
+
+        it('should convert between optic odds and overtime formats', () => {
+            const leagueName = formatOpticOddsLeagueName('German Bundesliga');
+            const opticOddsId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}67890`;
+            
+            // Convert to overtime format
+            const overtimeFormat = mapFromOpticOddsToOvertimeFormat(opticOddsId);
+            expect(overtimeFormat).toBe(`9001${OVERTIME_ID_SEPARATOR}67890`);
+            
+            // Convert back to optic odds format
+            const backToOpticOdds = mapFromOvertimeToOpticOddsFormat(overtimeFormat);
+            expect(backToOpticOdds).toBe(opticOddsId);
+        });
+
+        it('should handle round trip conversion with NBA league', () => {
+            const leagueName = formatOpticOddsLeagueName('National Basketball Association');
+            const originalId = `${leagueName}${OPTIC_ODDS_ID_SEPARATOR}game-456`;
+            
+            // Optic Odds -> Overtime -> Optic Odds
+            const overtimeFormat = mapFromOpticOddsToOvertimeFormat(originalId);
+            const backToOpticOdds = mapFromOvertimeToOpticOddsFormat(overtimeFormat);
+            
+            expect(backToOpticOdds).toBe(originalId);
+        });
+    });
+});

package/src/utils/opticOdds.ts

@@ -1,6 +1,6 @@
 import bytes32 from 'bytes32';
+import { getLeagueOpticOddsName, LeagueMap } from 'overtime-utils';
 import { OPTIC_ODDS_ID_SEPARATOR, OVERTIME_ID_SEPARATOR } from '../constants/common';
-import { LeagueIdMapOpticOdds } from '../constants/sports';
 import { Fixture, OddsObject, ScoresObject } from '../types/odds';
 
 export const mapOpticOddsApiFixtures = (fixturesData: any[]): Fixture[] =>
@@ -85,9 +85,9 @@ export const mapFromOpticOddsToOvertimeFormat = (fixtureId: string) => {
         return fixtureId;
     }
     const [leagueName, id] = fixtureId.split(OPTIC_ODDS_ID_SEPARATOR);
-    const overtimeLeagueId = Object.keys(LeagueIdMapOpticOdds).find(
-        (key) => formatOpticOddsLeagueName(LeagueIdMapOpticOdds[Number(key)]) === leagueName
-    );
+    const overtimeLeagueId = Object.values(LeagueMap).find(
+        (league) => formatOpticOddsLeagueName(league.opticOddsName || '') === leagueName
+    )?.id;
     if (!overtimeLeagueId) {
         throw `Optic Odds league ${leagueName} not mapped.`;
     }
@@ -99,7 +99,7 @@ export const mapFromOvertimeToOpticOddsFormat = (gameId: string) => {
         return gameId;
     }
     const [leagueId, id] = gameId.split(OVERTIME_ID_SEPARATOR);
-    const opticOddsLeagueName = LeagueIdMapOpticOdds[Number(leagueId)];
+    const opticOddsLeagueName = getLeagueOpticOddsName(Number(leagueId));
     if (!opticOddsLeagueName) {
         throw `Overtime league ID ${leagueId} not mapped.`;
     }