shufflecom-calculations 3.0.4 → 3.1.0

package/src/games/baccarat.ts

@@ -0,0 +1,273 @@
+import BigNumber from 'bignumber.js';
+import { CardGames } from './cardGames';
+
+export enum BaccaratBetType {
+  PLAYER = 'PLAYER',
+  BANKER = 'BANKER',
+  TIE = 'TIE',
+  PLAYER_PAIR = 'PLAYER_PAIR',
+  BANKER_PAIR = 'BANKER_PAIR',
+  PERFECT_PAIR = 'PERFECT_PAIR',
+  EITHER_PAIR = 'EITHER_PAIR',
+  PLAYER_BONUS = 'PLAYER_BONUS',
+  BANKER_BONUS = 'BANKER_BONUS',
+}
+
+export enum BaccaratOutcome {
+  PLAYER_WIN = 'PLAYER_WIN',
+  BANKER_WIN = 'BANKER_WIN',
+  TIE = 'TIE',
+}
+
+export interface BaccaratBet {
+  type: BaccaratBetType;
+  amount: BigNumber;
+}
+
+export interface BaccaratGameResult {
+  playerCards: number[]; // card indices 0–51, 2 or 3 cards
+  bankerCards: number[]; // card indices 0–51, 2 or 3 cards
+  playerHandValue: number; // 0–9
+  bankerHandValue: number; // 0–9
+  outcome: BaccaratOutcome;
+}
+
+export interface BaccaratTrendData {
+  outcome: BaccaratOutcome;
+  playerPair: boolean;
+  bankerPair: boolean;
+}
+
+const PLAYER_WIN_MULTIPLIER = new BigNumber(2); // 1:1
+const BANKER_WIN_MULTIPLIER = new BigNumber(1.95); // 0.95:1
+const TIE_MULTIPLIER = new BigNumber(9); // 8:1
+const PAIR_MULTIPLIER = new BigNumber(12); // 11:1
+const EITHER_PAIR_MULTIPLIER = new BigNumber(6); // 5:1
+const PERFECT_PAIR_ONE_HAND_MULTIPLIER = new BigNumber(26); // 25:1
+const PERFECT_PAIR_BOTH_HANDS_MULTIPLIER = new BigNumber(201); // 200:1
+const BONUS_NATURAL_WIN_MULTIPLIER = new BigNumber(2); // 1:1
+const BONUS_NATURAL_TIE_MULTIPLIER = new BigNumber(1); // push
+
+const BONUS_NON_NATURAL_PAYOUT: Record<number, BigNumber> = {
+  4: new BigNumber(2), // 1:1
+  5: new BigNumber(3), // 2:1
+  6: new BigNumber(5), // 4:1
+  7: new BigNumber(7), // 6:1
+  8: new BigNumber(11), // 10:1
+  9: new BigNumber(31), // 30:1
+};
+
+export class Baccarat {
+  static getBaccaratCardValue(cardIndex: number): number {
+    const { value } = CardGames.getCardDetails(cardIndex);
+    if (value === '10' || value === 'J' || value === 'Q' || value === 'K') {
+      return 0;
+    }
+    if (value === 'A') {
+      return 1;
+    }
+    return parseInt(value, 10);
+  }
+
+  static calcHandValue(cards: number[]): number {
+    return cards.reduce((sum, card) => (sum + this.getBaccaratCardValue(card)) % 10, 0);
+  }
+
+  static isNatural(handValue: number, cards: number[]): boolean {
+    return (handValue === 8 || handValue === 9) && cards.length === 2;
+  }
+
+  private static shouldPlayerDrawThird(playerValue: number): boolean {
+    return playerValue <= 5;
+  }
+
+  private static shouldBankerDrawThird(bankerValue: number, playerThirdCardValue: number | null): boolean {
+    if (playerThirdCardValue === null) {
+      return bankerValue <= 5;
+    }
+    if (bankerValue <= 2) {
+      return true;
+    }
+    if (bankerValue === 3) {
+      return playerThirdCardValue !== 8;
+    }
+    if (bankerValue === 4) {
+      return [2, 3, 4, 5, 6, 7].includes(playerThirdCardValue);
+    }
+    if (bankerValue === 5) {
+      return [4, 5, 6, 7].includes(playerThirdCardValue);
+    }
+    if (bankerValue === 6) {
+      return [6, 7].includes(playerThirdCardValue);
+    }
+    return false;
+  }
+
+  static getGameResult(hexString: string): BaccaratGameResult {
+    const cardIndices = CardGames.getResults([hexString]).slice(0, 6);
+
+    if (cardIndices.length !== 6) {
+      throw new Error(`Expected 6 card indices for Baccarat, but got ${cardIndices.length}.`);
+    }
+
+    const playerCards: number[] = [cardIndices[0], cardIndices[2]];
+    const bankerCards: number[] = [cardIndices[1], cardIndices[3]];
+
+    let playerHandValue = this.calcHandValue(playerCards);
+    let bankerHandValue = this.calcHandValue(bankerCards);
+
+    let thirdCardIndex = 4; // Index for player's third card if drawn, or banker's third card if player doesn't draw
+    const isNaturalWin = this.isNatural(playerHandValue, playerCards) || this.isNatural(bankerHandValue, bankerCards);
+    if (!isNaturalWin) {
+      let playerThirdCardValue: number | null = null;
+
+      if (this.shouldPlayerDrawThird(playerHandValue)) {
+        playerCards.push(cardIndices[thirdCardIndex]);
+        playerThirdCardValue = this.getBaccaratCardValue(cardIndices[thirdCardIndex]);
+        playerHandValue = this.calcHandValue(playerCards);
+        thirdCardIndex++;
+      }
+
+      if (this.shouldBankerDrawThird(bankerHandValue, playerThirdCardValue)) {
+        bankerCards.push(cardIndices[thirdCardIndex]);
+        bankerHandValue = this.calcHandValue(bankerCards);
+      }
+    }
+
+    let outcome: BaccaratOutcome;
+
+    if (playerHandValue === bankerHandValue) {
+      outcome = BaccaratOutcome.TIE;
+    } else {
+      outcome = playerHandValue > bankerHandValue ? BaccaratOutcome.PLAYER_WIN : BaccaratOutcome.BANKER_WIN;
+    }
+
+    return { playerCards, bankerCards, playerHandValue, bankerHandValue, outcome };
+  }
+
+  static hasPair(cards: number[]): boolean {
+    return CardGames.getCardDetails(cards[0]).value === CardGames.getCardDetails(cards[1]).value;
+  }
+
+  static getTrendData(result: BaccaratGameResult): BaccaratTrendData {
+    return {
+      outcome: result.outcome,
+      playerPair: Baccarat.hasPair(result.playerCards),
+      bankerPair: Baccarat.hasPair(result.bankerCards),
+    };
+  }
+
+  static hasPerfectPair(cards: number[]): boolean {
+    return cards[0] === cards[1];
+  }
+
+  private static getBonusPayout(betType: BaccaratBetType.PLAYER_BONUS | BaccaratBetType.BANKER_BONUS, result: BaccaratGameResult): BigNumber {
+    const { playerCards, bankerCards, playerHandValue, bankerHandValue, outcome } = result;
+    const isPlayerBonus = betType === BaccaratBetType.PLAYER_BONUS;
+
+    const isNaturalTie =
+      this.isNatural(playerHandValue, playerCards) && this.isNatural(bankerHandValue, bankerCards) && outcome === BaccaratOutcome.TIE;
+    if (isNaturalTie) {
+      return BONUS_NATURAL_TIE_MULTIPLIER;
+    }
+
+    const sideBetWins = isPlayerBonus ? outcome === BaccaratOutcome.PLAYER_WIN : outcome === BaccaratOutcome.BANKER_WIN;
+
+    if (!sideBetWins) {
+      return new BigNumber(0);
+    }
+
+    const sideHandValue = isPlayerBonus ? playerHandValue : bankerHandValue;
+    const otherHandValue = isPlayerBonus ? bankerHandValue : playerHandValue;
+
+    if (this.isNatural(sideHandValue, isPlayerBonus ? playerCards : bankerCards)) {
+      return BONUS_NATURAL_WIN_MULTIPLIER;
+    }
+
+    const margin = sideHandValue - otherHandValue;
+    return BONUS_NON_NATURAL_PAYOUT[margin] ?? new BigNumber(0);
+  }
+
+  static calcBetPayouts(bets: BaccaratBet[], result: BaccaratGameResult): { payout: BigNumber; multiplier: BigNumber } {
+    const { outcome } = result;
+
+    const playerHasPair = this.hasPair(result.playerCards);
+    const bankerHasPair = this.hasPair(result.bankerCards);
+    const playerHasPerfectPair = this.hasPerfectPair(result.playerCards);
+    const bankerHasPerfectPair = this.hasPerfectPair(result.bankerCards);
+
+    let totalPayout = new BigNumber(0);
+    let totalBetAmount = new BigNumber(0);
+
+    for (const bet of bets) {
+      totalBetAmount = totalBetAmount.plus(bet.amount);
+      let betPayout = new BigNumber(0);
+
+      switch (bet.type) {
+        case BaccaratBetType.PLAYER:
+          if (outcome === BaccaratOutcome.PLAYER_WIN) {
+            betPayout = bet.amount.times(PLAYER_WIN_MULTIPLIER);
+          } else if (outcome === BaccaratOutcome.TIE) {
+            betPayout = bet.amount;
+          }
+          break;
+
+        case BaccaratBetType.BANKER:
+          if (outcome === BaccaratOutcome.BANKER_WIN) {
+            betPayout = bet.amount.times(BANKER_WIN_MULTIPLIER);
+          } else if (outcome === BaccaratOutcome.TIE) {
+            betPayout = bet.amount;
+          }
+          break;
+
+        case BaccaratBetType.TIE:
+          if (outcome === BaccaratOutcome.TIE) {
+            betPayout = bet.amount.times(TIE_MULTIPLIER);
+          }
+          break;
+
+        case BaccaratBetType.PLAYER_PAIR:
+          if (playerHasPair) {
+            betPayout = bet.amount.times(PAIR_MULTIPLIER);
+          }
+          break;
+
+        case BaccaratBetType.BANKER_PAIR:
+          if (bankerHasPair) {
+            betPayout = bet.amount.times(PAIR_MULTIPLIER);
+          }
+          break;
+
+        case BaccaratBetType.PERFECT_PAIR:
+          if (playerHasPerfectPair && bankerHasPerfectPair) {
+            betPayout = bet.amount.times(PERFECT_PAIR_BOTH_HANDS_MULTIPLIER);
+          } else if (playerHasPerfectPair || bankerHasPerfectPair) {
+            betPayout = bet.amount.times(PERFECT_PAIR_ONE_HAND_MULTIPLIER);
+          }
+          break;
+
+        case BaccaratBetType.EITHER_PAIR:
+          if (playerHasPair || bankerHasPair) {
+            betPayout = bet.amount.times(EITHER_PAIR_MULTIPLIER);
+          }
+          break;
+
+        case BaccaratBetType.PLAYER_BONUS:
+        case BaccaratBetType.BANKER_BONUS:
+          betPayout = bet.amount.times(this.getBonusPayout(bet.type, result));
+          break;
+      }
+
+      totalPayout = totalPayout.plus(betPayout);
+    }
+
+    const multiplier = totalBetAmount.gt(0) ? totalPayout.dividedBy(totalBetAmount) : new BigNumber(0);
+    return { payout: totalPayout, multiplier };
+  }
+
+  static getGameOutcome(bets: BaccaratBet[], hexString: string): { result: BaccaratGameResult; payout: BigNumber; multiplier: BigNumber } {
+    const result = this.getGameResult(hexString);
+    const { payout, multiplier } = this.calcBetPayouts(bets, result);
+    return { result, payout, multiplier };
+  }
+}

package/src/games/chicken.spec.ts

@@ -1,5 +1,5 @@
+import { createHmac } from 'crypto';
 import { Chicken, ChickenDifficulty } from './chicken';
-import { GameCalculation } from './gameCalculation';
 
 const edgeBps = 200;
 
@@ -89,11 +89,10 @@ describe('Chicken', () => {
     ];
 
     gameSeeds.forEach(e => {
-      const resultHex = GameCalculation.generateDigestHex({
-        serverSeed: e.serverSeed,
-        clientSeed: e.clientSeed,
-        nonce: e.nonce,
-        rounds: e.rounds,
+      const resultHex = Array.from(Array(e.rounds).keys()).map(round => {
+        const hmac = createHmac('sha256', e.serverSeed);
+        hmac.update(`${e.clientSeed}:${e.nonce}:${round}`);
+        return hmac.digest('hex');
       });
       const results = Chicken.getResults(resultHex, e.difficulty);
       expect(results).toEqual(e.results);

package/src/games/gameCalculation.ts

@@ -1,6 +1,5 @@
 import BigNumber from 'bignumber.js';
 import { hexToBytes } from '../utils/hex-to-bytes';
-import { createHmac } from 'crypto';
 
 export abstract class GameCalculation {
   private static readonly BYTE_TOTAL = new BigNumber(256);
@@ -126,28 +125,4 @@ export abstract class GameCalculation {
 
     return results;
   }
-
-  /**
-   * Generate provably fair random hex strings using HMAC-SHA256
-   *
-   * @param serverSeed - Secret server seed (revealed after game/rotation)
-   * @param clientSeed - Player-provided seed for transparency
-   * @param nonce - Sequential number that increments with each bet
-   * @param rounds - How many hex strings to generate (each = 32 bytes of randomness)
-   * @returns Array of hex strings, each representing 32 bytes of cryptographic randomness
-   */
-  static generateDigestHex({
-    serverSeed,
-    clientSeed,
-    nonce,
-    rounds,
-  }: { 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;
-  }
 }

package/src/index.ts

@@ -28,5 +28,10 @@ export {
   twentyOnePlusThreePayout,
   HandOutcome,
 } from './games/blackjack';
+export { Baccarat, BaccaratBetType, BaccaratOutcome } from './games/baccarat';
+export type { BaccaratBet, BaccaratGameResult } from './games/baccarat';
+export { Chicken, ChickenDifficulty } from './games/chicken';
+export { Tower, TowerDifficulty, TOWER_DIFFICULTY_TO_CONFIG, TOWER_TOTAL_ROWS } from './games/tower';
+export { Wheel, WheelRiskLevel, WheelSegments, WHEEL_MULTIPLIERS, WHEEL_SEGMENTS_TO_NUMBER } from './games/wheel';
 export { formatSelectionName } from './utils/sports-name';
 export { SportsContentWithFixturesInfo } from './utils/sports-content-fixture.types';

package/src/regex/index.ts

@@ -1,5 +1,5 @@
-// Must be between 8 and 24 characters long
-export const PWD_REGEX = /^.{8,24}$/;
+// Must contain at least 1 alphabetical character and 1 number. Can include any symbols
+export const PWD_REGEX = /^(?=.*[0-9])(?=.*[a-zA-Z])(?=\S+$).{8,24}$/i;
 // Must contain lowercase alphabetical characters, can include underscores, no other symbols
 export const USERNAME_REGEX = /^[a-z\d]{3,16}$/i;
 

package/src/regex/regex.spec.ts

@@ -11,20 +11,29 @@ import {
 
 describe('regex', () => {
   describe('PWD_REGEX', () => {
+    it('should allow for passwords that includes 1 character and 1 number with 8 or more character', () => {
+      expect(PWD_REGEX.test('abcdefgh1')).toBe(true);
+      expect(PWD_REGEX.test('abcdefgh1!@#$%^&*()')).toBe(true);
+      expect(PWD_REGEX.test('1234567a')).toBe(true);
+    });
+
     it('should not allow passwords with less than 8 characters', () => {
       expect(PWD_REGEX.test('abcdef1')).toBe(false);
       expect(PWD_REGEX.test('123456a')).toBe(false);
     });
 
-    it('should not exceed 24 characters', () => {
-      expect(PWD_REGEX.test('0123456789abcdefghijklmnopqrst')).toBe(false);
+    it('should not allow passwords that do not include a letter', () => {
+      expect(PWD_REGEX.test('12345678')).toBe(false);
+      expect(PWD_REGEX.test('12345678@!@#')).toBe(false);
     });
 
-    it('should allow passwords between 8-24 characters', () => {
-      expect(PWD_REGEX.test('12345678')).toBe(true);      
-      expect(PWD_REGEX.test('abcdefgh')).toBe(true);   
-      expect(PWD_REGEX.test('Password123!')).toBe(true);  
+    it('should not allow passwords that do not include a letter', () => {
+      expect(PWD_REGEX.test('abcdefgh')).toBe(false);
+      expect(PWD_REGEX.test('abcdefgh!@#$')).toBe(false);
+    });
 
+    it('should not exceed 24 characters', () => {
+      expect(PWD_REGEX.test('0123456789abcdefghijklmnopqrst')).toBe(false);
     });
   });