shufflecom-calculations 1.2.4 → 1.3.0

package/src/games/roulette.ts

@@ -0,0 +1,521 @@
+import BigNumber from 'bignumber.js';
+import { hexToBytes } from '../utils/hex-to-bytes';
+const BYTE_TOTAL = BigNumber(256);
+const TOTAL_TILES = BigNumber(37);
+
+// Outside Bets
+export enum RouletteParity {
+  EVEN = 'EVEN',
+  ODD = 'ODD',
+}
+
+interface RouletteParityInput {
+  parity: RouletteParity;
+  amount: BigNumber; // check to be placed for negative numbers
+}
+
+export enum RouletteColor {
+  RED = 'RED',
+  BLACK = 'BLACK',
+}
+
+interface ColorInput {
+  color: RouletteColor;
+  amount: BigNumber;
+}
+
+export enum RouletteColumn {
+  TOP = 'TOP',
+  MIDDLE = 'MIDDLE',
+  BOTTOM = 'BOTTOM',
+}
+
+interface ColumnInput {
+  column: RouletteColumn;
+  amount: BigNumber;
+}
+
+export enum RouletteDozen {
+  FIRST = 'FIRST',
+  SECOND = 'SECOND',
+  THIRD = 'THIRD',
+}
+
+interface DozenInput {
+  dozen: RouletteDozen;
+  amount: BigNumber;
+}
+
+export enum RouletteHalf {
+  LOW = 'LOW',
+  HIGH = 'HIGH',
+}
+
+interface HalfInput {
+  half: RouletteHalf;
+  amount: BigNumber;
+}
+
+// Inside bets involving 0
+// Straight 0
+// Split 0,1/0,2/0,3
+// Street 0,1,2/0,2,3 (0,1,3 is not included as it's not physically on the board)
+// Corner 0,1,2,3
+// No double street
+
+export const STRAIGHT_VALUES = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+] as const;
+export const STREET_VALUES = [
+  // these 2 are the only street that are not allowed in a double street as it's not physically possible on the board
+  [0, 1, 2],
+  [0, 2, 3],
+  // every other adjacent street below is a valid double street pair
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [10, 11, 12],
+  [13, 14, 15],
+  [16, 17, 18],
+  [19, 20, 21],
+  [22, 23, 24],
+  [25, 26, 27],
+  [28, 29, 30],
+  [31, 32, 33],
+  [34, 35, 36],
+] as const;
+
+export type straightValue = (typeof STRAIGHT_VALUES)[number];
+
+export type streetValue = (typeof STREET_VALUES)[number];
+
+export interface StraightInput {
+  straightNumber: straightValue;
+  amount: BigNumber;
+}
+
+export interface SplitInput {
+  firstNumber: straightValue;
+  secondNumber: straightValue;
+  amount: BigNumber;
+}
+
+export interface CornerInput {
+  firstNumber: straightValue;
+  secondNumber: straightValue;
+  thirdNumber: straightValue;
+  fourthNumber: straightValue;
+
+  amount: BigNumber;
+}
+
+export interface StreetInput {
+  street: streetValue;
+  amount: BigNumber;
+}
+
+export interface DoubleStreetInput {
+  firstStreet: streetValue;
+  secondStreet: streetValue;
+  amount: BigNumber;
+}
+
+// !: Needs to match RoulettePlayInput input type
+export interface RouletteInput {
+  // outside bets
+  parityValues: RouletteParityInput[];
+  colorValues: ColorInput[];
+  halfValues: HalfInput[];
+  columnValues: ColumnInput[];
+  dozenValues: DozenInput[];
+
+  // inside bets
+  straightValues: StraightInput[];
+  splitValues: SplitInput[];
+  streetValues: StreetInput[]; // number is the smallest number in the column
+  cornerValues: CornerInput[]; // check to be done that it's a valid corner
+  doubleStreetValues: DoubleStreetInput[]; // firstNumber is the smallest number in the column, secondNumber is the smallest number in the adjacent column
+}
+
+const isValidStraight = (num: number): boolean => {
+  return STRAIGHT_VALUES.includes(num as straightValue);
+};
+
+export const isValidStreet = (street: streetValue): boolean => {
+  const sortedStreet = (street as unknown as number[]).sort((a, b) => a - b);
+
+  return sortedStreet.length === 3 && STREET_VALUES.some((val) => val[0] === sortedStreet[0] && val[1] === sortedStreet[1] && val[2] === sortedStreet[2]);
+};
+
+// for corners (up, down, left, right, and diagonally adjacent)
+export const cornerNumbers = (num: straightValue): straightValue[] => {
+  if (!isValidStraight(num)) {
+    return [];
+  }
+
+  // need to hardcode as 0 is a special case
+  if (num === 0) {
+    return [1, 2, 3];
+  } else if (num === 1) {
+    return [0, 2, 3, 4, 5];
+  } else if (num === 2) {
+    return [0, 1, 3, 4, 5, 6];
+  } else if (num === 3) {
+    return [0, 1, 2, 5, 6];
+  }
+
+  // when num is 0
+  let possibleCornerNumbers: number[] = [];
+  if (num % 3 === 1) {
+    possibleCornerNumbers = [num - 3, num - 2, num + 1, num + 3, num + 4];
+  } else if (num % 3 === 2) {
+    possibleCornerNumbers = [num - 4, num - 3, num - 2, num - 1, num + 1, num + 2, num + 3, num + 4];
+  } else {
+    possibleCornerNumbers = [num - 4, num - 3, num - 1, num + 2, num + 3];
+  }
+
+  return possibleCornerNumbers.filter((num) => isValidStraight(num)) as straightValue[];
+};
+
+// up, down, left, right
+export const isValidSplit = (firstNumber: straightValue, secondNumber: straightValue): boolean => {
+  if (!isValidStraight(firstNumber) || !isValidStraight(secondNumber)) {
+    return false;
+  }
+
+  let possibleSplitNumbers: number[] = [];
+
+  if (firstNumber % 3 === 1) {
+    possibleSplitNumbers = [firstNumber - 3, firstNumber + 1, firstNumber + 3];
+  } else if (firstNumber % 3 === 2) {
+    possibleSplitNumbers = [firstNumber - 3, firstNumber - 1, firstNumber + 1, firstNumber + 3];
+  } else {
+    possibleSplitNumbers = [firstNumber - 3, firstNumber - 1, firstNumber + 3];
+  }
+
+  const filteredPossibleSplitNumbers = possibleSplitNumbers.filter((num) => isValidStraight(num)) as straightValue[];
+
+  if (firstNumber !== 0 && secondNumber !== 0) {
+    return filteredPossibleSplitNumbers.includes(secondNumber);
+  } else if (firstNumber === 0) {
+    return secondNumber === 1 || secondNumber === 2 || secondNumber === 3;
+  } else if (secondNumber === 0) {
+    return firstNumber === 1 || firstNumber === 2 || firstNumber === 3;
+  }
+
+  return false; // should never reach here
+};
+
+export const isValidCorner = (firstNumber: straightValue, secondNumber: straightValue, thirdNumber: straightValue, fourthNumber: straightValue): boolean => {
+  // all 4 numbers MUST be adjacent to every other number
+  const numbersAdjacentToFirstNumber = cornerNumbers(firstNumber);
+  const numbersAdjacentToSecondNumber = cornerNumbers(secondNumber);
+  const numbersAdjacentToThirdNumber = cornerNumbers(thirdNumber);
+  const numbersAdjacentToFourthNumber = cornerNumbers(fourthNumber);
+
+  const allNumsAdjacentToFirstNumber =
+    numbersAdjacentToFirstNumber.includes(secondNumber) &&
+    numbersAdjacentToFirstNumber.includes(thirdNumber) &&
+    numbersAdjacentToFirstNumber.includes(fourthNumber);
+
+  const allNumsAdjacentToSecondNumber =
+    numbersAdjacentToSecondNumber.includes(firstNumber) &&
+    numbersAdjacentToSecondNumber.includes(thirdNumber) &&
+    numbersAdjacentToSecondNumber.includes(fourthNumber);
+
+  const allNumsAdjacentToThirdNumber =
+    numbersAdjacentToThirdNumber.includes(firstNumber) &&
+    numbersAdjacentToThirdNumber.includes(secondNumber) &&
+    numbersAdjacentToThirdNumber.includes(fourthNumber);
+
+  const allNumsAdjacentToFourthNumber =
+    numbersAdjacentToFourthNumber.includes(firstNumber) &&
+    numbersAdjacentToFourthNumber.includes(secondNumber) &&
+    numbersAdjacentToFourthNumber.includes(thirdNumber);
+
+  return allNumsAdjacentToFirstNumber && allNumsAdjacentToSecondNumber && allNumsAdjacentToThirdNumber && allNumsAdjacentToFourthNumber;
+};
+
+export const isValidDoubleStreet = (firstStreet: streetValue, secondStreet: streetValue): boolean => {
+  if (!isValidStreet(firstStreet) || !isValidStreet(secondStreet)) {
+    return false;
+  }
+
+  const firstNumOfFirstStreet = firstStreet[0];
+  const firstNumOfSecondStreet = secondStreet[0];
+
+  // 0 is not in any valid double streets
+  if (firstNumOfFirstStreet === 0 || firstNumOfSecondStreet === 0) {
+    return false;
+  }
+
+  return firstNumOfFirstStreet + 3 === firstNumOfSecondStreet || firstNumOfFirstStreet - 3 === firstNumOfSecondStreet;
+};
+
+export enum BetType {
+  // outside bets
+  PARITY = 'PARITY',
+  COLOR = 'COLOR',
+  HALF = 'HALF',
+  COLUMN = 'COLUMN',
+  DOZEN = 'DOZEN',
+
+  // inside bets
+  STRAIGHT = 'STRAIGHT',
+  SPLIT = 'SPLIT',
+  STREET = 'STREET',
+  CORNER = 'CORNER',
+  DOUBLE_STREET = 'DOUBLE_STREET',
+}
+
+// payout, not profit
+const PAYOUT_MAP: Record<BetType, BigNumber> = {
+  [BetType.PARITY]: BigNumber(2),
+  [BetType.COLOR]: BigNumber(2),
+  [BetType.HALF]: BigNumber(2),
+  [BetType.COLUMN]: BigNumber(3),
+  [BetType.DOZEN]: BigNumber(3),
+  [BetType.STRAIGHT]: BigNumber(36),
+  [BetType.SPLIT]: BigNumber(18),
+  [BetType.STREET]: BigNumber(12),
+  [BetType.CORNER]: BigNumber(9),
+  [BetType.DOUBLE_STREET]: BigNumber(6),
+};
+
+export const RED_NUMBERS = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36];
+export const BLACK_NUMBERS = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35];
+
+// Payout stuff
+export const parityPayout = ({ parity, amount }: RouletteParityInput, result: straightValue): BigNumber => {
+  if (result === 0) return BigNumber(0);
+
+  const resultParity = result % 2 === 0 ? RouletteParity.EVEN : RouletteParity.ODD;
+  const isWin = parity === resultParity;
+
+  if (isWin) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.PARITY]);
+  }
+  return BigNumber(0);
+};
+
+export const colorPayout = ({ color, amount }: ColorInput, result: straightValue): BigNumber => {
+  const isRed = RED_NUMBERS.includes(result);
+  const isBlack = BLACK_NUMBERS.includes(result);
+
+  if ((isRed && color === RouletteColor.RED) || (isBlack && color === RouletteColor.BLACK)) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.COLOR]);
+  }
+
+  return BigNumber(0);
+};
+
+export const halfsPayout = ({ half, amount }: HalfInput, result: straightValue): BigNumber => {
+  const isLow = result > 0 && result <= 18;
+  const isHigh = result > 18 && result <= 36;
+
+  if ((isLow && half === RouletteHalf.LOW) || (isHigh && half === RouletteHalf.HIGH)) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.HALF]);
+  }
+
+  return BigNumber(0);
+};
+
+export const columnPayout = ({ column, amount }: ColumnInput, result: straightValue): BigNumber => {
+  const topColumn = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36];
+  const middleColumn = [2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35];
+  const bottomColumn = [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34];
+
+  if (
+    (column === RouletteColumn.TOP && topColumn.includes(result)) ||
+    (column === RouletteColumn.MIDDLE && middleColumn.includes(result)) ||
+    (column === RouletteColumn.BOTTOM && bottomColumn.includes(result))
+  ) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.COLUMN]);
+  }
+
+  return BigNumber(0);
+};
+
+export const dozenPayout = ({ dozen, amount }: DozenInput, result: straightValue): BigNumber => {
+  const firstDozen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+  const secondDozen = [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24];
+  const thirdDozen = [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
+
+  if (
+    (dozen === RouletteDozen.FIRST && firstDozen.includes(result)) ||
+    (dozen === RouletteDozen.SECOND && secondDozen.includes(result)) ||
+    (dozen === RouletteDozen.THIRD && thirdDozen.includes(result))
+  ) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.DOZEN]);
+  }
+
+  return BigNumber(0);
+};
+
+export const straightPayout = ({ straightNumber, amount }: StraightInput, result: straightValue): BigNumber => {
+  if (result === straightNumber) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.STRAIGHT]);
+  }
+
+  return BigNumber(0);
+};
+
+export const splitPayout = ({ firstNumber, secondNumber, amount }: SplitInput, result: straightValue): BigNumber => {
+  if (result === firstNumber || result === secondNumber) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.SPLIT]);
+  }
+
+  return BigNumber(0);
+};
+
+export const streetPayout = ({ street, amount }: StreetInput, result: straightValue): BigNumber => {
+  if ((street as readonly number[]).includes(result)) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.STREET]);
+  }
+
+  return BigNumber(0);
+};
+
+export const cornerPayout = ({ firstNumber, secondNumber, thirdNumber, fourthNumber, amount }: CornerInput, result: straightValue): BigNumber => {
+  const cornerNumbers = [firstNumber, secondNumber, thirdNumber, fourthNumber];
+
+  if (cornerNumbers.includes(result)) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.CORNER]);
+  }
+
+  return BigNumber(0);
+};
+
+export const doubleStreetPayout = ({ firstStreet, secondStreet, amount }: DoubleStreetInput, result: straightValue): BigNumber => {
+  if ((firstStreet as readonly number[]).includes(result) || (secondStreet as readonly number[]).includes(result)) {
+    return amount.multipliedBy(PAYOUT_MAP[BetType.DOUBLE_STREET]);
+  }
+
+  return BigNumber(0);
+};
+
+export class Roulette {
+  // get a whole number from 0-36 inclusive
+  static getResult(hexStr: string): straightValue {
+    const gameResultBytes = hexToBytes(hexStr);
+
+    let result = BigNumber(0);
+
+    // Only use the first 4
+    for (let i = 0; i < 4; i++) {
+      const value = gameResultBytes[i];
+      result = result.plus(BigNumber(value).dividedBy(BYTE_TOTAL.pow(i + 1)));
+    }
+
+    const resultNum = result.multipliedBy(TOTAL_TILES).integerValue(BigNumber.ROUND_DOWN).toNumber() as straightValue;
+
+    if (!isValidStraight(resultNum)) {
+      throw new Error('Invalid result');
+    }
+
+    return resultNum;
+  }
+
+  static getPayout(inputs: RouletteInput, result: straightValue): BigNumber {
+    if (!this.validateInputs(inputs)) {
+      throw new Error('Invalid inputs');
+    }
+
+    const {
+      // outside bets
+      parityValues,
+      colorValues,
+      halfValues,
+      columnValues,
+      dozenValues,
+
+      // inside bets
+      straightValues,
+      splitValues,
+      streetValues,
+      cornerValues,
+      doubleStreetValues,
+    } = inputs;
+
+    const totalParityPayout = parityValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(parityPayout(input, result));
+    }, BigNumber(0));
+
+    const totalColorPayout = colorValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(colorPayout(input, result));
+    }, BigNumber(0));
+
+    const totalHalfsPayout = halfValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(halfsPayout(input, result));
+    }, BigNumber(0));
+
+    const totalColumnsPayout = columnValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(columnPayout(input, result));
+    }, BigNumber(0));
+
+    const totalDozensPayout = dozenValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(dozenPayout(input, result));
+    }, BigNumber(0));
+
+    const totalStraightsPayout = straightValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(straightPayout(input, result));
+    }, BigNumber(0));
+
+    const totalSplitPayout = splitValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(splitPayout(input, result));
+    }, BigNumber(0));
+
+    const totalStreetPayout = streetValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(streetPayout(input, result));
+    }, BigNumber(0));
+
+    const totalCornerPayout = cornerValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(cornerPayout(input, result));
+    }, BigNumber(0));
+
+    const totalDoubleStreetPayout = doubleStreetValues.reduce((totalPayout, input) => {
+      return totalPayout.plus(doubleStreetPayout(input, result));
+    }, BigNumber(0));
+
+    const totalPayout = totalParityPayout
+      .plus(totalColorPayout)
+      .plus(totalHalfsPayout)
+      .plus(totalColumnsPayout)
+      .plus(totalDozensPayout)
+      .plus(totalStraightsPayout)
+      .plus(totalSplitPayout)
+      .plus(totalStreetPayout)
+      .plus(totalCornerPayout)
+      .plus(totalDoubleStreetPayout);
+
+    return totalPayout;
+  }
+
+  static validateInputs(inputs: RouletteInput): boolean {
+    const { straightValues, splitValues, streetValues, cornerValues, doubleStreetValues, parityValues, colorValues, columnValues, dozenValues, halfValues } =
+      inputs;
+    // user must bet on at least one thing
+    if (
+      straightValues.length === 0 &&
+      splitValues.length === 0 &&
+      streetValues.length === 0 &&
+      cornerValues.length === 0 &&
+      doubleStreetValues.length === 0 &&
+      parityValues.length === 0 &&
+      colorValues.length === 0 &&
+      columnValues.length === 0 &&
+      dozenValues.length === 0 &&
+      halfValues.length === 0
+    ) {
+      return false;
+    }
+
+    const straightsValid = straightValues.every((input) => isValidStraight(input.straightNumber));
+    const splitsValid = splitValues.every((input) => isValidSplit(input.firstNumber, input.secondNumber));
+    const streetsValid = streetValues.every((input) => isValidStreet(input.street));
+    const cornersValid = cornerValues.every((input) => isValidCorner(input.firstNumber, input.secondNumber, input.thirdNumber, input.fourthNumber));
+    const doubleStreetsValid = doubleStreetValues.every((input) => isValidDoubleStreet(input.firstStreet, input.secondStreet));
+
+    return straightsValid && splitsValid && streetsValid && cornersValid && doubleStreetsValid;
+  }
+}

package/src/index.ts

@@ -9,6 +9,7 @@ export { VipBonusIssuanceStatus } from './utils/vip-bonus.type';
 export { deriveBonusIssuances } from './utils/derive-vip-bonus';
 export { convertBs58ToUuid, convertUuidToBs58 } from './utils/uuid-converter';
 export { Dice, DiceDirection } from './games/dice';
+export { Roulette } from './games/roulette';
 export { Mines } from './games/mines';
 export { Plinko, PlinkoRiskLevel } from './games/plinko';
 export { Crash } from './games/crash';

package/src/utils/dates-calculator.ts

@@ -6,7 +6,7 @@ export class DatesCalculator {
   // Most recent thursday at 11:00 UTC
   static startOfWeeklyBonus = (utcDate: Dayjs) => {
     if (!utcDate.isUTC()) {
-      throw 'utcDate must be in UTC';
+      throw new Error('utcDate must be in UTC');
     }
 
     const thisThursday = utcDate.startOf('week').set('day', 4).set('hour', 11);
@@ -21,7 +21,7 @@ export class DatesCalculator {
   // Most recent first friday of a month at 00:00 UTC
   static startOfMonthlyBonus = (utcDate: Dayjs): Date => {
     if (!utcDate.isUTC()) {
-      throw 'utcDate must be in UTC';
+      throw new Error('utcDate must be in UTC');
     }
 
     const startOfMonth = utcDate.startOf('month');