shufflecom-calculations 2.2.4 → 2.2.5

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

@@ -1,130 +1,129 @@
 import BigNumber from 'bignumber.js';
-import { limitTotalOddsDecimalPlaces, oddsFractionToDecimal } from "./odds";
-import { SportsBetSelectionInterface, SportsMarketSelectionInterface, SportsBetSelectionStatus, OutcomeResult } from "./sports.types";
-import { SportsSystemBetType, SportsSystemBetTypeCombinations } from "./system-bet.types";
-
+import { limitTotalOddsDecimalPlaces, oddsFractionToDecimal } from './odds';
+import { OutcomeResult, SportsBetSelectionInterface, SportsBetSelectionStatus, SportsMarketSelectionInterface } from './sports.types';
+import { SportsSystemBetType, SportsSystemBetTypeCombinations, SportsSystemBetTypeSelectionCountsToBetCounts } from './system-bet.types';
 
 export const CUSTOM_BET_VOIDED_STATUSES = [
-    SportsBetSelectionStatus.VOIDED,
-    SportsBetSelectionStatus.PROVIDER_VOIDED,
-    SportsBetSelectionStatus.PUSHED,
-  ];
-
-  export function generateSystemBetIndexCombinations(length: number, size: number): number[][] {
-    if (size === 0) return [[]];
-    if (size > length) return [];
-    if (size === length) return [Array.from({ length }, (_, i) => i)];
-  
-    const combinations: number[][] = [];
-  
-    function backtrack(start: number, combo: number[]) {
-      if (combo.length === size) {
-        combinations.push([...combo]);
-        return;
-      }
-  
-      for (let i = start; i < length; i++) {
-        combo.push(i);
-        backtrack(i + 1, combo);
-        combo.pop();
-      }
+  SportsBetSelectionStatus.VOIDED,
+  SportsBetSelectionStatus.PROVIDER_VOIDED,
+  SportsBetSelectionStatus.PUSHED,
+];
+
+export function generateSystemBetIndexCombinations(length: number, size: number): number[][] {
+  if (size === 0) return [[]];
+  if (size > length) return [];
+  if (size === length) return [Array.from({ length }, (_, i) => i)];
+
+  const combinations: number[][] = [];
+
+  function backtrack(start: number, combo: number[]) {
+    if (combo.length === size) {
+      combinations.push([...combo]);
+      return;
+    }
+
+    for (let i = start; i < length; i++) {
+      combo.push(i);
+      backtrack(i + 1, combo);
+      combo.pop();
     }
-  
-    backtrack(0, []);
-    return combinations;
   }
-  
+
+  backtrack(0, []);
+  return combinations;
+}
 
 export function getSystemBetSubBetSelections(
-    selections: SportsBetSelectionInterface[],
-    sportsSystemBetType: SportsSystemBetType,
-  ): SportsBetSelectionInterface[][] {
-    const systemBetSizes = SportsSystemBetTypeCombinations[sportsSystemBetType];
-    if (!systemBetSizes) {
-      throw new Error('Invalid system bet type');
-    }
-    const combinations = systemBetSizes.flatMap(size => generateSystemBetIndexCombinations(selections.length, size));
-    const combinationSelections = combinations.map(combination => combination.map(index => selections[index]));
-  
-    return combinationSelections;
+  selections: SportsBetSelectionInterface[],
+  sportsSystemBetType: SportsSystemBetType,
+): SportsBetSelectionInterface[][] {
+  const systemBetSizes = SportsSystemBetTypeCombinations[sportsSystemBetType];
+  if (!systemBetSizes) {
+    throw new Error('Invalid system bet type');
   }
+  if (!SportsSystemBetTypeSelectionCountsToBetCounts[selections.length][sportsSystemBetType]) {
+    throw new Error('Invalid selection count');
+  }
+  const combinations = systemBetSizes.flatMap(size => generateSystemBetIndexCombinations(selections.length, size));
+  const combinationSelections = combinations.map(combination => combination.map(index => selections[index]));
+
+  return combinationSelections;
+}
 
 export function calculateSportsPayoutOdds(
-    selections: SportsBetSelectionInterface[],
-    marketSelections: SportsMarketSelectionInterface[],
-    opt: { sportsCustomBetTotalOddsDecimal: BigNumber | null; subBetSelections: SportsBetSelectionInterface[][] | null },
-  ): 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);
-      }
+  selections: SportsBetSelectionInterface[],
+  marketSelections: SportsMarketSelectionInterface[],
+  opt: {
+    sportsCustomBetTotalOddsDecimal: BigNumber | null;
+    subBetSelections: SportsBetSelectionInterface[][] | null;
+    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>,
-    );
-  
-    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,
-        });
-        totalOddsDecimal = totalOddsDecimal.plus(subBetOdds);
+  }
+
+  const marketSelectionMap = marketSelections.reduce(
+    (map, selection) => {
+      map[selection.id] = selection;
+      return map;
+    },
+    {} as Record<string, SportsMarketSelectionInterface>,
+  );
+
+  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');
       }
-  
-      return limitTotalOddsDecimalPlaces(totalOddsDecimal);
+      const subBetOdds = calculateSportsPayoutOdds(subBetSelection, subBetMarketSelections as SportsMarketSelectionInterface[], {
+        sportsCustomBetTotalOddsDecimal: null,
+        subBetSelections: null,
+        isEstimation: opt?.isEstimation,
+      });
+      totalOddsDecimal = totalOddsDecimal.plus(subBetOdds);
     }
-  
-    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 &&
-            'percentageWin' in marketSelection.resultAdditionalData &&
-            'percentagePush' in marketSelection.resultAdditionalData
-          ) {
+
+    return limitTotalOddsDecimalPlaces(totalOddsDecimal);
+  }
+
+  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 (
-            marketSelection.resultAdditionalData &&
-            'voidFactor' in marketSelection.resultAdditionalData &&
-            'outcome' in marketSelection.resultAdditionalData
-          ) {
+          } else if ('voidFactor' in marketSelection.resultAdditionalData && 'outcome' in marketSelection.resultAdditionalData) {
             if (marketSelection.resultAdditionalData.outcome === OutcomeResult.WINNING) {
               return totalOddsDecimal.multipliedBy(
                 selectionOddsDecimal
@@ -132,114 +131,122 @@ export function calculateSportsPayoutOdds(
                   .plus(BigNumber(marketSelection.resultAdditionalData?.voidFactor)),
               );
             }
-  
-            return totalOddsDecimal.multipliedBy(marketSelection.resultAdditionalData?.voidFactor || 0);
-          } else if (marketSelection.resultAdditionalData && '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.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.PUSHED) {
-          return totalOddsDecimal;
-        }
-  
-        if (selection.status === SportsBetSelectionStatus.VOIDED || selection.status == SportsBetSelectionStatus.PROVIDER_VOIDED) {
-          return totalOddsDecimal;
-        }
-  
-        if (selection.status === SportsBetSelectionStatus.PENDING || selection.status === SportsBetSelectionStatus.CASHED_OUT) {
-          return calculateSelectionCashoutOdds(totalOddsDecimal, selectionOddsDecimal, marketSelection);
-        }
-  
-        selection.status satisfies never;
-  
+
         return totalOddsDecimal;
-      }, BigNumber(1)),
-    );
-  }
+      }
 
-  function calculateSelectionCashoutOdds(
-    totalOddsDecimal: BigNumber,
-    selectionOddsDecimal: BigNumber,
-    marketSelection: SportsMarketSelectionInterface,
-  ) {
-    if (marketSelection?.additionalProbability) {
-      let cashoutOdds = BigNumber(0);
-  
-      if (marketSelection.additionalProbability?.winProbability) {
-        if (marketSelection.additionalProbability.winProbability > 1) {
-          throw new Error('Win Probability is greater than 1');
+      if (selection.status === SportsBetSelectionStatus.PLACED) {
+        if (marketSelection.resultAdditionalData && 'countInPlace' in marketSelection.resultAdditionalData) {
+          return totalOddsDecimal.multipliedBy(selectionOddsDecimal.dividedBy(marketSelection.resultAdditionalData.countInPlace));
         }
-  
-        // payoutIfTicketWins = ticketStake * ticketOdds
-        // probability(ticket wins) * payoutIfTicketWins
-        cashoutOdds = cashoutOdds.plus(
-          totalOddsDecimal.multipliedBy(selectionOddsDecimal).multipliedBy(marketSelection.additionalProbability.winProbability),
-        );
+
+        return totalOddsDecimal;
       }
-  
-      if (marketSelection.additionalProbability?.loseProbability) {
-        if (marketSelection.additionalProbability.loseProbability > 1) {
-          throw new Error('Lose Probability is greater than 1');
-        }
-  
-        // payoutIfTicketLoses = 0
-        // probability(ticket loses) * payoutIfTicketLoses
-        cashoutOdds = cashoutOdds.plus(BigNumber(0).multipliedBy(marketSelection.additionalProbability.loseProbability));
+
+      if (selection.status === SportsBetSelectionStatus.PUSHED) {
+        return totalOddsDecimal;
       }
-  
-      if (marketSelection.additionalProbability?.halfWinProbability) {
-        if (marketSelection.additionalProbability.halfWinProbability > 1) {
-          throw new Error('Half Win Probability is greater than 1');
-        }
-  
-        // payoutIfTicketWinsHalf = ticketStake * (((ticketOdds - 1) / 2) + 1)
-        // probability(ticket wins half) * payoutIfTicketWinsHalf
-        cashoutOdds = cashoutOdds.plus(
-          totalOddsDecimal
-            .multipliedBy(selectionOddsDecimal.minus(1).dividedBy(2).plus(1))
-            .multipliedBy(marketSelection.additionalProbability.halfWinProbability),
-        );
+
+      if (selection.status === SportsBetSelectionStatus.VOIDED || selection.status == SportsBetSelectionStatus.PROVIDER_VOIDED) {
+        return totalOddsDecimal;
       }
-  
-      if (marketSelection.additionalProbability?.halfLoseProbability) {
-        if (marketSelection.additionalProbability.halfLoseProbability > 1) {
-          throw new Error('Half Lose Probability is greater than 1');
+
+      if (selection.status === SportsBetSelectionStatus.CASHED_OUT) {
+        return calculateSelectionCashoutOdds(totalOddsDecimal, selectionOddsDecimal, marketSelection);
+      }
+
+      if (selection.status === SportsBetSelectionStatus.PENDING) {
+        if (opt?.isEstimation) {
+          return totalOddsDecimal.multipliedBy(selectionOddsDecimal);
         }
-  
-        // payoutIfTicketLosesHalf = ticketStake / 2
-        // probability(ticket loses half) * payoutIfTicketLosesHalf
-        cashoutOdds = cashoutOdds.plus(totalOddsDecimal.dividedBy(2).multipliedBy(marketSelection.additionalProbability.halfLoseProbability));
+        return calculateSelectionCashoutOdds(totalOddsDecimal, selectionOddsDecimal, marketSelection);
+      }
+
+      selection.status satisfies never;
+
+      return totalOddsDecimal;
+    }, BigNumber(1)),
+  );
+}
+
+function calculateSelectionCashoutOdds(
+  totalOddsDecimal: BigNumber,
+  selectionOddsDecimal: BigNumber,
+  marketSelection: SportsMarketSelectionInterface,
+) {
+  if (marketSelection?.additionalProbability) {
+    let cashoutOdds = BigNumber(0);
+
+    if (marketSelection.additionalProbability?.winProbability) {
+      if (marketSelection.additionalProbability.winProbability > 1) {
+        throw new Error('Win Probability is greater than 1');
       }
-  
-      if (marketSelection.additionalProbability?.refundProbability) {
-        // payoutIfTicketVoids = ticketStake
-        // probability(ticket voids) * payoutIfTicketVoids
-        cashoutOdds = cashoutOdds.plus(totalOddsDecimal.multipliedBy(marketSelection.additionalProbability.refundProbability));
+
+      // payoutIfTicketWins = ticketStake * ticketOdds
+      // probability(ticket wins) * payoutIfTicketWins
+      cashoutOdds = cashoutOdds.plus(
+        totalOddsDecimal.multipliedBy(selectionOddsDecimal).multipliedBy(marketSelection.additionalProbability.winProbability),
+      );
+    }
+
+    if (marketSelection.additionalProbability?.loseProbability) {
+      if (marketSelection.additionalProbability.loseProbability > 1) {
+        throw new Error('Lose Probability is greater than 1');
+      }
+
+      // payoutIfTicketLoses = 0
+      // probability(ticket loses) * payoutIfTicketLoses
+      cashoutOdds = cashoutOdds.plus(BigNumber(0).multipliedBy(marketSelection.additionalProbability.loseProbability));
+    }
+
+    if (marketSelection.additionalProbability?.halfWinProbability) {
+      if (marketSelection.additionalProbability.halfWinProbability > 1) {
+        throw new Error('Half Win Probability is greater than 1');
       }
-  
-      return cashoutOdds;
+
+      // payoutIfTicketWinsHalf = ticketStake * (((ticketOdds - 1) / 2) + 1)
+      // probability(ticket wins half) * payoutIfTicketWinsHalf
+      cashoutOdds = cashoutOdds.plus(
+        totalOddsDecimal
+          .multipliedBy(selectionOddsDecimal.minus(1).dividedBy(2).plus(1))
+          .multipliedBy(marketSelection.additionalProbability.halfWinProbability),
+      );
     }
-  
-    if (marketSelection?.probability) {
-      if (marketSelection.probability.isGreaterThan(1)) {
-        throw new Error('Probability is greater than 1');
+
+    if (marketSelection.additionalProbability?.halfLoseProbability) {
+      if (marketSelection.additionalProbability.halfLoseProbability > 1) {
+        throw new Error('Half Lose Probability is greater than 1');
       }
-  
-      return totalOddsDecimal.multipliedBy(selectionOddsDecimal.multipliedBy(marketSelection.probability));
+
+      // payoutIfTicketLosesHalf = ticketStake / 2
+      // probability(ticket loses half) * payoutIfTicketLosesHalf
+      cashoutOdds = cashoutOdds.plus(totalOddsDecimal.dividedBy(2).multipliedBy(marketSelection.additionalProbability.halfLoseProbability));
     }
-  
-    return totalOddsDecimal
-      .multipliedBy(selectionOddsDecimal)
-      .dividedBy(oddsFractionToDecimal(marketSelection.oddsNumerator, marketSelection.oddsDenominator));
-  }
+
+    if (marketSelection.additionalProbability?.refundProbability) {
+      // payoutIfTicketVoids = ticketStake
+      // probability(ticket voids) * payoutIfTicketVoids
+      cashoutOdds = cashoutOdds.plus(totalOddsDecimal.multipliedBy(marketSelection.additionalProbability.refundProbability));
+    }
+
+    return cashoutOdds;
+  }
+
+  if (marketSelection?.probability) {
+    if (marketSelection.probability.isGreaterThan(1)) {
+      throw new Error('Probability is greater than 1');
+    }
+
+    return totalOddsDecimal.multipliedBy(selectionOddsDecimal.multipliedBy(marketSelection.probability));
+  }
+
+  return totalOddsDecimal
+    .multipliedBy(selectionOddsDecimal)
+    .dividedBy(oddsFractionToDecimal(marketSelection.oddsNumerator, marketSelection.oddsDenominator));
+}