shufflecom-calculations 4.2.3 → 4.2.5

package/src/games/roulette.spec.ts

@@ -20,6 +20,7 @@ import {
   isValidSplit,
   isValidStreet,
   parityPayout,
+  RouletteInput,
   splitPayout,
   straightPayout,
   straightValue,
@@ -35,7 +36,7 @@ function arrayEquals<T>(arr1: T, arr2: T) {
 describe('Roulette', () => {
   it('getResult should return 0-36 inclusive', () => {
     const hexStrArr = generateDigestHex({ serverSeed: 'test', clientSeed: 'test', nonce: '0', rounds: 100000 });
-    const results = hexStrArr.map((hexStr) => Roulette.getResult(hexStr));
+    const results = hexStrArr.map(hexStr => Roulette.getResult(hexStr));
     const uniqueResults = [...new Set(results)].sort((a, b) => a - b) as readonly straightValue[];
     arrayEquals(uniqueResults, STRAIGHT_VALUES);
   });
@@ -500,6 +501,25 @@ describe('Roulette', () => {
   });
 });
 
+describe('Roulette.getMaxPayout', () => {
+  it('returns the maximum payout across all 37 wheel results', () => {
+    const inputs = {
+      parityValues: [],
+      colorValues: [],
+      halfValues: [],
+      columnValues: [],
+      dozenValues: [],
+      straightValues: [{ straightNumber: 7, amount: new BigNumber(1) }],
+      splitValues: [],
+      streetValues: [],
+      cornerValues: [],
+      doubleStreetValues: [],
+    } as RouletteInput;
+    const max = Roulette.getMaxPayout(inputs);
+    expect(max.toNumber()).toBe(36);
+  });
+});
+
 function generateDigestHex({
   serverSeed,
   clientSeed,
@@ -511,7 +531,7 @@ function generateDigestHex({
   nonce: string;
   rounds?: number;
 }): string[] {
-  const results = Array.from(Array(rounds).keys()).map((round) => {
+  const results = Array.from(Array(rounds).keys()).map(round => {
     const hmac = createHmac('sha256', serverSeed);
     hmac.update(`${clientSeed}:${nonce}:${round}`);
     return hmac.digest('hex');

package/src/games/roulette.ts

@@ -416,6 +416,10 @@ export class Roulette {
     return resultNum;
   }
 
+  static getMaxPayout(inputs: RouletteInput): BigNumber {
+    return BigNumber.max(...STRAIGHT_VALUES.map(result => Roulette.getPayout(inputs, result)));
+  }
+
   static getPayout(inputs: RouletteInput, result: straightValue): BigNumber {
     if (!this.validateInputs(inputs)) {
       throw new Error('Invalid inputs');

package/src/games/wheel.spec.ts

@@ -127,6 +127,15 @@ describe('Wheel', () => {
   });
 });
 
+describe('Wheel.getMaxMultiplier', () => {
+  it('returns the largest multiplier in the segment/risk table', () => {
+    const max = Wheel.getMaxMultiplier(WheelSegments.TEN, WheelRiskLevel.HIGH);
+    // HIGH risk always includes the top multiplier; must be > any other entry.
+    expect(max.isGreaterThan(0)).toBe(true);
+    expect(max.toNumber()).toBe(Math.max(...WHEEL_MULTIPLIERS[WheelSegments.TEN][WheelRiskLevel.HIGH]));
+  });
+});
+
 function generateDigestHex({
   serverSeed,
   clientSeed,

package/src/games/wheel.ts

@@ -70,6 +70,10 @@ export const WHEEL_SEGMENTS_TO_NUMBER: Record<WheelSegments, number> = {
 };
 
 export class Wheel {
+  static getMaxMultiplier(segments: WheelSegments, risk: WheelRiskLevel): BigNumber {
+    return BigNumber.max(...WHEEL_MULTIPLIERS[segments][risk].map(v => new BigNumber(v)));
+  }
+
   static getResult(hexStr: string, segments: WheelSegments, risk: WheelRiskLevel): { resultSegment: number; multiplier: BigNumber } {
     const resultSegment = this.getRandomNumberFromHexStr(hexStr).multipliedBy(WHEEL_SEGMENTS_TO_NUMBER[segments]).integerValue(BigNumber.ROUND_DOWN).toNumber();
     const multiplier = BigNumber(WHEEL_MULTIPLIERS[segments][risk][resultSegment]);

package/src/utils/getExternalTxLinkOfChain.ts

@@ -31,7 +31,7 @@ export const TX_LINK_PREFIXES_MAINNET: Record<Chain, string> = {
   [Chain.AVAXC]: 'https://snowtrace.io/tx/{txId}',
   [Chain.ARBITRUM]: 'https://arbiscan.io/tx/{txId}',
   [Chain.BASE]: 'https://basescan.org/tx/{txId}',
-  [Chain.RHC]: 'https://robinhoodchain.blockscout.com/{txId}',
+  [Chain.RHC]: 'https://robinhoodchain.blockscout.com/tx/{txId}',
 };
 
 export const ADDRESS_LINK_PREFIXES_TESTNET: Record<Chain, string> = {