shufflecom-calculations 3.3.9 → 3.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "3.3.9",
+  "version": "3.3.11",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "55c15194f5b26382e3793140c4a843196c3d82cf"
+  "gitHead": "ef4532ce504fc76df3fda095044475231b91cf19"
 }

package/src/regex/index.ts

@@ -17,5 +17,9 @@ export const TIMEZONE_OFFSET_REGEX = /^(?:Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])
 export const TXN_URL_REGEX = /^https:\/\/.*\{txId\}.*$/;
 
 export const ADDRESS_URL_REGEX = /^https:\/\/.*\{address\}.*$/;
-export const VALID_NAME_REGEX = /^[^0-9!@#$%^&*`~()+=[{\]};:"\\|<>\/?\u3164]*$/;
+export const VALID_NAME_REGEX = /^[^0-9!@#$%^&*`~()+=[{\]};:"\\|<>\/?]*$/;
+// Rejects invisible/blank Unicode chars commonly used to spoof empty or hidden names:
+// U+2800 Braille Blank, U+FFA0 Halfwidth Hangul Filler, U+115F Hangul Choseong Filler,
+// U+1160 Hangul Jungseong Filler, U+3164 Hangul Filler
+export const NO_INVISIBLE_CHAR_REGEX = /^[^\u2800\uFFA0\u115F\u1160\u3164]*$/;
 export const US_PHONE_NUMBER_REGEX = /^\+1\d{10}$/;

package/src/regex/regex.spec.ts

@@ -7,6 +7,7 @@ import {
   ADDRESS_URL_REGEX,
   VALID_NAME_REGEX,
   US_PHONE_NUMBER_REGEX,
+  NO_INVISIBLE_CHAR_REGEX,
 } from '.';
 
 describe('regex', () => {
@@ -21,10 +22,9 @@ describe('regex', () => {
     });
 
     it('should allow passwords between 8-24 characters', () => {
-      expect(PWD_REGEX.test('12345678')).toBe(true);      
-      expect(PWD_REGEX.test('abcdefgh')).toBe(true);   
-      expect(PWD_REGEX.test('Password123!')).toBe(true);  
-
+      expect(PWD_REGEX.test('12345678')).toBe(true);
+      expect(PWD_REGEX.test('abcdefgh')).toBe(true);
+      expect(PWD_REGEX.test('Password123!')).toBe(true);
     });
   });
 
@@ -139,9 +139,44 @@ describe('regex', () => {
     it('should allow for empty string', () => {
       expect(VALID_NAME_REGEX.test('')).toBe(true);
     });
+  });
+
+  describe('NO_INVISIBLE_CHAR_REGEX', () => {
+    const BRAILLE_BLANK = String.fromCodePoint(0x2800);
+    const HALFWIDTH_HANGUL_FILLER = String.fromCodePoint(0xffa0);
+    const HANGUL_CHOSEONG_FILLER = String.fromCodePoint(0x115f);
+    const HANGUL_JUNGSEONG_FILLER = String.fromCodePoint(0x1160);
+    const HANGUL_FILLER = String.fromCodePoint(0x3164);
+
+    it('should not allow for U+2800 (Braille Blank) unicode character', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(BRAILLE_BLANK)).toBe(false);
+    });
+
+    it('should not allow for U+FFA0 (Halfwidth Hangul Filler) unicode character', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(HALFWIDTH_HANGUL_FILLER)).toBe(false);
+    });
+
+    it('should not allow for U+115F (Hangul Choseong Filler) unicode character', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(HANGUL_CHOSEONG_FILLER)).toBe(false);
+    });
+
+    it('should not allow for U+1160 (Hangul Jungseong Filler) unicode character', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(HANGUL_JUNGSEONG_FILLER)).toBe(false);
+    });
+
+    it('should not allow for U+3164 (Hangul Filler) unicode character', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(HANGUL_FILLER)).toBe(false);
+    });
+
+    it('should not allow strings with multiple invisible chars', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test(`${BRAILLE_BLANK}${HANGUL_FILLER}${HALFWIDTH_HANGUL_FILLER}`)).toBe(false);
+    });
 
-    it('should not allow for U+3164(Hangul Filler) unicode character', () => {
-      expect(VALID_NAME_REGEX.test('ㅤ')).toBe(false); // there is an invisible unicode character in here
+    it('should allow clean strings without invisible chars', () => {
+      expect(NO_INVISIBLE_CHAR_REGEX.test('superman')).toBe(true);
+      expect(NO_INVISIBLE_CHAR_REGEX.test('SuPERman 123!')).toBe(true);
+      expect(NO_INVISIBLE_CHAR_REGEX.test('我喜欢bingchiling')).toBe(true);
+      expect(NO_INVISIBLE_CHAR_REGEX.test("m_r's don-nut.")).toBe(true);
     });
   });
 

package/src/sports/calculate-sports-payout-odds.ts

@@ -1,6 +1,14 @@
 import BigNumber from 'bignumber.js';
 import { limitTotalOddsDecimalPlaces, oddsFractionToDecimal } from './odds';
-import { OutcomeResult, SportsBetSelectionInterface, SportsBetSelectionStatus, SportsMarketSelectionInterface } from './sports.types';
+import {
+  OutcomeResult,
+  SportsBetLegInterface,
+  SportsBetLegType,
+  SportsBetSelectionInterface,
+  SportsBetSelectionStatus,
+  SportsBetType,
+  SportsMarketSelectionInterface,
+} from './sports.types';
 import { SportsSystemBetType, SportsSystemBetTypeCombinations, SportsSystemBetTypeSelectionCountsToBetCounts } from './system-bet.types';
 
 export const MARGIN_MIN_BPS = 100; // hard limit min 1% for cashout
@@ -73,6 +81,9 @@ export function getSystemBetSubBetSelections(
   return subBetSelectionsAndIndex.map(({ subBetSelection }) => subBetSelection);
 }
 
+// Selection-shaped façade over `calculateSportsPayoutOddsFromLegs`. Builds legs from the input
+// selections, maps subBetSelections to subBetLegs, and delegates. Callers that already have legs
+// should prefer `calculateSportsPayoutOddsFromLegs` directly to skip the bridging cost.
 export function calculateSportsPayoutOdds(
   selections: SportsBetSelectionInterface[],
   marketSelections: SportsMarketSelectionInterface[],
@@ -82,119 +93,30 @@ export function calculateSportsPayoutOdds(
     isEstimation: boolean; // treats PENDING leg as WON
   },
 ): BigNumber {
-  const sportsCustomBetTotalOddsDecimal = opt?.sportsCustomBetTotalOddsDecimal;
-  const subBetSelections = opt?.subBetSelections;
-  if (sportsCustomBetTotalOddsDecimal) {
-    if (selections.some(({ status }) => CUSTOM_BET_VOIDED_STATUSES.includes(status))) {
-      return new BigNumber(1);
-    } else if (selections.some(({ status }) => status === SportsBetSelectionStatus.LOST)) {
-      return new BigNumber(0);
-    } else {
-      return limitTotalOddsDecimalPlaces(sportsCustomBetTotalOddsDecimal);
-    }
-  }
-
-  const marketSelectionMap = marketSelections.reduce(
-    (map, selection) => {
-      map[selection.id] = selection;
-      return map;
-    },
-    {} as Record<string, SportsMarketSelectionInterface>,
-  );
+  const sportsBetType = opt.sportsCustomBetTotalOddsDecimal !== null ? SportsBetType.CUSTOM_BET : SportsBetType.REGULAR;
+  const legs = deriveLegsFromSelections(sportsBetType, selections, opt.sportsCustomBetTotalOddsDecimal ?? new BigNumber(1));
+  const subBetLegs = opt.subBetSelections ? mapSubBetSelectionsToLegs(opt.subBetSelections, legs) : null;
+  return calculateSportsPayoutOddsFromLegs(legs, marketSelections, { subBetLegs, isEstimation: opt.isEstimation });
+}
 
-  if (subBetSelections) {
-    let totalOddsDecimal = new BigNumber(0);
-    for (const subBetSelection of subBetSelections) {
-      const subBetMarketSelections = subBetSelection.map(selection => marketSelectionMap[selection.marketSelectionId]);
-      if (subBetMarketSelections.some(marketSelection => !marketSelection)) {
-        throw new Error('Sub bet market selections not found');
-      }
-      const subBetOdds = calculateSportsPayoutOdds(subBetSelection, subBetMarketSelections as SportsMarketSelectionInterface[], {
-        sportsCustomBetTotalOddsDecimal: null,
-        subBetSelections: null,
-        isEstimation: opt?.isEstimation,
-      });
-      totalOddsDecimal = totalOddsDecimal.plus(subBetOdds);
+function mapSubBetSelectionsToLegs(
+  subBetSelections: SportsBetSelectionInterface[][],
+  legs: SportsBetLegInterface[],
+): SportsBetLegInterface[][] {
+  const legByMarketSelectionId = new Map<string, SportsBetLegInterface>();
+  for (const leg of legs) {
+    for (const selection of leg.selections) {
+      legByMarketSelectionId.set(selection.marketSelectionId, leg);
     }
-
-    return limitTotalOddsDecimalPlaces(totalOddsDecimal.dividedBy(subBetSelections.length));
   }
-
-  return limitTotalOddsDecimalPlaces(
-    selections.reduce((totalOddsDecimal, selection): BigNumber => {
-      // https://geniussports.atlassian.net/wiki/spaces/BID/pages/1239941172/Back-End+Integrations#Back-EndIntegrations-Whatareselectionresultingvalues%3F
-      const selectionOddsDecimal = oddsFractionToDecimal(selection.oddsNumerator, selection.oddsDenominator);
-      const marketSelection = marketSelectionMap[selection.marketSelectionId];
-
-      if (!marketSelection) {
-        throw new Error('Market selection not found');
-      }
-
-      if (selection.status === SportsBetSelectionStatus.LOST) {
-        return BigNumber(0);
-      }
-
-      if (selection.status === SportsBetSelectionStatus.WON) {
-        return totalOddsDecimal.multipliedBy(selectionOddsDecimal);
-      }
-
-      if (selection.status === SportsBetSelectionStatus.PARTIAL) {
-        if (marketSelection.resultAdditionalData) {
-          if ('percentageWin' in marketSelection.resultAdditionalData && 'percentagePush' in marketSelection.resultAdditionalData) {
-            return totalOddsDecimal.multipliedBy(
-              selectionOddsDecimal
-                .multipliedBy(BigNumber(marketSelection.resultAdditionalData?.percentageWin).dividedBy(100))
-                .plus(BigNumber(marketSelection.resultAdditionalData?.percentagePush).dividedBy(100)),
-            );
-          } else if ('voidFactor' in marketSelection.resultAdditionalData && 'outcome' in marketSelection.resultAdditionalData) {
-            if (marketSelection.resultAdditionalData.outcome === OutcomeResult.WINNING) {
-              return totalOddsDecimal.multipliedBy(
-                selectionOddsDecimal
-                  .multipliedBy(BigNumber(marketSelection.resultAdditionalData?.voidFactor))
-                  .plus(BigNumber(marketSelection.resultAdditionalData?.voidFactor)),
-              );
-            }
-
-            return totalOddsDecimal.multipliedBy(marketSelection.resultAdditionalData.voidFactor || 0);
-          } else if ('deadHeatFactor' in marketSelection.resultAdditionalData) {
-            return totalOddsDecimal.multipliedBy(selectionOddsDecimal.multipliedBy(marketSelection.resultAdditionalData.deadHeatFactor || 0));
-          }
-        }
-
-        return totalOddsDecimal;
+  return subBetSelections.map(subBet =>
+    subBet.map(selection => {
+      const leg = legByMarketSelectionId.get(selection.marketSelectionId);
+      if (!leg) {
+        throw new Error('Sub bet leg not found');
       }
-
-      if (selection.status === SportsBetSelectionStatus.PLACED) {
-        if (marketSelection.resultAdditionalData && 'countInPlace' in marketSelection.resultAdditionalData) {
-          return totalOddsDecimal.multipliedBy(selectionOddsDecimal.dividedBy(marketSelection.resultAdditionalData.countInPlace));
-        }
-
-        return totalOddsDecimal;
-      }
-
-      if (selection.status === SportsBetSelectionStatus.PUSHED) {
-        return totalOddsDecimal;
-      }
-
-      if (selection.status === SportsBetSelectionStatus.VOIDED || selection.status == SportsBetSelectionStatus.PROVIDER_VOIDED) {
-        return totalOddsDecimal;
-      }
-
-      if (selection.status === SportsBetSelectionStatus.CASHED_OUT) {
-        return calculateSelectionCashoutOdds(totalOddsDecimal, selectionOddsDecimal, marketSelection);
-      }
-
-      if (selection.status === SportsBetSelectionStatus.PENDING) {
-        if (opt?.isEstimation) {
-          return totalOddsDecimal.multipliedBy(selectionOddsDecimal);
-        }
-        return calculateSelectionCashoutOdds(totalOddsDecimal, selectionOddsDecimal, marketSelection);
-      }
-
-      selection.status satisfies never;
-
-      return totalOddsDecimal;
-    }, BigNumber(1)),
+      return leg;
+    }),
   );
 }
 
@@ -273,3 +195,153 @@ function calculateSelectionCashoutOdds(
     .multipliedBy(selectionOddsDecimal)
     .dividedBy(oddsFractionToDecimal(marketSelection.oddsNumerator, marketSelection.oddsDenominator));
 }
+
+// Structural mapping from (bet type, selections) → legs. The placement writer and the backfill
+// service both consume this so that the leg-shape rule for each bet type lives in one place.
+export function deriveLegsFromSelections(
+  sportsBetType: SportsBetType,
+  selections: SportsBetSelectionInterface[],
+  customBetTotalOddsDecimal: BigNumber,
+): SportsBetLegInterface[] {
+  if (sportsBetType === SportsBetType.CUSTOM_BET) {
+    return [{ type: SportsBetLegType.CUSTOM, oddsDecimal: customBetTotalOddsDecimal, selections }];
+  }
+  return selections.map(selection => ({
+    type: SportsBetLegType.REGULAR,
+    oddsDecimal: oddsFractionToDecimal(selection.oddsNumerator, selection.oddsDenominator),
+    selections: [selection],
+  }));
+}
+
+export function getSystemBetSubBetLegs<TLeg>(legs: TLeg[], sportsSystemBetType: SportsSystemBetType): TLeg[][] {
+  const systemBetSizes = SportsSystemBetTypeCombinations[sportsSystemBetType];
+  if (!systemBetSizes) {
+    throw new Error('Invalid system bet type');
+  }
+  if (!SportsSystemBetTypeSelectionCountsToBetCounts[legs.length]?.[sportsSystemBetType]) {
+    throw new Error('Invalid selection count');
+  }
+  const combinations = systemBetSizes.flatMap(size => generateSystemBetIndexCombinations(legs.length, size));
+  return combinations.map(combination => combination.map(index => legs[index]));
+}
+
+export function calculateSportsPayoutOddsFromLegs(
+  legs: SportsBetLegInterface[],
+  marketSelections: SportsMarketSelectionInterface[],
+  opt: {
+    subBetLegs: SportsBetLegInterface[][] | null;
+    isEstimation: boolean;
+  },
+): BigNumber {
+  const subBetLegs = opt?.subBetLegs;
+
+  const marketSelectionMap = marketSelections.reduce(
+    (map, selection) => {
+      map[selection.id] = selection;
+      return map;
+    },
+    {} as Record<string, SportsMarketSelectionInterface>,
+  );
+
+  if (subBetLegs) {
+    let totalOddsDecimal = new BigNumber(0);
+    for (const subBetLeg of subBetLegs) {
+      const subBetOdds = calculateSportsPayoutOddsFromLegs(subBetLeg, marketSelections, {
+        subBetLegs: null,
+        isEstimation: opt?.isEstimation,
+      });
+      totalOddsDecimal = totalOddsDecimal.plus(subBetOdds);
+    }
+    return limitTotalOddsDecimalPlaces(totalOddsDecimal.dividedBy(subBetLegs.length));
+  }
+
+  return limitTotalOddsDecimalPlaces(
+    legs.reduce((totalOddsDecimal, leg) => totalOddsDecimal.multipliedBy(getLegPayoutOddsDecimal(leg, marketSelectionMap, opt.isEstimation)), new BigNumber(1)),
+  );
+}
+
+function getLegPayoutOddsDecimal(
+  leg: SportsBetLegInterface,
+  marketSelectionMap: Record<string, SportsMarketSelectionInterface>,
+  isEstimation: boolean,
+): BigNumber {
+  if (leg.type === SportsBetLegType.CUSTOM) {
+    if (leg.selections.some(({ status }) => CUSTOM_BET_VOIDED_STATUSES.includes(status))) {
+      return new BigNumber(1);
+    }
+    if (leg.selections.some(({ status }) => status === SportsBetSelectionStatus.LOST)) {
+      return new BigNumber(0);
+    }
+    return leg.oddsDecimal;
+  }
+
+  // REGULAR leg: exactly one selection. Mirrors the per-selection reducer in calculateSportsPayoutOdds.
+  const [selection] = leg.selections;
+  const selectionOddsDecimal = oddsFractionToDecimal(selection.oddsNumerator, selection.oddsDenominator);
+  const marketSelection = marketSelectionMap[selection.marketSelectionId];
+
+  if (!marketSelection) {
+    throw new Error('Market selection not found');
+  }
+
+  if (selection.status === SportsBetSelectionStatus.LOST) {
+    return BigNumber(0);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.WON) {
+    return selectionOddsDecimal;
+  }
+
+  if (selection.status === SportsBetSelectionStatus.PARTIAL) {
+    if (marketSelection.resultAdditionalData) {
+      if ('percentageWin' in marketSelection.resultAdditionalData && 'percentagePush' in marketSelection.resultAdditionalData) {
+        return selectionOddsDecimal
+          .multipliedBy(BigNumber(marketSelection.resultAdditionalData?.percentageWin).dividedBy(100))
+          .plus(BigNumber(marketSelection.resultAdditionalData?.percentagePush).dividedBy(100));
+      } else if ('voidFactor' in marketSelection.resultAdditionalData && 'outcome' in marketSelection.resultAdditionalData) {
+        if (marketSelection.resultAdditionalData.outcome === OutcomeResult.WINNING) {
+          return selectionOddsDecimal
+            .multipliedBy(BigNumber(marketSelection.resultAdditionalData?.voidFactor))
+            .plus(BigNumber(marketSelection.resultAdditionalData?.voidFactor));
+        }
+
+        return new BigNumber(marketSelection.resultAdditionalData.voidFactor || 0);
+      } else if ('deadHeatFactor' in marketSelection.resultAdditionalData) {
+        return selectionOddsDecimal.multipliedBy(marketSelection.resultAdditionalData.deadHeatFactor || 0);
+      }
+    }
+
+    return new BigNumber(1);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.PLACED) {
+    if (marketSelection.resultAdditionalData && 'countInPlace' in marketSelection.resultAdditionalData) {
+      return selectionOddsDecimal.dividedBy(marketSelection.resultAdditionalData.countInPlace);
+    }
+
+    return new BigNumber(1);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.PUSHED) {
+    return new BigNumber(1);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.VOIDED || selection.status === SportsBetSelectionStatus.PROVIDER_VOIDED) {
+    return new BigNumber(1);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.CASHED_OUT) {
+    return calculateSelectionCashoutOdds(new BigNumber(1), selectionOddsDecimal, marketSelection);
+  }
+
+  if (selection.status === SportsBetSelectionStatus.PENDING) {
+    if (isEstimation) {
+      return selectionOddsDecimal;
+    }
+    return calculateSelectionCashoutOdds(new BigNumber(1), selectionOddsDecimal, marketSelection);
+  }
+
+  selection.status satisfies never;
+
+  return new BigNumber(1);
+}

package/src/sports/sports-bet.types.ts

@@ -0,0 +1,168 @@
+import { VipLevel } from '../types/vip-level.type';
+import { Currency } from '../utils/currency';
+import {
+  MatchStatusParts,
+  Sports,
+  SportsBetLegType,
+  SportsBetSelectionStatus,
+  SportsBetStatus,
+  SportsBetType,
+  SportsFixtureBannerType,
+  SportsFixtureStatus,
+  SportsMarketProductId,
+  SportsMarketProvider,
+  SportsMarketSelectionResultStatus,
+  SportsMarketSelectionStatus,
+  SportsMarketStatus,
+  SportsMatchPhaseHomeAway,
+  SportsMatchPhaseSummary,
+  SportsMatchStatistics,
+} from './sports.types';
+import { SportsSystemBetType } from './system-bet.types';
+
+export interface SportsBetSelectionCategoryV3 {
+  id: string;
+  slug: string;
+}
+
+export interface SportsBetSelectionCompetitionV3 {
+  id: string;
+  slug: string;
+  name: string;
+}
+
+export interface SportsBetSelectionFixtureV3 {
+  provider: SportsMarketProvider;
+  id: string;
+  slug: string;
+  name: string;
+  startTime: string;
+  inPlayAllowed: boolean;
+  status: SportsFixtureStatus;
+  bannerType: SportsFixtureBannerType | null;
+  shortName: string;
+}
+
+export interface SportsBetSelectionCompetitorV3 {
+  isHome: boolean;
+  countryCode: string | null;
+  iconPath: string | null;
+  displayName: string;
+  abbreviation: string;
+}
+
+export interface SportsBetSelectionMarketV3 {
+  provider: SportsMarketProvider;
+  id: string;
+  name: string;
+  isOtc: boolean;
+  inPlay: boolean;
+  expiryTime: string | null;
+  status: SportsMarketStatus;
+  productId: SportsMarketProductId | null;
+  fullName: string;
+  lineValue: string | null;
+}
+
+export interface SportsBetSelectionMarketSelectionV3 {
+  id: string;
+  oddsNumerator: string;
+  oddsDenominator: string;
+  status: SportsMarketSelectionStatus;
+  resultStatus: SportsMarketSelectionResultStatus | null;
+  formattedName: string;
+}
+
+export interface SportsBetSelectionMatchSummaryV3 {
+  matchStatusDisplay: MatchStatusParts[];
+  homeScore: string | null;
+  awayScore: string | null;
+  possession: SportsMatchPhaseHomeAway | null;
+  currentRound: string | null;
+  timeRemaining: number | null;
+  stoppageTime: number | null;
+  stoppageTimeAnnounced: number | null;
+  timeElapsed: number | null;
+  clockRunning: boolean | null;
+  providerMessageTimestamp: string | null;
+  currentPhase: SportsMatchPhaseSummary | null;
+  phases: SportsMatchPhaseSummary[] | null;
+  statistics: SportsMatchStatistics | null;
+}
+
+export interface SportsBetSelectionMatchStateV3 {
+  matchSummary: SportsBetSelectionMatchSummaryV3 | null;
+}
+
+export interface SportsBetSelectionV3 {
+  id: string;
+  oddsNumerator: string;
+  oddsDenominator: string;
+  inPlay: boolean;
+  status: SportsBetSelectionStatus;
+  displayStatus: SportsBetSelectionStatus;
+  updatedAt: string;
+  createdAt: string;
+  sports: Sports;
+  streamExists: boolean;
+  category: SportsBetSelectionCategoryV3;
+  competition: SportsBetSelectionCompetitionV3;
+  fixture: SportsBetSelectionFixtureV3;
+  competitors: SportsBetSelectionCompetitorV3[];
+  marketSelection: SportsBetSelectionMarketSelectionV3;
+  market: SportsBetSelectionMarketV3;
+  matchState: SportsBetSelectionMatchStateV3 | null;
+}
+
+export interface SportsBetLegV3 {
+  id: string;
+  type: SportsBetLegType;
+  oddsDecimal: string;
+  updatedAt: string;
+  createdAt: string;
+  selections: SportsBetSelectionV3[];
+}
+
+export interface SportsBetSettlementV3 {
+  id: string;
+  payoutOddsDecimal: string;
+  payout: string;
+  createdAt: string;
+}
+
+export interface SportsBetCashoutAvailableV3 {
+  canCashout: boolean;
+  reason: string | null;
+}
+
+export interface SportsBetUserV3 {
+  id: string;
+  username: string;
+  vipLevel: VipLevel;
+}
+
+export interface SportsBetPayloadV3 {
+  id: string; // bs58
+  currency: Currency;
+  amount: string;
+  originalAmount: string | null;
+  totalOddsDecimal: string;
+  status: SportsBetStatus;
+  type: SportsBetType;
+  systemBetType: SportsSystemBetType | null;
+  isOtc: boolean;
+  updatedAt: string;
+  createdAt: string;
+  actualOddsDecimal: string;
+  cashoutOddsDecimal: string | null;
+  providerCashoutDisabled: boolean;
+  settlement: SportsBetSettlementV3 | null;
+  cashoutAvailable: SportsBetCashoutAvailableV3;
+  user: SportsBetUserV3 | null;
+  legs: SportsBetLegV3[];
+}
+
+export interface PaginatedSportsBetPayloadV3 {
+  nodes: SportsBetPayloadV3[];
+  nextCursor: string | null;
+}

package/src/sports/sports.types.ts

@@ -46,8 +46,8 @@ export enum SportsFixtureStatus {
 export enum SportsMarketStatus {
   OPEN = 'OPEN',
   CLOSED = 'CLOSED', // gets reverted back to OPEN very often with the radar line market cases
-  RESULTED = 'RESULTED', // aka, finalized, no longer used in any query + index, updated by update-market-status job
   SUSPENDED = 'SUSPENDED',
+  RESULTED = 'RESULTED', // aka, finalized, no longer used in any query + index, updated by update-market-status job
   /**
    * @deprecated
    */
@@ -135,6 +135,17 @@ export interface SportsBetSelectionInterface {
   oddsDenominator: BigNumber;
 }
 
+export enum SportsBetLegType {
+  REGULAR = 'REGULAR',
+  CUSTOM = 'CUSTOM',
+}
+
+export interface SportsBetLegInterface {
+  type: SportsBetLegType;
+  oddsDecimal: BigNumber;
+  selections: SportsBetSelectionInterface[];
+}
+
 export interface SportsFixtureInterface {
   id: string;
   status: SportsFixtureStatus;
@@ -539,6 +550,8 @@ export enum SportsMarketGroup {
   LAST_TO_MARKETS = 'LAST_TO_MARKETS',
   OTHER_MARKETS = 'OTHER_MARKETS', // this doesnt really exist in db, for query purpose only
   SAME_GAME_MULTI_MARKETS = 'SAME_GAME_MULTI_MARKETS',
+  QUICK_COMBOS = 'QUICK_COMBOS', // for managing tab visibility only — no SportsMarketGrouping rows. queries for tab content happen through quickCombos query, not sportsMarketInfo
+
   KILL_MARKETS = 'KILL_MARKETS',
   ROSHAN_MARKETS = 'ROSHAN_MARKETS',
   TURRET_MARKETS = 'TURRET_MARKETS',