shufflecom-calculations 1.2.4 → 1.3.0

package/src/games/roulette.spec.ts

@@ -0,0 +1,521 @@
+import { createHmac } from 'crypto';
+import BigNumber from 'bignumber.js';
+import {
+  Roulette,
+  RouletteColor,
+  RouletteColumn,
+  RouletteDozen,
+  RouletteHalf,
+  RouletteParity,
+  STRAIGHT_VALUES,
+  colorPayout,
+  columnPayout,
+  cornerNumbers,
+  cornerPayout,
+  doubleStreetPayout,
+  dozenPayout,
+  halfsPayout,
+  isValidCorner,
+  isValidDoubleStreet,
+  isValidSplit,
+  isValidStreet,
+  parityPayout,
+  splitPayout,
+  straightPayout,
+  straightValue,
+  streetPayout,
+} from './roulette';
+
+// if A is a subset of B and B is a subset of A, then A = B
+function arrayEquals<T>(arr1: T, arr2: T) {
+  expect(arr1).toEqual(expect.arrayContaining(arr2 as any));
+  expect(arr2).toEqual(expect.arrayContaining(arr1 as any));
+}
+
+describe('Roulette', () => {
+  it('getResult should return 0-36 inclusive', () => {
+    const hexStrArr = generateDigestHex({ serverSeed: 'test', clientSeed: 'test', nonce: '0', rounds: 100000 });
+    const results = hexStrArr.map((hexStr) => Roulette.getResult(hexStr));
+    const uniqueResults = [...new Set(results)].sort((a, b) => a - b) as readonly straightValue[];
+    arrayEquals(uniqueResults, STRAIGHT_VALUES);
+  });
+  it('isValidStreet should work', () => {
+    expect(isValidStreet([1, 2, 3])).toEqual(true);
+    expect(isValidStreet([3, 1, 2] as any)).toEqual(true);
+    expect(isValidStreet([1, 2, 4] as any)).toEqual(false);
+  });
+  it('cornerNumbers should return the right numbers', () => {
+    expect(cornerNumbers(0)).toEqual([1, 2, 3]);
+    expect(cornerNumbers(1)).toEqual([0, 2, 3, 4, 5]);
+    expect(cornerNumbers(2)).toEqual([0, 1, 3, 4, 5, 6]);
+    expect(cornerNumbers(3)).toEqual([0, 1, 2, 5, 6]);
+    expect(cornerNumbers(4)).toEqual([1, 2, 5, 7, 8]);
+    expect(cornerNumbers(5)).toEqual([1, 2, 3, 4, 6, 7, 8, 9]);
+    expect(cornerNumbers(6)).toEqual([2, 3, 5, 8, 9]);
+    expect(cornerNumbers(7)).toEqual([4, 5, 8, 10, 11]);
+    expect(cornerNumbers(8)).toEqual([4, 5, 6, 7, 9, 10, 11, 12]);
+    expect(cornerNumbers(9)).toEqual([5, 6, 8, 11, 12]);
+    expect(cornerNumbers(10)).toEqual([7, 8, 11, 13, 14]);
+    expect(cornerNumbers(11)).toEqual([7, 8, 9, 10, 12, 13, 14, 15]);
+    expect(cornerNumbers(12)).toEqual([8, 9, 11, 14, 15]);
+    expect(cornerNumbers(13)).toEqual([10, 11, 14, 16, 17]);
+    expect(cornerNumbers(14)).toEqual([10, 11, 12, 13, 15, 16, 17, 18]);
+    expect(cornerNumbers(15)).toEqual([11, 12, 14, 17, 18]);
+    expect(cornerNumbers(16)).toEqual([13, 14, 17, 19, 20]);
+    expect(cornerNumbers(17)).toEqual([13, 14, 15, 16, 18, 19, 20, 21]);
+    expect(cornerNumbers(18)).toEqual([14, 15, 17, 20, 21]);
+    expect(cornerNumbers(19)).toEqual([16, 17, 20, 22, 23]);
+    expect(cornerNumbers(20)).toEqual([16, 17, 18, 19, 21, 22, 23, 24]);
+    expect(cornerNumbers(21)).toEqual([17, 18, 20, 23, 24]);
+    expect(cornerNumbers(22)).toEqual([19, 20, 23, 25, 26]);
+    expect(cornerNumbers(23)).toEqual([19, 20, 21, 22, 24, 25, 26, 27]);
+    expect(cornerNumbers(24)).toEqual([20, 21, 23, 26, 27]);
+    expect(cornerNumbers(25)).toEqual([22, 23, 26, 28, 29]);
+    expect(cornerNumbers(26)).toEqual([22, 23, 24, 25, 27, 28, 29, 30]);
+    expect(cornerNumbers(27)).toEqual([23, 24, 26, 29, 30]);
+    expect(cornerNumbers(28)).toEqual([25, 26, 29, 31, 32]);
+    expect(cornerNumbers(29)).toEqual([25, 26, 27, 28, 30, 31, 32, 33]);
+    expect(cornerNumbers(30)).toEqual([26, 27, 29, 32, 33]);
+    expect(cornerNumbers(31)).toEqual([28, 29, 32, 34, 35]);
+    expect(cornerNumbers(32)).toEqual([28, 29, 30, 31, 33, 34, 35, 36]);
+    expect(cornerNumbers(33)).toEqual([29, 30, 32, 35, 36]);
+    expect(cornerNumbers(34)).toEqual([31, 32, 35]);
+    expect(cornerNumbers(35)).toEqual([31, 32, 33, 34, 36]);
+    expect(cornerNumbers(36)).toEqual([32, 33, 35]);
+  });
+  it('isValidSplit to work correctly', () => {
+    // same value
+    expect(isValidSplit(4, 4)).toEqual(false);
+    // 0s
+    expect(isValidSplit(0, 1)).toEqual(true);
+    expect(isValidSplit(0, 2)).toEqual(true);
+    expect(isValidSplit(0, 3)).toEqual(true);
+    expect(isValidSplit(0, 4)).toEqual(false);
+    // adjacent to 0
+    expect(isValidSplit(6, 3)).toEqual(true);
+    expect(isValidSplit(2, 3)).toEqual(true);
+    expect(isValidSplit(5, 3)).toEqual(false);
+    // bottom
+    expect(isValidSplit(4, 1)).toEqual(true);
+    expect(isValidSplit(4, 2)).toEqual(false);
+    expect(isValidSplit(4, 3)).toEqual(false);
+    expect(isValidSplit(4, 5)).toEqual(true);
+    expect(isValidSplit(4, 6)).toEqual(false);
+    expect(isValidSplit(4, 7)).toEqual(true);
+    expect(isValidSplit(4, 8)).toEqual(false);
+    // center
+    expect(isValidSplit(1, 5)).toEqual(false);
+    expect(isValidSplit(2, 5)).toEqual(true);
+    expect(isValidSplit(3, 5)).toEqual(false);
+    expect(isValidSplit(4, 5)).toEqual(true);
+    expect(isValidSplit(6, 5)).toEqual(true);
+    expect(isValidSplit(7, 5)).toEqual(false);
+    expect(isValidSplit(8, 5)).toEqual(true);
+    expect(isValidSplit(9, 5)).toEqual(false);
+    // top
+    expect(isValidSplit(6, 1)).toEqual(false);
+    expect(isValidSplit(6, 2)).toEqual(false);
+    expect(isValidSplit(6, 3)).toEqual(true);
+    expect(isValidSplit(6, 4)).toEqual(false);
+    expect(isValidSplit(6, 5)).toEqual(true);
+    expect(isValidSplit(6, 7)).toEqual(false);
+    expect(isValidSplit(6, 8)).toEqual(false);
+    expect(isValidSplit(6, 9)).toEqual(true);
+    // right most side
+    // bottom
+    expect(isValidSplit(35, 34)).toEqual(true);
+    expect(isValidSplit(36, 34)).toEqual(false);
+    expect(isValidSplit(31, 34)).toEqual(true);
+    expect(isValidSplit(32, 34)).toEqual(false);
+    // center
+    expect(isValidSplit(35, 34)).toEqual(true);
+    expect(isValidSplit(35, 32)).toEqual(true);
+    expect(isValidSplit(35, 36)).toEqual(true);
+    expect(isValidSplit(35, 33)).toEqual(false);
+    // top
+    expect(isValidSplit(35, 36)).toEqual(true);
+    expect(isValidSplit(34, 36)).toEqual(false);
+    expect(isValidSplit(33, 36)).toEqual(true);
+    // random
+    expect(isValidSplit(33, 3)).toEqual(false);
+    expect(isValidSplit(13, 23)).toEqual(false);
+  });
+  it('isValidCorner works', () => {
+    // check 0 works
+    expect(isValidCorner(0, 1, 2, 3)).toEqual(true);
+    expect(isValidCorner(3, 0, 2, 1)).toEqual(true);
+    expect(isValidCorner(2, 3, 5, 6)).toEqual(true);
+    expect(isValidCorner(11, 12, 14, 15)).toEqual(true);
+    expect(isValidCorner(11, 10, 13, 14)).toEqual(true);
+    expect(isValidCorner(32, 33, 35, 36)).toEqual(true);
+    expect(isValidCorner(31, 32, 34, 35)).toEqual(true);
+    expect(isValidCorner(2, 3, 5, 7)).toEqual(false);
+    expect(isValidCorner(2, 4, 6, 1)).toEqual(false);
+    expect(isValidCorner(31, 32, 34, 30)).toEqual(false);
+    expect(isValidCorner(0, 1, 2, 4)).toEqual(false);
+    expect(isValidCorner(0, 1, 5, 2)).toEqual(false);
+    expect(isValidCorner(25, 26, 27, 28)).toEqual(false);
+  });
+
+  it('double street', () => {
+    expect(isValidDoubleStreet([0, 1, 2], [1, 2, 3])).toEqual(false);
+    expect(isValidDoubleStreet([0, 1, 2], [0, 2, 3])).toEqual(false);
+    expect(isValidDoubleStreet([1, 2, 3], [6, 5, 4] as any)).toEqual(true);
+    expect(isValidDoubleStreet([7, 8, 9], [6, 5, 4] as any)).toEqual(true);
+    expect(isValidDoubleStreet([7, 8, 9, 10] as any, [6, 5, 4] as any)).toEqual(false);
+    expect(isValidDoubleStreet([31, 32, 33], [34, 35, 36])).toEqual(true);
+    expect(isValidDoubleStreet([28, 29, 30], [34, 35, 36])).toEqual(false);
+  });
+
+  it('validate inputs works', () => {
+    expect(
+      Roulette.validateInputs({
+        colorValues: [],
+        columnValues: [],
+        cornerValues: [],
+        doubleStreetValues: [],
+        dozenValues: [],
+        halfValues: [],
+        parityValues: [],
+        splitValues: [],
+        straightValues: [],
+        streetValues: [],
+      }),
+    ).toEqual(false);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [],
+        halfValues: [],
+        columnValues: [],
+        dozenValues: [],
+        straightValues: [],
+        splitValues: [],
+        streetValues: [],
+        cornerValues: [],
+        doubleStreetValues: [],
+      }),
+    ).toEqual(true);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+
+        straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(true);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+
+        straightValues: [{ amount: BigNumber(1), straightNumber: 37 as any }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(false);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+
+        straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 3 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(false);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+        straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 4] as any }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(false);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+        straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 5, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(false);
+
+    expect(
+      Roulette.validateInputs({
+        parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+        colorValues: [
+          { amount: BigNumber(1), color: RouletteColor.BLACK },
+          { amount: BigNumber(1), color: RouletteColor.RED },
+        ],
+        halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+        columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+        dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+        straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+        splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+        streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+        cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0 }],
+        doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [10, 11, 12], secondStreet: [4, 5, 6] }],
+      }),
+    ).toEqual(false);
+  });
+
+  it('parity Payout', () => {
+    expect(parityPayout({ parity: RouletteParity.EVEN, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(parityPayout({ parity: RouletteParity.ODD, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(parityPayout({ parity: RouletteParity.ODD, amount: BigNumber(1) }, 5).toNumber()).toEqual(2);
+    expect(parityPayout({ parity: RouletteParity.EVEN, amount: BigNumber(1) }, 5).toNumber()).toEqual(0);
+    expect(parityPayout({ parity: RouletteParity.ODD, amount: BigNumber(1) }, 10).toNumber()).toEqual(0);
+    expect(parityPayout({ parity: RouletteParity.EVEN, amount: BigNumber(1) }, 10).toNumber()).toEqual(2);
+  });
+
+  it('color Payout', () => {
+    expect(colorPayout({ color: RouletteColor.RED, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(colorPayout({ color: RouletteColor.BLACK, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(colorPayout({ color: RouletteColor.RED, amount: BigNumber(1) }, 1).toNumber()).toEqual(2);
+    expect(colorPayout({ color: RouletteColor.BLACK, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(colorPayout({ color: RouletteColor.RED, amount: BigNumber(1) }, 2).toNumber()).toEqual(0);
+    expect(colorPayout({ color: RouletteColor.BLACK, amount: BigNumber(1) }, 2).toNumber()).toEqual(2);
+  });
+
+  it('halfs payout', () => {
+    expect(halfsPayout({ half: RouletteHalf.HIGH, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.LOW, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.LOW, amount: BigNumber(1) }, 1).toNumber()).toEqual(2);
+    expect(halfsPayout({ half: RouletteHalf.HIGH, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.LOW, amount: BigNumber(1) }, 18).toNumber()).toEqual(2);
+    expect(halfsPayout({ half: RouletteHalf.HIGH, amount: BigNumber(1) }, 18).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.LOW, amount: BigNumber(1) }, 19).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.HIGH, amount: BigNumber(1) }, 19).toNumber()).toEqual(2);
+    expect(halfsPayout({ half: RouletteHalf.LOW, amount: BigNumber(1) }, 36).toNumber()).toEqual(0);
+    expect(halfsPayout({ half: RouletteHalf.HIGH, amount: BigNumber(1) }, 36).toNumber()).toEqual(2);
+  });
+
+  it('column payout', () => {
+    expect(columnPayout({ column: RouletteColumn.BOTTOM, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(columnPayout({ column: RouletteColumn.MIDDLE, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(columnPayout({ column: RouletteColumn.TOP, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+
+    expect(columnPayout({ column: RouletteColumn.TOP, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(columnPayout({ column: RouletteColumn.MIDDLE, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(columnPayout({ column: RouletteColumn.BOTTOM, amount: BigNumber(1) }, 1).toNumber()).toEqual(3);
+
+    expect(columnPayout({ column: RouletteColumn.TOP, amount: BigNumber(1) }, 2).toNumber()).toEqual(0);
+    expect(columnPayout({ column: RouletteColumn.MIDDLE, amount: BigNumber(1) }, 2).toNumber()).toEqual(3);
+    expect(columnPayout({ column: RouletteColumn.BOTTOM, amount: BigNumber(1) }, 2).toNumber()).toEqual(0);
+  });
+
+  it('dozen payout', () => {
+    expect(dozenPayout({ dozen: RouletteDozen.FIRST, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.SECOND, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.THIRD, amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+
+    expect(dozenPayout({ dozen: RouletteDozen.FIRST, amount: BigNumber(1) }, 1).toNumber()).toEqual(3);
+    expect(dozenPayout({ dozen: RouletteDozen.SECOND, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.THIRD, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+
+    expect(dozenPayout({ dozen: RouletteDozen.FIRST, amount: BigNumber(1) }, 20).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.SECOND, amount: BigNumber(1) }, 20).toNumber()).toEqual(3);
+    expect(dozenPayout({ dozen: RouletteDozen.THIRD, amount: BigNumber(1) }, 20).toNumber()).toEqual(0);
+
+    expect(dozenPayout({ dozen: RouletteDozen.FIRST, amount: BigNumber(1) }, 30).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.SECOND, amount: BigNumber(1) }, 30).toNumber()).toEqual(0);
+    expect(dozenPayout({ dozen: RouletteDozen.THIRD, amount: BigNumber(1) }, 30).toNumber()).toEqual(3);
+  });
+
+  it('straight payout', () => {
+    expect(straightPayout({ straightNumber: 0, amount: BigNumber(1) }, 0).toNumber()).toEqual(36);
+    expect(straightPayout({ straightNumber: 0, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+    expect(straightPayout({ straightNumber: 2, amount: BigNumber(1) }, 2).toNumber()).toEqual(36);
+    expect(straightPayout({ straightNumber: 2, amount: BigNumber(1) }, 3).toNumber()).toEqual(0);
+  });
+
+  it('split payout', () => {
+    expect(splitPayout({ firstNumber: 0, secondNumber: 1, amount: BigNumber(1) }, 0).toNumber()).toEqual(18);
+    expect(splitPayout({ firstNumber: 0, secondNumber: 1, amount: BigNumber(1) }, 1).toNumber()).toEqual(18);
+    expect(splitPayout({ firstNumber: 2, secondNumber: 3, amount: BigNumber(1) }, 3).toNumber()).toEqual(18);
+    expect(splitPayout({ firstNumber: 2, secondNumber: 3, amount: BigNumber(1) }, 1).toNumber()).toEqual(0);
+  });
+
+  it('street payout', () => {
+    expect(streetPayout({ street: [0, 1, 2], amount: BigNumber(1) }, 0).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [0, 2, 3], amount: BigNumber(1) }, 0).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [1, 2, 3], amount: BigNumber(1) }, 0).toNumber()).toEqual(0);
+    expect(streetPayout({ street: [1, 2, 3], amount: BigNumber(1) }, 1).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [1, 2, 3], amount: BigNumber(1) }, 3).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [1, 2, 3], amount: BigNumber(1) }, 2).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [4, 5, 6], amount: BigNumber(1) }, 5).toNumber()).toEqual(12);
+    expect(streetPayout({ street: [1, 2, 3], amount: BigNumber(1) }, 8).toNumber()).toEqual(0);
+  });
+
+  it('corner payout', () => {
+    expect(cornerPayout({ firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0, amount: BigNumber(1) }, 1).toNumber()).toEqual(9);
+    expect(cornerPayout({ firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0, amount: BigNumber(1) }, 2).toNumber()).toEqual(9);
+    expect(cornerPayout({ firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0, amount: BigNumber(1) }, 3).toNumber()).toEqual(9);
+    expect(cornerPayout({ firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0, amount: BigNumber(1) }, 0).toNumber()).toEqual(9);
+    expect(cornerPayout({ firstNumber: 1, secondNumber: 2, thirdNumber: 3, fourthNumber: 0, amount: BigNumber(1) }, 7).toNumber()).toEqual(0);
+  });
+
+  it('double street payout', () => {
+    expect(doubleStreetPayout({ firstStreet: [1, 2, 3], secondStreet: [4, 5, 6], amount: BigNumber(1) }, 1).toNumber()).toEqual(6);
+    expect(doubleStreetPayout({ firstStreet: [1, 2, 3], secondStreet: [4, 5, 6], amount: BigNumber(1) }, 5).toNumber()).toEqual(6);
+    expect(doubleStreetPayout({ firstStreet: [1, 2, 3], secondStreet: [4, 5, 6], amount: BigNumber(1) }, 8).toNumber()).toEqual(0);
+  });
+
+  it('getPayouts', () => {
+    expect(
+      Roulette.getPayout(
+        {
+          parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+          colorValues: [
+            { amount: BigNumber(1), color: RouletteColor.BLACK },
+            { amount: BigNumber(1), color: RouletteColor.RED },
+          ],
+          halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+          columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+          dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+          straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+          splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+          streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+          cornerValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2, thirdNumber: 4, fourthNumber: 5 }],
+          doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+        },
+        0,
+      ).toNumber(),
+    ).toEqual(0);
+
+    expect(
+      Roulette.getPayout(
+        {
+          parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+          colorValues: [
+            { amount: BigNumber(1), color: RouletteColor.BLACK },
+            { amount: BigNumber(1), color: RouletteColor.RED },
+            { amount: BigNumber(2), color: RouletteColor.RED },
+          ],
+          halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+          columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+          dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+          straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+          splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+          streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+          cornerValues: [{ amount: BigNumber(1), firstNumber: 10, secondNumber: 11, thirdNumber: 13, fourthNumber: 14 }],
+          doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+        },
+        1,
+      ).toNumber(),
+    ).toEqual(84); // 3*2 for color, 1*3 for column, 1*3 for dozen,1*36 for straight, 1*18 for split, 1*12 for street, 1*6 for double street
+
+    // win everything
+    expect(
+      Roulette.getPayout(
+        {
+          parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+          colorValues: [{ amount: BigNumber(1), color: RouletteColor.RED }],
+          halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+          columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+          dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.THIRD }],
+          straightValues: [{ amount: BigNumber(1), straightNumber: 34 }],
+          splitValues: [{ amount: BigNumber(1), firstNumber: 34, secondNumber: 35 }],
+          streetValues: [{ amount: BigNumber(1), street: [34, 35, 36] }],
+          cornerValues: [{ amount: BigNumber(1), firstNumber: 31, secondNumber: 32, thirdNumber: 34, fourthNumber: 35 }],
+          doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [31, 32, 33], secondStreet: [34, 35, 36] }],
+        },
+        34,
+      ).toNumber(),
+    ).toEqual(93); // 2 for parity, 2 for color, 2 for half, 3 for column, 3 for dozen, 36 for straight, 18 for split, 12 for street, 6 for double street, 9 for corner
+
+    // win nothing
+    expect(
+      Roulette.getPayout(
+        {
+          parityValues: [{ amount: BigNumber(1), parity: RouletteParity.EVEN }],
+          colorValues: [
+            { amount: BigNumber(1), color: RouletteColor.BLACK },
+            { amount: BigNumber(1), color: RouletteColor.RED },
+            { amount: BigNumber(2), color: RouletteColor.RED },
+          ],
+          halfValues: [{ amount: BigNumber(1), half: RouletteHalf.HIGH }],
+          columnValues: [{ amount: BigNumber(1), column: RouletteColumn.BOTTOM }],
+          dozenValues: [{ amount: BigNumber(1), dozen: RouletteDozen.FIRST }],
+          straightValues: [{ amount: BigNumber(1), straightNumber: 1 }],
+          splitValues: [{ amount: BigNumber(1), firstNumber: 1, secondNumber: 2 }],
+          streetValues: [{ amount: BigNumber(1), street: [1, 2, 3] }],
+          cornerValues: [{ amount: BigNumber(1), firstNumber: 10, secondNumber: 11, thirdNumber: 13, fourthNumber: 14 }],
+          doubleStreetValues: [{ amount: BigNumber(1), firstStreet: [1, 2, 3], secondStreet: [4, 5, 6] }],
+        },
+        0,
+      ).toNumber(),
+    ).toEqual(0);
+  });
+});
+
+function generateDigestHex({
+  serverSeed,
+  clientSeed,
+  nonce,
+  rounds = 2,
+}: {
+  serverSeed: string;
+  clientSeed: string;
+  nonce: string;
+  rounds?: number;
+}): string[] {
+  const results = Array.from(Array(rounds).keys()).map((round) => {
+    const hmac = createHmac('sha256', serverSeed);
+    hmac.update(`${clientSeed}:${nonce}:${round}`);
+    return hmac.digest('hex');
+  });
+
+  return results;
+}