shufflecom-calculations 1.1.6 → 1.2.1

package/src/games/hilo.ts

@@ -1,9 +1,10 @@
 import BigNumber from 'bignumber.js';
-import { calculateEdgeMultiplier, hexToBytes } from '../utils';
+import { calculateEdgeMultiplier } from '../utils';
+import { CardGames } from './cardGames';
 
-const BYTE_TOTAL = new BigNumber(256);
 const TOTAL_CARD = new BigNumber(13);
 
+// TODO: Remove the card detail stuff from here
 /**
  * For Ace card, since it's the lowest card,
  * - SAME_OR_ABOVE -> ABOVE
@@ -28,64 +29,15 @@ export enum Suits {
   CLUBS = 'CLUBS',
 }
 
-const suitsArr = [Suits.DIAMONDS, Suits.HEARTS, Suits.SPADES, Suits.CLUBS];
-
-const CARD_MAP: Record<string, string> = {
-  '1': 'A',
-  '11': 'J',
-  '12': 'Q',
-  '13': 'K',
-};
-
 export interface CardDetail {
   suit: Suits;
   value: string;
 }
 
 export class Hilo {
-  static getResult(hexStr: string, cardNo: number): number {
-    const bytePosition = cardNo % 8;
-    const bytes = hexToBytes(hexStr);
-    let result = new BigNumber(0);
-    for (let j = 0; j < 4; j++) {
-      const value = bytes[4 * bytePosition + j];
-      result = result.plus(new BigNumber(value).dividedBy(BYTE_TOTAL.pow(j + 1)));
-    }
-    return result.multipliedBy(52).integerValue(BigNumber.ROUND_FLOOR).toNumber();
-  }
-
-  static getResults(hexStr: string[]): number[] {
-    const results: number[] = [];
-    for (let i = 0; i < hexStr.length * 8; i++) {
-      const hexNo = Math.trunc(i / 8);
-      results.push(this.getResult(hexStr[hexNo], i));
-    }
-    return results;
-  }
-  // Index of 0 to 51 : ♦2 to ♣A
-  // [
-  // ♦2, ♥2, ♠2, ♣2, ♦3, ♥3, ♠3, ♣3, ♦4, ♥4,
-  // ♠4, ♣4, ♦5, ♥5, ♠5, ♣5, ♦6, ♥6, ♠6, ♣6,
-  // ♦7, ♥7, ♠7, ♣7, ♦8, ♥8, ♠8, ♣8, ♦9, ♥9,
-  // ♠9, ♣9, ♦10, ♥10, ♠10, ♣10, ♦J, ♥J, ♠J,
-  // ♣J, ♦Q, ♥Q, ♠Q, ♣Q, ♦K, ♥K, ♠K, ♣K, ♦A,
-  // ♥A, ♠A, ♣A
-  // ]
-
-  // A = 1, 2 = 2 ,...10 = 10, J = 11, Q = 12, K = 13
-  static toComparableNo(result: number) {
-    const comparableNo = Math.trunc(result / 4) + 2;
-
-    if (comparableNo === 14) {
-      return 1;
-    } else {
-      return comparableNo;
-    }
-  }
-
   static isGuessCorrect(previousCard: number, guess: HiloGuess, result: number) {
-    const previousCardValue = this.toComparableNo(previousCard);
-    const resultValue = this.toComparableNo(result);
+    const previousCardValue = CardGames.toComparableNo(previousCard);
+    const resultValue = CardGames.toComparableNo(result);
 
     if (guess === HiloGuess.SAME_OR_ABOVE) {
       // If previous card is Ace, then result must be above 1
@@ -141,7 +93,7 @@ export class Hilo {
 
   static calculateWinChanceBN(guess: HiloGuess, previousCard: number): BigNumber {
     let possibleOutcomes = new BigNumber(0);
-    const previousCardValue = this.toComparableNo(previousCard);
+    const previousCardValue = CardGames.toComparableNo(previousCard);
 
     if ((previousCardValue === 1 && guess === HiloGuess.SAME_OR_BELOW) || (previousCardValue === 13 && guess === HiloGuess.SAME_OR_ABOVE)) {
       possibleOutcomes = BigNumber(1);
@@ -155,18 +107,4 @@ export class Hilo {
 
     return possibleOutcomes.dividedBy(TOTAL_CARD);
   }
-
-  static getCardDetails(cardNum: number): CardDetail {
-    if (cardNum > 51 || cardNum < 0 || !Number.isInteger(cardNum)) {
-      throw 'out of bounds';
-    }
-    const suit = suitsArr[cardNum % 4];
-    let value = this.toComparableNo(cardNum).toString();
-
-    if (CARD_MAP[value]) {
-      value = CARD_MAP[value];
-    }
-
-    return { suit, value };
-  }
 }

package/src/index.ts

@@ -6,4 +6,14 @@ export { Plinko, PlinkoRiskLevel } from './games/plinko';
 export { Crash } from './games/crash';
 export { Limbo } from './games/limbo';
 export { Keno, KenoRiskLevel } from './games/keno';
-export { Hilo, HiloGuess, CardDetail, Suits } from './games/hilo';
+export { Hilo, HiloGuess } from './games/hilo';
+export { CardGames, CardDetail, CardValue, Suits, suitsArr } from './games/cardGames';
+export {
+  BlackjackAction,
+  Blackjack,
+  InsuranceStatus,
+  PerfectPairType,
+  TwentyOnePlusThreeType,
+  perfectPairPayout,
+  twentyOnePlusThreePayout,
+} from './games/blackjack';

package/src/utils/index.ts

@@ -5,3 +5,4 @@ export { ChatMessageType, ChatMessage } from './chat-message.type';
 export { DatesCalculator } from './dates-calculator';
 export { VipBonusIssuanceStatus } from './vip-bonus.type';
 export { deriveBonusIssuances } from './derive-vip-bonus';
+export { convertBs58ToUuid, convertUuidToBs58 } from './uuid-converter';

package/src/utils/uuid-converter.spec.ts

@@ -0,0 +1,21 @@
+import { convertBs58ToUuid, convertUuidToBs58 } from './uuid-converter';
+
+describe('uuid-converter', () => {
+  it('should convert uuid to bs58', () => {
+    const uuid = '0331056b-ed96-4103-9144-0384c1a2b039';
+    const bs58 = 'PrkNxyx43ECZUuxGAAbFn';
+
+    expect(convertUuidToBs58(uuid)).toEqual(bs58);
+    expect(convertBs58ToUuid(bs58)).toEqual(uuid);
+  });
+
+  it('should return invalid bs58 back if errors are silenced', () => {
+    const invalidBs58 = 'abcd!';
+    expect(convertBs58ToUuid(invalidBs58)).toEqual(invalidBs58);
+  });
+
+  it('should throw error for invalid bs58 back if errors are not silenced', () => {
+    const invalidBs58 = 'abcd!';
+    expect(() => convertBs58ToUuid(invalidBs58, false)).toThrow('Non-base58 character');
+  });
+});

package/src/utils/uuid-converter.ts

@@ -0,0 +1,32 @@
+import bs58 from 'bs58';
+
+const addUUIDDashes = (i: string) => `${i.substring(0, 8)}-${i.substring(8, 12)}-${i.substring(12, 16)}-${i.substring(16, 20)}-${i.substring(20)}`;
+
+export function convertUuidToBs58(uuidValue: string): string {
+  if (!uuidValue) {
+    return null;
+  }
+
+  const uuidWithoutDashes = uuidValue.replace(/-/g, '');
+
+  const buff = Buffer.from(uuidWithoutDashes, 'hex');
+
+  return bs58.encode(Uint8Array.from(buff));
+}
+
+export function convertBs58ToUuid(bs58Value: string, silenceErrors = true) {
+  try {
+    const bytes = bs58.decode(bs58Value);
+
+    const hexValue = Buffer.from(bytes).toString('hex');
+
+    return addUUIDDashes(hexValue);
+  } catch (e) {
+    if (silenceErrors) {
+      // If invalid just return normal value
+      return bs58Value;
+    } else {
+      throw e;
+    }
+  }
+}