shufflecom-calculations 3.3.10 → 3.3.11

package/package.json

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

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

@@ -81,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[],
@@ -90,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');
+  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.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;
-      }
-
-      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;
+    }),
   );
 }
 
@@ -298,3 +212,136 @@ export function deriveLegsFromSelections(
     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;
+}