Blackjack

Chicken Cross

Dice

Hilo

Keno

Limbo

Mines

Moles

Plinko

Rock Paper Scissors

Roulette

Tower

Wheel

import { createHmac } from 'crypto';
import Decimal from 'decimal.js';

const UINT32_MAX = 0x100000000; // 2^32

/**
 * Generates an infinite deterministic stream of cryptographically secure
 * 32-bit unsigned integers derived from HMAC-SHA256.
 *
 * @param key - Secret cryptographic key (server seed). Must remain private until revealed.
 * @param message - Public input string (e.g., client seed, nonce, or domain label).
 *
 * @remarks
 * - Uses HMAC-SHA256 as a pseudorandom function (PRF) to produce a reproducible
 *   and verifiable sequence of numbers.
 * - `step` ensures each 32-bit block is derived from a unique input.
 * - Output is split into 32-bit chunks, suitable for unbiased integer or bit-level
 *   extraction.
 * - Bits are consumed starting from the Most Significant Bit (MSB) to preserve
 *   full numeric precision and maximum entropy.
 * - Fully deterministic: anyone with the same key and message can verify the results.
 */
function* getUint32Stream(key: string, message: string): Iterator<number> {
  let step = 0;

  while (true) {
    const hmac = createHmac('sha256', key);
    hmac.update(`${message}:${step}`);
    const hash = hmac.digest(); // 32 bytes (256 bits)

    for (let i = 0; i < hash.length; i += 4) {
      yield (
        (hash[i] << 24) |
        (hash[i + 1] << 16) |
        (hash[i + 2] << 8) |
        hash[i + 3]
      ) >>> 0; // force unsigned 32-bit
    }

    step++;
  }
}

const survivalMultiplier = (options: {
  total: number;
  safe: number;
  rounds: number;
  houseEdge: number;
}) => {
  const combination = (n: number, r: number) => {
    const k = Math.min(r, n - r);
    let result = new Decimal(1);

    for (let i = 1; i <= k; i++) {
      result = result.mul(n - k + i).div(i);
    }

    return result;
  };

  const { total, safe, rounds, houseEdge } = options;

  const probability = combination(safe, rounds).div(combination(total, rounds));

  return new Decimal(1)
    .minus(houseEdge)
    .div(probability)
    .toDecimalPlaces(2, Decimal.ROUND_HALF_UP)
    .toString();
};


function determineResult(options: {
  difficulty: "easy" | "medium" | "hard" | "expert";
  round: number;
  serverSeed: string;
  clientSeed: string;
  nonce: number;
}) {
  const chickenCrossConfig = {
    easy: {
      get maxRounds() {
        return 24;
      },
      difficultyFactor: 1,
    },
    medium: {
      get maxRounds() {
        return 22;
      },
      difficultyFactor: 3,
    },
    hard: {
      get maxRounds() {
        return 20;
      },
      difficultyFactor: 5,
    },
    expert: {
      get maxRounds() {
        return 15;
      },
      difficultyFactor: 10,
    },
  };

  const { difficultyFactor, maxRounds } = chickenCrossConfig[options.difficulty];

  const stream = getUint32Stream(
    options.serverSeed,
    `${options.clientSeed}:${options.nonce}:chicken-cross`
  );

  const value = stream.next().value;

  if (value === undefined) {
    throw new Error('Failed to generate random value');
  }

  const fairValue = new Decimal(value).plus(1);

  const ev = 4;
  const rtp = new Decimal(100).minus(ev).div(100);

  const hiddenMultiplier = new Decimal(UINT32_MAX).div(fairValue).mul(rtp);

  const roundMultiplier = survivalMultiplier({
    total: difficultyFactor + maxRounds,
    safe: maxRounds,
    rounds: options.round,
    houseEdge: new Decimal(ev).div(100).toNumber(),
  });

  const isWin = hiddenMultiplier.greaterThanOrEqualTo(roundMultiplier);

  return {
    multiplier: isWin ? Number(roundMultiplier) : 0,
    winPercentage: new Decimal(100)
      .minus(ev)
      .div(roundMultiplier)
      .toDecimalPlaces(4, Decimal.ROUND_FLOOR)
      .toString(),
  };
}

console.log(
  determineResult({
    difficulty: 'easy',
    clientSeed: 'chicken-cross-test',
    serverSeed: 'chicken-cross-test',
    round: 1,
    nonce: 0,
  })
)


chicken-cross_provably_fair_explanation_v2

import { createHmac } from "crypto";
import Decimal from "decimal.js";

interface ChickenCrossSegment {
maxRounds: number;
roundMultiplier: (round: number) => number;
}

const CHICKEN_CROSS_HOUSE_EDGE = 4;
const CHICKEN_CROSS_MAX_ROUNDS = 25;

const ChickenCrossDifficulty = {
Easy: 'easy',
Medium: 'medium',
Hard: 'hard',
Expert: 'expert',
} as const;

export type ChickenCrossDifficulty =
  (typeof ChickenCrossDifficulty)[keyof typeof ChickenCrossDifficulty];

function\* getBytesChunks(
serverSeed: string,
clientSeed: string,
nonce: number | string
): Generator<number[]> {
let step = 0;
let counter = 0;

while (true) {
const hmac = createHmac('sha512', serverSeed);
hmac.update(`${clientSeed}:${nonce}:${step}`);
const hashValue = hmac.digest('hex');

    while (counter < 16) {
      const hashBytes: number[] = [];

      for (let i = 0; i < 4; i++) {
        hashBytes.push(
          parseInt(
            hashValue.substring(i * 2 + counter * 8, i * 2 + 2 + counter * 8),
            16
          )
        );
      }

      yield hashBytes;
      counter += 1;
    }

    counter = 0;
    step += 1;

}
}

const getFloats = (
serverSeed: string,
clientSeed: string,
nonce: number | string,
count: number
) => {
const bytes = getBytesChunks(serverSeed, clientSeed, nonce);
const ints: number[][] = [];

while (ints.length < count) {
const nextValue = bytes.next().value;
if (nextValue) {
ints.push(nextValue);
}
}

return ints.map((bytesArray) =>
bytesArray.reduce((acc, value, i) => acc + value / 256 \*\* (i + 1), 0)
);
}

const getFairValue = ({
clientSeed,
serverSeed,
nonceUsed,
round,
}: {
clientSeed: string;
serverSeed: string;
nonceUsed: number;
round: number | string;
}) => {
const floats = getFloats(serverSeed, clientSeed, `${nonceUsed}:${round}`, 1);

const fairValue = floats[0];

if (fairValue == null) {
throw new Error('Failed to generate provably fair value');
}

return fairValue;
};

const multiplierFormula = (options: {
difficultyFactor: number;
round: number;
}) => {
let multiplier = new Decimal(1);

const difficultyFactor = Decimal(
CHICKEN_CROSS_MAX_ROUNDS - options.difficultyFactor
);

for (let roundIndex = 0; roundIndex < options.round; roundIndex++) {
multiplier = multiplier.mul(
difficultyFactor
.minus(roundIndex)
.dividedBy(CHICKEN_CROSS_MAX_ROUNDS - roundIndex)
);
}

const chancePercent = multiplier.mul(100);

const finalMultiplier = new Decimal(100)
.minus(CHICKEN_CROSS_HOUSE_EDGE)
.dividedBy(chancePercent);

return finalMultiplier
.toDecimalPlaces(2, Decimal.ROUND_HALF_UP)
.toNumber();
};

const CHICKEN_CROSS_CONFIGS: Record<
ChickenCrossDifficulty,
ChickenCrossSegment

> = {
> [ChickenCrossDifficulty.Easy]: {

    get maxRounds() {
      return 24;
    },
    roundMultiplier(round: number) {
      return multiplierFormula({
        round,
        difficultyFactor: 1,
      });
    },

},
[ChickenCrossDifficulty.Medium]: {
get maxRounds() {
return 22;
},
roundMultiplier(round: number) {
return multiplierFormula({
round,
difficultyFactor: 3,
});
},
},
[ChickenCrossDifficulty.Hard]: {
get maxRounds() {
return 20;
},
roundMultiplier(round: number) {
return multiplierFormula({
round,
difficultyFactor: 5,
});
},
},
[ChickenCrossDifficulty.Expert]: {
get maxRounds() {
return 15;
},
roundMultiplier(round: number) {
return multiplierFormula({
round,
difficultyFactor: 10,
});
},
},
};

const determineMultiplierWinPercentage = (options: {
fairValue: number;
difficulty: ChickenCrossDifficulty;
round: number;
}) => {
const config = CHICKEN_CROSS_CONFIGS[options.difficulty];

const multiplier = config.roundMultiplier(options.round);

const winPercentage = (100 - CHICKEN_CROSS_HOUSE_EDGE) / multiplier;

// Scale the fair value (0-0.999...) to the total weight range
const targetPercentage = options.fairValue \* 100;

if (targetPercentage >= winPercentage) {
return 0
}

return multiplier;
}

const USER_INPUT_SERVER_SEED = 'SERVER_SEED';
const USER_INPUT_CLIENT_SEED = 'CLIENT_SEED';
const USER_INPUT_NONCE = 1;
const USER_INPUT_DIFFICULTY = 'easy' // "easy" | "medium" | "hard" | "expert";
const USER_INPUT_JUMP_COUNT = 21;

const fairValue = getFairValue({
serverSeed: USER_INPUT_SERVER_SEED,
clientSeed: USER_INPUT_CLIENT_SEED,
nonceUsed: USER_INPUT_NONCE,
round: 'chicken-cross',
});

const maxPossibleMultiplier = determineMultiplierWinPercentage(
{
fairValue,
difficulty: USER_INPUT_DIFFICULTY,
round: USER_INPUT_JUMP_COUNT,
}
);


chicken-cross_provably_fair_explanation_v1