Provably Fair

Crash Game Formula

// Generate crash point from hash
function getCrashPoint(hash) {
  const h = parseInt(hash.slice(0, 8), 16);
  const e = Math.pow(2, 32);
  const result = Math.max(1,
    Math.floor((0.97 * e) / (e - h) * 100) / 100);
  return result;
}

Hash Chain

Game results are generated using a hash chain. Starting from a final hash, each previous hash is the SHA-256 of the next. This means all future results are pre-determined but cannot be predicted without knowing the unhashed seeds.

Verification Code

const crypto = require('crypto');

function verify(serverSeed, clientSeed, nonce) {
  const hmac = crypto.createHmac('sha256', serverSeed);
  hmac.update(clientSeed + ':' + nonce);
  const hash = hmac.digest('hex');
  return getCrashPoint(hash);
}

Crash

The crash game uses a hash chain where each round's hash is the SHA-256 of the previous round's hash, creating a pre-determined sequence that can be verified after the seed is revealed. The crash point is computed from the first 8 hex characters of the round hash:

1. Parse the first 8 hex characters as a 32-bit unsigned integer h
2. Compute: crashPoint = max(1, floor(0.97 * 2^32 / (2^32 - h) * 100) / 100)
3. The 0.97 factor represents the 3% house edge
4. Approximately 3% of rounds crash at exactly 1.00x (instant crash)

Coinflip

Each coinflip generates a fresh server seed and combines it with the client seed via HMAC-SHA256.

1. Generate a 32-byte server seed using crypto.randomBytes(32)
2. Compute HMAC-SHA256 of clientSeed:nonce with the server seed as key
3. Take the first byte of the HMAC result (value 0-255)
4. If the byte value is < 125 (48.83% probability), the player wins at 2x payout
5. House edge: 1 - (125/256 * 2) = ~2.34%

Dice

Dice allows players to choose a target number and direction (over/under), with dynamic payouts based on win probability.

1. Generate HMAC-SHA256 as with coinflip
2. Read the first 4 bytes as a 32-bit unsigned integer
3. Roll = (value % 10000) / 100, yielding 0.00 to 99.99
4. Win chance depends on the chosen target and direction
5. Payout multiplier = 97 / winChance (the 3% gap from 100 is the house edge)

Mines

Mines uses a 25-tile grid with a configurable number of mines (1-24). Mine positions are determined before the game begins.

1. Generate HMAC-SHA256 from server seed, client seed, and nonce
2. Use 2-byte segments of the HMAC to determine mine positions on the 5x5 grid
3. Each gem reveal increases the multiplier based on the formula: product of (remaining / safe) for each revealed gem, times 0.97
4. The 0.97 factor provides a 3% house edge
5. All mine positions are committed before the first tile is revealed and can be verified after the round

Blackjack

Blackjack uses a standard 52-card deck shuffled with a cryptographically secure Fisher-Yates shuffle.

1. A 52-card deck is created and shuffled using crypto.randomBytes(4) for each swap in the Fisher-Yates algorithm
2. A seed hash is generated and stored with the session for later verification
3. Standard blackjack rules: natural blackjack pays 3:2, dealer stands on all 17s
4. Players can hit, stand, or double down (on initial two cards only)
5. Up to 3 seats per session
6. House edge is approximately 0.5% with optimal basic strategy