Added functions to help calculate tier fractions

.gitignore

@@ -4,4 +4,5 @@ node_modules
 dist
 coverage
 
-.envrc
+.envrc
+.history

.nvmrc

@@ -0,0 +1 @@
+16.13.0

src/helpers/calculateNumberOfPrizesForIndex.ts

@@ -5,9 +5,8 @@ export function calculateNumberOfPrizesForIndex(
   let bitRangeDecimal = 2 ** bitRangeSize;
   let numberOfPrizesForIndex = bitRangeDecimal ** prizeDistributionIndex;
 
-  while (prizeDistributionIndex > 0) {
+  if (prizeDistributionIndex > 0) {
     numberOfPrizesForIndex -= bitRangeDecimal ** (prizeDistributionIndex - 1);
-    prizeDistributionIndex--;
   }
 
   return numberOfPrizesForIndex;

src/utils/computePrizeFromAbsolutePrizes.ts

@@ -0,0 +1,26 @@
+import { BigNumber, ethers } from "ethers";
+import { calculateNumberOfPrizesForIndex } from "../helpers/calculateNumberOfPrizesForIndex";
+
+/**
+ * Calculates the total prize payout for tiers defined absolutely.
+ *
+ * @remarks
+ * Given tier prizes of [2500, 800], that means there is 1 $2500 prize and 3 $800 prizes. This function
+ * will add them all up.
+ *
+ * @param bitRangeSize The bit range to use.  Determines the number of prizes per tier
+ * @param tierPrizes The prize tiers defined in terms of absolute prize value.
+ */
+export function computePrizeFromAbsolutePrizes(
+  bitRangeSize: number,
+  tierPrizes: BigNumber[]
+): BigNumber {
+  return tierPrizes.reduce(
+    (tot: BigNumber, tierPrize: BigNumber, index: number): BigNumber => {
+      return tot.add(
+        tierPrize.mul(calculateNumberOfPrizesForIndex(bitRangeSize, index))
+      );
+    },
+    ethers.BigNumber.from("0")
+  );
+}

src/utils/computeTiersFromAbsolutePrizes.ts

@@ -0,0 +1,36 @@
+import { BigNumber, ethers } from "ethers";
+import { calculateNumberOfPrizesForIndex } from "../helpers/calculateNumberOfPrizesForIndex";
+import { computePrizeFromAbsolutePrizes } from "./computePrizeFromAbsolutePrizes";
+
+/**
+ * Converts a list of absolute prizes to a fraction array.
+ *
+ * @remarks
+ * Given an array of prizes, this function returns a corresponding array of fixed point 9 fractions for the prize tiers.
+ *
+ * For example, if the tierPrizes array is [2500, 800] then this function will assume:
+ *
+ * There is 1 $2500 prize,
+ * There are 3 $800 prizes
+ *
+ * The total prize is 2500 + 3 * 800 = 4900.
+ *
+ * The result will then be `[2500*1e9/4900, (3*800*1e9)/4900]` or [ 510204081, 489795918 ]
+ *
+ * @param bitRangeSize The bit range that determines the count for each tier of prizes
+ * @param tierPrizes The tiers of prizes represented as absolute amounts.
+ */
+export function computeTiersFromAbsolutePrizes(
+  bitRangeSize: number,
+  tierPrizes: BigNumber[]
+): BigNumber[] {
+  const totalPrizes = computePrizeFromAbsolutePrizes(bitRangeSize, tierPrizes);
+
+  return tierPrizes.map(
+    (tierPrize: BigNumber, index: number): BigNumber =>
+      tierPrize
+        .mul(calculateNumberOfPrizesForIndex(bitRangeSize, index))
+        .mul(ethers.utils.parseUnits("1", 9))
+        .div(totalPrizes)
+  );
+}

src/utils/index.ts

@@ -5,3 +5,5 @@ export * from "./isDrawStructSet";
 export * from "./isPrizeDistributionStructSet";
 export * from "./sanityCheckPrizeDistribution";
 export * from "./sumBigNumbers";
+export * from "./computePrizeFromAbsolutePrizes";
+export * from "./computeTiersFromAbsolutePrizes";