shufflecom-calculations 3.3.20 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "3.3.20",
+  "version": "4.1.0",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "680a93d4430f249efb6b00ac6a79421a9dcf71a1"
+  "gitHead": "12f611596255710c364326a119bf766ee459e0a5"
 }

package/src/lottery/lottery.spec.ts

@@ -1,119 +1,137 @@
 import { createHmac, randomBytes } from 'crypto';
-import { LOTTERY_POWER_BALL_MAX_NUMBER, LOTTERY_PRIMARY_BALL_COUNT, LOTTERY_PRIMARY_BALL_MAX_NUMBER, Lottery } from './lottery';
+import { Lottery, LotteryVersion } from './lottery';
+
+function generateSeedAndHashes(version: LotteryVersion) {
+  const seed = randomBytes(32).toString('hex');
+  const btcBlockHash = randomBytes(32).toString('hex');
+  return {
+    seed,
+    btcBlockHash,
+    results: Lottery.generateBalls(version, createHmac('sha256', seed).update(btcBlockHash).digest('hex')),
+  };
+}
 
 describe('Lottery', () => {
   it('lottery provably fair', () => {
-    const lotterySeeds = [
-      {
-        seed: '7068df16f5ed60bd856c956df8437504ddc8a14e301201f08cb2d9c8457f57dd',
-        btcBlockHash: '90d543f6352a959285472a3b5a259513c38bb0baa5af3a28e59a759983da1cb2',
-        results: [51, 48, 37, 29, 49, 7],
-      },
-      {
-        seed: '9b437ae3c72373f0d07db77fa8784ba9df669b9aaf6fb2867683d1ca6aba149b',
-        btcBlockHash: '780f71593352440989e65a4a752ae8a6ee73c940206a5608ff5a0fcd719db437',
-        results: [43, 46, 35, 44, 1, 13],
-      },
-      {
-        seed: '1b42b3477981fc3bfbcedc4fbe598b2938aeb5564371be115911f18b2f781922',
-        btcBlockHash: 'c66271152aa3869660c109a16ddf2e3cb45379a237d2f8d4e3cc0d888a833b79',
-        results: [49, 28, 12, 10, 30, 6],
-      },
-      {
-        seed: 'f77706a9561669febcf626adc0cbeb8ed0bffce0a26918deb4d5bacbd840545f',
-        btcBlockHash: '2178204156e99463104b3fdaa5149156939cf8c168b354407d804173b2c64c76',
-        results: [2, 40, 32, 9, 18, 10],
-      },
-      {
-        seed: '559ac610caf66e960f8c3396a85cf9258bb14015e40b0649920ab772d4748d5b',
-        btcBlockHash: 'e99de92f4da4c38d9978324ddbf3ab4134ea9f1e3ae288d6fa69fdfbc8bef894',
-        results: [44, 23, 18, 10, 6, 17],
-      },
-      {
-        seed: '6fbe8a32f2c2f5c67af615c2f50e85cfea5a304fd7d5eaef882e994cdad23d1c',
-        btcBlockHash: '18b761483323262626ed5cca932db1f9e268b93654204b189757d8cde888f2b6',
-        results: [51, 12, 17, 11, 24, 1],
-      },
-      {
-        seed: '44ca0c4d384b60fb593d63ca59ee85222a33dfa10da7847d241860fee32bed35',
-        btcBlockHash: '5b15290eda6e2a880f8c8797161887055b13f608aeb7cfc8cba4d44e1167f516',
-        results: [47, 45, 33, 43, 29, 8],
-      },
-      {
-        seed: '2762358b55a0e7a9b29cbf69c1578d9e5697d95f605d583f2d05b71e25cf5523',
-        btcBlockHash: 'cba1653303bf96ac3986f5a956f56b029af1950a30cce2407f0e2dca89898433',
-        results: [10, 38, 5, 18, 30, 12],
-      },
-      {
-        seed: '279340242134b1b5f4fac74b9334ddbacba0c9fc2a48cab4ebc40378193a2def',
-        btcBlockHash: 'd99ba049066e67852ccbbd4f78144b8c2f93326a8da707a596ba3ea87df67389',
-        results: [11, 21, 17, 2, 40, 8],
-      },
-      {
-        seed: '7b5912894dd7d4cae1dc0d20ae326b6d66dfe3a1b5654c76c3569cbb92d378d6',
-        btcBlockHash: '0a0984225605f3756e8f510476389e0bb9d61afefc4bd58438763dcb53b5e7dc',
-        results: [41, 31, 47, 40, 55, 15],
-      },
-    ];
+    const lotterySeeds: Record<LotteryVersion, { seed: string; btcBlockHash: string; results: number[] }[]> = {
+      [LotteryVersion.V1]: [
+        {
+          seed: '7068df16f5ed60bd856c956df8437504ddc8a14e301201f08cb2d9c8457f57dd',
+          btcBlockHash: '90d543f6352a959285472a3b5a259513c38bb0baa5af3a28e59a759983da1cb2',
+          results: [51, 48, 37, 29, 49, 7],
+        },
+        {
+          seed: 'f77706a9561669febcf626adc0cbeb8ed0bffce0a26918deb4d5bacbd840545f',
+          btcBlockHash: '2178204156e99463104b3fdaa5149156939cf8c168b354407d804173b2c64c76',
+          results: [2, 40, 32, 9, 18, 10],
+        },
+        {
+          seed: '44ca0c4d384b60fb593d63ca59ee85222a33dfa10da7847d241860fee32bed35',
+          btcBlockHash: '5b15290eda6e2a880f8c8797161887055b13f608aeb7cfc8cba4d44e1167f516',
+          results: [47, 45, 33, 43, 29, 8],
+        },
+        {
+          seed: '7b5912894dd7d4cae1dc0d20ae326b6d66dfe3a1b5654c76c3569cbb92d378d6',
+          btcBlockHash: '0a0984225605f3756e8f510476389e0bb9d61afefc4bd58438763dcb53b5e7dc',
+          results: [41, 31, 47, 40, 55, 15],
+        },
+      ],
+      [LotteryVersion.V2]: [
+        {
+          seed: '7068df16f5ed60bd856c956df8437504ddc8a14e301201f08cb2d9c8457f57dd',
+          btcBlockHash: '90d543f6352a959285472a3b5a259513c38bb0baa5af3a28e59a759983da1cb2',
+          results: [71, 37, 55, 66, 56, 7],
+        },
+        {
+          seed: '9b437ae3c72373f0d07db77fa8784ba9df669b9aaf6fb2867683d1ca6aba149b',
+          btcBlockHash: '780f71593352440989e65a4a752ae8a6ee73c940206a5608ff5a0fcd719db437',
+          results: [51, 50, 65, 56, 10, 13],
+        },
+        {
+          seed: '1b42b3477981fc3bfbcedc4fbe598b2938aeb5564371be115911f18b2f781922',
+          btcBlockHash: 'c66271152aa3869660c109a16ddf2e3cb45379a237d2f8d4e3cc0d888a833b79',
+          results: [58, 69, 28, 27, 2, 6],
+        },
+        {
+          seed: 'f77706a9561669febcf626adc0cbeb8ed0bffce0a26918deb4d5bacbd840545f',
+          btcBlockHash: '2178204156e99463104b3fdaa5149156939cf8c168b354407d804173b2c64c76',
+          results: [34, 63, 58, 19, 41, 10],
+        },
+      ],
+    };
 
-    lotterySeeds.forEach(e => {
-      const hexToStr = createHmac('sha256', e.seed).update(e.btcBlockHash).digest('hex');
-      const results = Lottery.generateBalls(hexToStr);
-      expect(results).toEqual(e.results);
+    Object.values(LotteryVersion).forEach(ver => {
+      lotterySeeds[ver].forEach(e => {
+        const hexToStr = createHmac('sha256', e.seed).update(e.btcBlockHash).digest('hex');
+        const results = Lottery.generateBalls(ver, hexToStr);
+        expect(results).toEqual(e.results);
+      });
     });
   });
 
-  it('lottery balls check', () => {
-    const allResults: number[][] = [];
-    for (let i = 0; i < 5; i++) {
-      const { results } = generateSeedAndHashes();
-      allResults.push(results);
-    }
-
-    allResults.forEach(results => {
-      const primaryBalls = results.slice(0, 5);
-      const powerBall = results[5];
+  it('lottery config check', () => {
+    // DO NOT CHANGE THIS NUMBERS
+    const lotteryConfigs: Record<LotteryVersion, { maxPrimaryBall: number; maxPowerBall: number; primaryBallCount: number }> = {
+      [LotteryVersion.V1]: { maxPrimaryBall: 55, maxPowerBall: 18, primaryBallCount: 5 },
+      [LotteryVersion.V2]: { maxPrimaryBall: 74, maxPowerBall: 18, primaryBallCount: 5 },
+    };
 
-      expect(primaryBalls.filter(ball => ball < 1 || ball > LOTTERY_PRIMARY_BALL_MAX_NUMBER).length).toBe(0);
-      expect(new Set(primaryBalls).size).toBe(primaryBalls.length);
-      expect(powerBall <= LOTTERY_POWER_BALL_MAX_NUMBER && powerBall > 0).toBe(true);
+    Object.values(LotteryVersion).forEach(ver => {
+      const config = lotteryConfigs[ver];
+      expect(Lottery.getConfig(ver)).toMatchObject({
+        maxPrimaryBall: config.maxPrimaryBall,
+        maxPowerBall: config.maxPowerBall,
+        primaryBallCount: config.primaryBallCount,
+      });
     });
   });
 
-  it('lottery random ball generator check', () => {
-    const checkBalls = (ticketData: number[][]) => {
-      const endIndex = LOTTERY_PRIMARY_BALL_COUNT;
-      const betterSet = new Uint8Array(LOTTERY_PRIMARY_BALL_MAX_NUMBER + 1);
+  for (const version of Object.values(LotteryVersion)) {
+    it(`(${version}) lottery balls check`, () => {
+      const allResults: number[][] = [];
+      for (let i = 0; i < 5; i++) {
+        const { results } = generateSeedAndHashes(version);
+        allResults.push(results);
+      }
+
+      const config = Lottery.getConfig(version);
+      allResults.forEach(results => {
+        const primaryBalls = results.slice(0, config.primaryBallCount);
+        const powerBall = results[config.primaryBallCount];
+
+        expect(primaryBalls.filter(ball => ball < 1 || ball > config.maxPrimaryBall).length).toBe(0);
+        expect(new Set(primaryBalls).size).toBe(primaryBalls.length);
+        expect(powerBall <= config.maxPowerBall && powerBall > 0).toBe(true);
+      });
+    });
 
-      for (let i = 0; i < ticketData.length; i++) {
-        const ticket = ticketData[i];
+    it(`(${version}) lottery random ball generator check`, () => {
+      const config = Lottery.getConfig(version);
 
-        if (ticket.length !== LOTTERY_PRIMARY_BALL_COUNT + 1) return 'INVALID_AMOUNT_OF_BALLS';
+      const checkBalls = (ticketData: number[][]) => {
+        const endIndex = config.primaryBallCount;
+        const betterSet = new Uint8Array(config.maxPrimaryBall + 1);
 
-        const powerball = ticket[endIndex];
-        if (powerball < 1 || powerball > LOTTERY_POWER_BALL_MAX_NUMBER) return 'INVALID_POWERBALL';
+        for (let i = 0; i < ticketData.length; i++) {
+          const ticket = ticketData[i];
 
-        betterSet.fill(0);
-        for (let j = 0; j < endIndex; j++) {
-          const ball = ticket[j];
-          if (ball < 1 || ball > LOTTERY_PRIMARY_BALL_MAX_NUMBER || betterSet[ball]) return 'INVALID_PRIMARY_BALL';
-          betterSet[ball] = 1;
+          if (ticket.length !== config.primaryBallCount + 1) return 'INVALID_AMOUNT_OF_BALLS';
+
+          const powerball = ticket[endIndex];
+          if (powerball < 1 || powerball > config.maxPowerBall) return 'INVALID_POWERBALL';
+
+          betterSet.fill(0);
+          for (let j = 0; j < endIndex; j++) {
+            const ball = ticket[j];
+            if (ball < 1 || ball > config.maxPrimaryBall || betterSet[ball]) return 'INVALID_PRIMARY_BALL';
+            betterSet[ball] = 1;
+          }
         }
-      }
-      return 'VALID';
-    };
+        return 'VALID';
+      };
 
-    const ticketData = Lottery.batchGenerateTicketNumbers(1000_000);
-    expect(checkBalls(ticketData)).toEqual('VALID');
-  });
+      const ticketData = Lottery.batchGenerateTicketNumbers(version, 1000_000);
+      expect(checkBalls(ticketData)).toEqual('VALID');
+    });
+  }
 });
-
-function generateSeedAndHashes() {
-  const seed = randomBytes(32).toString('hex');
-  const btcBlockHash = randomBytes(32).toString('hex');
-  return {
-    seed,
-    btcBlockHash,
-    results: Lottery.generateBalls(createHmac('sha256', seed).update(btcBlockHash).digest('hex')),
-  };
-}

package/src/lottery/lottery.ts

@@ -1,67 +1,63 @@
 import { fisherYatesShuffle } from '../utils/fisher-yates-shuffle';
 
-export const LOTTERY_PRIMARY_BALL_MAX_NUMBER = 55;
-export const LOTTERY_POWER_BALL_MAX_NUMBER = 18;
-export const LOTTERY_PRIMARY_BALL_COUNT = 5;
+export enum LotteryVersion {
+  V1 = 'V1',
+  V2 = 'V2',
+}
+
+type LotteryConfig = {
+  maxPrimaryBall: number;
+  maxPowerBall: number;
+  primaryBallCount: number;
+};
+
+export const LOTTERY_VERSION_RECORD: Record<LotteryVersion, LotteryConfig> = {
+  [LotteryVersion.V1]: { maxPrimaryBall: 55, maxPowerBall: 18, primaryBallCount: 5 },
+  [LotteryVersion.V2]: { maxPrimaryBall: 74, maxPowerBall: 18, primaryBallCount: 5 },
+};
 
 export class Lottery {
-  static generateBalls(hexStr: string) {
+  static readonly version = LotteryVersion.V2;
+
+  static getConfig(version: LotteryVersion): LotteryConfig {
+    return LOTTERY_VERSION_RECORD[version];
+  }
+
+  static generateBalls(version: LotteryVersion, hexStr: string) {
     const hashed = Buffer.from(hexStr, 'hex');
 
+    const config = this.getConfig(version);
     const shuffledPrimaryBalls = this.shuffleBalls(
-      Array.from({ length: LOTTERY_PRIMARY_BALL_MAX_NUMBER }, (_, i) => i + 1),
+      Array.from({ length: config.maxPrimaryBall }, (_, i) => i + 1),
       hashed,
     );
 
     const shuffledPowerBalls = this.shuffleBalls(
-      Array.from({ length: LOTTERY_POWER_BALL_MAX_NUMBER }, (_, i) => i + 1),
+      Array.from({ length: config.maxPowerBall }, (_, i) => i + 1),
       hashed,
     );
 
     return [...shuffledPrimaryBalls.slice(0, 5), shuffledPowerBalls[0]];
   }
 
-  static shuffleBalls(balls: number[], hashBuffer: Buffer) {
-    return fisherYatesShuffle(balls, hashBuffer);
-  }
-
-  static generateRandomBalls() {
+  static generateRandomBalls(version: LotteryVersion) {
     const primaryBalls: Set<number> = new Set();
-    while (primaryBalls.size < LOTTERY_PRIMARY_BALL_COUNT) {
-      const randomNumber = Math.floor(Math.random() * LOTTERY_PRIMARY_BALL_MAX_NUMBER) + 1;
+    const config = this.getConfig(version);
+    while (primaryBalls.size < config.primaryBallCount) {
+      const randomNumber = Math.floor(Math.random() * config.maxPrimaryBall) + 1;
       primaryBalls.add(randomNumber);
     }
 
-    const powerball = Math.floor(Math.random() * LOTTERY_POWER_BALL_MAX_NUMBER) + 1;
+    const powerball = Math.floor(Math.random() * config.maxPowerBall) + 1;
 
     return [...Array.from(primaryBalls), powerball];
   }
 
-  static batchGenerateTicketNumbers(count: number) {
-    return Array.from({ length: count }, () => this.generateRandomBalls());
+  static batchGenerateTicketNumbers(version: LotteryVersion, count: number) {
+    return Array.from({ length: count }, () => this.generateRandomBalls(version));
   }
 
-  static validateTicketNumbers({ ticketData, hasPowerBall }: { ticketData: number[][]; hasPowerBall: boolean }) {
-    const endIndex = LOTTERY_PRIMARY_BALL_COUNT;
-    const betterSet = new Uint8Array(LOTTERY_PRIMARY_BALL_MAX_NUMBER + 1);
-
-    for (let i = 0; i < ticketData.length; i++) {
-      const ticket = ticketData[i];
-
-      if (ticket.length !== LOTTERY_PRIMARY_BALL_COUNT + (hasPowerBall ? 1 : 0)) return false;
-
-      if (hasPowerBall) {
-        const powerball = ticket[endIndex];
-        if (powerball < 1 || powerball > LOTTERY_POWER_BALL_MAX_NUMBER) return false;
-      }
-
-      betterSet.fill(0);
-      for (let j = 0; j < endIndex; j++) {
-        const ball = ticket[j];
-        if (ball < 1 || ball > LOTTERY_PRIMARY_BALL_MAX_NUMBER || betterSet[ball]) return false;
-        betterSet[ball] = 1;
-      }
-    }
-    return true;
+  static shuffleBalls(balls: number[], hashBuffer: Buffer) {
+    return fisherYatesShuffle(balls, hashBuffer);
   }
 }

package/src/regex/index.ts

@@ -23,3 +23,12 @@ export const VALID_NAME_REGEX = /^[^0-9!@#$%^&*`~()+=[{\]};:"\\|<>\/?]*$/;
 // U+1160 Hangul Jungseong Filler, U+3164 Hangul Filler
 export const NO_INVISIBLE_CHAR_REGEX = /^[^\u2800\uFFA0\u115F\u1160\u3164]*$/;
 export const US_PHONE_NUMBER_REGEX = /^\+1\d{10}$/;
+// E.164 international phone number: leading +, first digit 1-9, total 7-15 digits
+export const E164_PHONE_NUMBER_REGEX = /^\+[1-9]\d{6,14}$/;
+// Brazilian CPF (digits only, no formatting)
+export const CPF_REGEX = /^\d{11}$/;
+// Mexican CURP (18 alphanumeric chars)
+export const CURP_REGEX = /^[A-Z0-9]{18}$/i;
+// Argentine CUIL/CUIT: 11 digits, no formatting, leading with a valid person/entity
+// prefix (20-27 individuals, 30/33/34 legal entities)
+export const CUIL_CUIT_REGEX = /^(20|23|24|25|26|27|30|33|34)\d{9}$/;

package/src/regex/regex.spec.ts

@@ -1,16 +1,36 @@
 import {
+  ADDRESS_URL_REGEX,
+  CUIL_CUIT_REGEX,
   HEX_COLOR_CODE_REGEX,
+  NO_INVISIBLE_CHAR_REGEX,
   PROMOTION_CODE_REGEX,
   PWD_REGEX,
-  USERNAME_REGEX,
   TXN_URL_REGEX,
-  ADDRESS_URL_REGEX,
-  VALID_NAME_REGEX,
+  USERNAME_REGEX,
   US_PHONE_NUMBER_REGEX,
-  NO_INVISIBLE_CHAR_REGEX,
+  VALID_NAME_REGEX,
 } from '.';
 
 describe('regex', () => {
+  describe('CUIL_CUIT_REGEX', () => {
+    it('accepts 11 digits with a valid individual or entity prefix', () => {
+      expect(CUIL_CUIT_REGEX.test('20123456789')).toBe(true);
+      expect(CUIL_CUIT_REGEX.test('27123456789')).toBe(true);
+      expect(CUIL_CUIT_REGEX.test('30123456789')).toBe(true);
+    });
+
+    it('rejects an invalid leading prefix', () => {
+      expect(CUIL_CUIT_REGEX.test('19123456789')).toBe(false);
+      expect(CUIL_CUIT_REGEX.test('28123456789')).toBe(false);
+    });
+
+    it('rejects wrong length or non-digits', () => {
+      expect(CUIL_CUIT_REGEX.test('2012345678')).toBe(false); // 10 digits
+      expect(CUIL_CUIT_REGEX.test('201234567890')).toBe(false); // 12 digits
+      expect(CUIL_CUIT_REGEX.test('20-12345678-9')).toBe(false); // formatted
+    });
+  });
+
   describe('PWD_REGEX', () => {
     it('should not allow passwords with less than 8 characters', () => {
       expect(PWD_REGEX.test('abcdef1')).toBe(false);