shufflecom-calculations 4.3.2 → 4.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "4.3.2",
+  "version": "4.3.3",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "267cf8cd0477307db6392d3485cf1557371b098c"
+  "gitHead": "3d5d2ae67ace14d80a6d16becc6a2107d7f15080"
 }

package/src/games/blitz.spec.ts

@@ -1,5 +1,6 @@
 import { createHmac } from 'crypto';
 import { Blitz } from './blitz';
+import { CardGames } from './cardGames';
 
 const SERVER_SEED = 'ebd3ff712ee7ed3cabe3753146f95847b017f847758ed254c531ff0d45686cea';
 const CLIENT_SEED = 'pf4jl5q97q';
@@ -47,36 +48,20 @@ function generateDigestHex(nonce: string, rounds: number): string[] {
   });
 }
 
-describe('Blitz.getGameSeedRounds', () => {
-  it('returns 1 round for picks 1–8', () => {
-    expect(Blitz.getGameSeedRounds(5)).toBe(1);
-    expect(Blitz.getGameSeedRounds(8)).toBe(1);
-  });
-
-  it('returns 2 rounds for picks 9–16', () => {
-    expect(Blitz.getGameSeedRounds(9)).toBe(2);
-    expect(Blitz.getGameSeedRounds(16)).toBe(2);
-  });
-
-  it('returns 4 rounds for 30 picks (max)', () => {
-    expect(Blitz.getGameSeedRounds(30)).toBe(4);
-  });
-});
-
 describe('Blitz.getGameOutcome', () => {
   it('returns the correct number of cards', () => {
-    const hexStrings = generateDigestHex('1', Blitz.getGameSeedRounds(10));
+    const hexStrings = generateDigestHex('1', Blitz.getMaxUniqueCardsSeedRounds());
     const { cards } = Blitz.getGameOutcome(hexStrings, 10);
     expect(cards).toHaveLength(10);
 
-    const hexStrings2 = generateDigestHex('2', Blitz.getGameSeedRounds(25));
+    const hexStrings2 = generateDigestHex('2', Blitz.getMaxUniqueCardsSeedRounds());
     const { cards: cards2 } = Blitz.getGameOutcome(hexStrings2, 25);
     expect(cards2).toHaveLength(25);
   });
 
   it('maxCount is 1 when all cards are unique', () => {
     // Force a known set of unique cards by checking the outcome
-    const hexStrings = generateDigestHex('1', Blitz.getGameSeedRounds(5));
+    const hexStrings = generateDigestHex('1', Blitz.getMaxUniqueCardsSeedRounds());
     const { maxRepeatedCount, cards } = Blitz.getGameOutcome(hexStrings, 5);
     const uniqueCount = new Set(cards).size;
     if (uniqueCount === 5) {
@@ -87,15 +72,59 @@ describe('Blitz.getGameOutcome', () => {
   });
 
   it('maxCount reflects the highest duplicate count', () => {
-    const hexStrings = generateDigestHex('5', Blitz.getGameSeedRounds(30));
+    const hexStrings = generateDigestHex('5', Blitz.getMaxUniqueCardsSeedRounds());
     const { maxRepeatedCount } = Blitz.getGameOutcome(hexStrings, 30);
 
     expect(maxRepeatedCount).toBe(2);
 
-    const hexStrings2 = generateDigestHex('6', Blitz.getGameSeedRounds(30));
+    const hexStrings2 = generateDigestHex('6', Blitz.getMaxUniqueCardsSeedRounds());
     const { maxRepeatedCount: maxRepeatedCount2 } = Blitz.getGameOutcome(hexStrings2, 30);
     expect(maxRepeatedCount2).toBe(3);
   });
+
+  describe('maxUniqueCardsBeforeDuplicate', () => {
+    function bruteForceUniqueCountBeforeDuplicate(hexStrings: string[]): number {
+      const cards = CardGames.getResults(hexStrings);
+      const seen = new Set<number>();
+
+      for (const card of cards) {
+        if (seen.has(card)) return seen.size;
+        seen.add(card);
+      }
+
+      return seen.size;
+    }
+
+    it('matches a brute-force scan of all drawn cards for several nonces', () => {
+      for (const nonce of ['1', '2', '5', '6', '42']) {
+        const hexStrings = generateDigestHex(nonce, Blitz.getMaxUniqueCardsSeedRounds());
+        const { maxUniqueCardsBeforeDuplicate } = Blitz.getGameOutcome(hexStrings, 5);
+        expect(maxUniqueCardsBeforeDuplicate).toBe(bruteForceUniqueCountBeforeDuplicate(hexStrings));
+      }
+    });
+
+    it('never exceeds the number of distinct cards in a deck', () => {
+      for (const nonce of ['1', '2', '5', '6', '42']) {
+        const hexStrings = generateDigestHex(nonce, Blitz.getMaxUniqueCardsSeedRounds());
+        const { maxUniqueCardsBeforeDuplicate } = Blitz.getGameOutcome(hexStrings, 5);
+        expect(maxUniqueCardsBeforeDuplicate).toBeLessThanOrEqual(52);
+      }
+    });
+
+    it('is independent of picks, since it scans the full drawn card sequence', () => {
+      const hexStrings = generateDigestHex('1', Blitz.getMaxUniqueCardsSeedRounds());
+      const outcomeA = Blitz.getGameOutcome(hexStrings, 5);
+      const outcomeB = Blitz.getGameOutcome(hexStrings, 30);
+
+      expect(outcomeA.maxUniqueCardsBeforeDuplicate).toBe(outcomeB.maxUniqueCardsBeforeDuplicate);
+    });
+  });
+});
+
+describe('Blitz.getMaxUniqueCardsSeedRounds', () => {
+  it('returns enough rounds to guarantee a duplicate within a 52-card deck', () => {
+    expect(Blitz.getMaxUniqueCardsSeedRounds()).toBe(7);
+  });
 });
 
 describe('Blitz.isCleanSweepWin', () => {

package/src/games/blitz.ts

@@ -8,36 +8,46 @@ export const BLITZ_MAX_PICKS = 36;
 export interface BlitzResult {
   maxRepeatedCount: number;
   cards: number[];
+  maxUniqueCardsBeforeDuplicate: number;
 }
 
 export class Blitz {
-  static getGameSeedRounds(picks: number): number {
-    return Math.ceil(picks / 8);
+  static getMaxUniqueCardsSeedRounds(): number {
+    return Math.ceil((CARDS_PER_DECK + 1) / 8);
   }
 
-  private static drawCards(hexStrings: string[], picks: number): number[] {
-    const cards = CardGames.getResults(hexStrings);
+  static getGameOutcome(hexStrings: string[], picks: number): BlitzResult {
+    const allCards = CardGames.getResults(hexStrings);
 
-    if (cards.length < picks) {
+    if (allCards.length < picks) {
       throw new Error('Not enough cards drawn');
     }
 
-    return cards.slice(0, picks);
-  }
-
-  static getGameOutcome(hexStrings: string[], picks: number): BlitzResult {
-    const cards = this.drawCards(hexStrings, picks);
     const cardCounts: Record<number, number> = {};
     let maxRepeatedCount = 0;
+    let maxUniqueCardsBeforeDuplicate = 0;
+    let duplicateFound = false;
+
+    for (let i = 0; i < allCards.length; i++) {
+      const card = allCards[i];
+      const isNewCard = !(card in cardCounts);
+
+      cardCounts[card] = (cardCounts[card] || 0) + 1;
 
-    for (const card of cards) {
-      const count = (cardCounts[card] || 0) + 1;
-      cardCounts[card] = count;
+      if (i < picks && cardCounts[card] > maxRepeatedCount) {
+        maxRepeatedCount = cardCounts[card];
+      }
 
-      if (count > maxRepeatedCount) maxRepeatedCount = count;
+      if (!duplicateFound) {
+        if (isNewCard) {
+          maxUniqueCardsBeforeDuplicate++;
+        } else {
+          duplicateFound = true;
+        }
+      }
     }
 
-    return { maxRepeatedCount, cards };
+    return { maxRepeatedCount, cards: allCards.slice(0, picks), maxUniqueCardsBeforeDuplicate };
   }
 
   static calculateWinChanceBN(picks: number): BigNumber {