Provably fair

Every round on Kingz Originals is random, and nobody, including us, can change the outcome after you place your bet. Here is how that is guaranteed, and how you check it yourself.

1
Before you play
We pick a random server seed and show you only its SHA-256 hash, so the seed is fixed before your first bet. You bring a client seed you can change at any time. A nonce counts the rounds played with that pair.
2
Every round
The result is HMAC-SHA256 of your client seed and nonce, keyed with the server seed, read as 32-bit numbers. Each game turns those numbers into tiles, a roll, a card or a reel stop in one fixed way, with no other input. Crash, played by everyone at once, swaps your client seed for a public drand beacon announced before bets close.
3
After you rotate
Rotating retires the pair and reveals the server seed. Hash it and compare with what you saw before playing, then recompute any round below or with the standalone code. It matches, every time.

How each game reads the numbers

Mines: HMAC-SHA256(server seed, clientSeed:nonce:cursor) read as 32-bit words with rejection sampling drives a Fisher-Yates shuffle of the tiles; the first N are the mines.
Plinko: One HMAC-SHA256(server seed, clientSeed:nonce:row) per row; the first 32-bit word mod 2 sends the ball left or right. The bucket is the number of right bounces; the risk level only picks the payout table.
Dice: HMAC-SHA256(server seed, clientSeed:nonce) read as 32-bit words; the first word below the largest multiple of 10001 (rejection sampling) mod 10001 is the roll, 0.00–100.00. The target and direction only decide win or lose.
Limbo: HMAC-SHA256(server seed, clientSeed:nonce); the first 32-bit word w gives the raw result max(1, floor(2³² ÷ (w + 1) × 10⁶) ÷ 10⁶). The house edge is applied to that result (rounded down to 6 decimals); you win when it still reaches your target, and the payout is bet × target.
Keno: Backward Fisher-Yates over the numbers 0…39: step i uses HMAC-SHA256(server seed, clientSeed:nonce:cursor) with cursor 39 − i, takes the first 32-bit word below 2³² − (2³² mod (i + 1)) and swaps position i with word mod (i + 1); a cursor only advances when all eight words of a digest are rejected. The first ten positions + 1 are the drawn numbers — your picks and the risk only decide the payout row.
Crash: Crash has no client seed: each shared round has its own server seed (hash published when bets open) and a public seed — the drand quicknet beacon signature announced two seconds before bets close and published after. HMAC-SHA256(server seed, publicSeed:0), first 32-bit word w, crash point = 2³² ÷ (w + 1) × (1 − edge), floored at 1.00× and shown truncated to 2 decimals. Bets and cash-outs never enter the hash.
Blackjack: One card per cursor: HMAC-SHA256(server seed, clientSeed:nonce:cursor), first 32-bit word below 52 × ⌊2³² ÷ 52⌋, modulo 52 → 2♦ 2♥ 2♠ 2♣ 3♦ … A♣ (an infinite deck — every card is an independent draw). Cursor 0 is your first card, 1 the dealer's up card, 2 your second, 3 the hole card; every further card follows in play order (hits, the double card, both second cards after a split, the dealer's draw). Your actions only decide how many cursors are used; the payout adds a commission on winnings that is shown on the game. Side bets read the same first three cards: Perfect Pairs = your two cards share a rank (same suit 26.73×, same colour 10.89×, mixed 6.93× at 1 %), 21+3 = your two + the dealer's up card as a poker hand (suited trips 120.02×, straight flush 52.47×, three of a kind 31.68×, straight 11.88×, flush 4.95×).
Maxwin: One HMAC-SHA256(server seed, clientSeed:nonce:reel) per reel — the same digest Plinko uses for a row — read as 32-bit words; the first word below 2³² − (2³² mod N) modulo N is where that reel stops on its N-position strip (a cursor only advances when all eight words are rejected). The letter at the stop sits on the payline; K·I·N·G·Z across all five is the only paying outcome and pays (1 − edge) ÷ P(all five). The tier only picks the strips.
Roulette: Rainbet's algorithm, bit for bit: HMAC-SHA256 with the server seed's TEXT (its UTF-8 bytes, not the decoded hex) as the key over clientSeed:nonce:roulette:step, read as eight 32-bit words; the first word below 2³² − (2³² mod 37) modulo 37 is the winning pocket (step advances only when all eight words are rejected). Bets and the house edge never enter the hash — the same three values give the same number on rainbet.com/provably-fair → Game Verifier → Roulette.
Baccarat: Rainbet's algorithm, bit for bit: HMAC-SHA256 with the server seed's TEXT (its UTF-8 bytes) as the key over clientSeed:nonce:baccarat:step, read as eight 32-bit words. A fresh eight-deck shoe (suit-major c d h s × A … K, eight times) is drawn lazily without replacement — each draw takes the first word below 2³² − (2³² mod remaining) modulo remaining, swaps that card with the last remaining one and deals it — in Punto Banco order: Player, Banker, Player, Banker, then the third cards the tableau asks for (Player draws on 0–5; Banker by the standard table). Bets and payouts never enter the hash — the same three values give the same hands on rainbet.com/provably-fair → Game Verifier → Baccarat.
Hilo: Stake's algorithm, bit for bit: HMAC-SHA256 with the server seed's TEXT as the key over clientSeed:nonce:round (round = 0, 1, 2, … every 32 bytes), each 4 bytes read as a float b0/256 + b1/256² + b2/256³ + b3/256⁴, card = floor(float × 52) into 2♦ 2♥ 2♠ 2♣ 3♦ … A♣ (every card an independent draw). Card 0 answers your first guess, every guess or skip takes the next one; the start card is yours and never enters the hash. Ace is low, King high; the round multiplier is (1 − edge) × 13/n per correct guess with the edge taken once — the same three values give the same cards on stake.com/provably-fair/calculation → Hilo.
Lion Tower: Stake's algorithm, bit for bit (their game name for it is Dragon Tower): HMAC-SHA256 with the server seed's TEXT as the key over clientSeed:nonce:round (round = 0, 1, 2, … every 32 bytes), each 4 bytes read as a float b0/256 + b1/256² + b2/256³ + b3/256⁴. For each of the nine rows, bottom to top, the safe tiles are drawn from the tiles still remaining — floor(float × remaining) picks one and removes it, as many draws as the difficulty has safe tiles per row (easy 3 of 4, medium 2 of 3, hard 1 of 2, expert 1 of 3, master 1 of 4). The whole tower is fixed when the bet is placed; the multiplier after k rows is (1 − edge) × (tiles ÷ safe)^k rounded to 2 decimals and paid as shown — the same three values and difficulty give the same rows on stake.com/provably-fair/calculation → Dragon Tower.
Goat: Duel's algorithm, bit for bit (their game name for it is Beef, internally Cross Road): HMAC-SHA256 with the server seed's BYTES as the key over clientSeed:nonce:cursor, a backward Fisher-Yates shuffle of the 20 lanes (cursor 19 − i per swap, eight 32-bit words per digest with rejection sampling, a fresh digest only when every word was rejected), the first 1 / 3 / 5 / 10 positions sorted = the car lanes for easy / medium / hard / expert. The whole road is fixed when the bet is placed; the multiplier after k lanes is (1 − edge) × C(20, k) ÷ C(20 − cars, k) rounded to 2 decimals and paid as shown — the same three values and difficulty give the same car lanes on duel.com/provably-fair/verify → Beef (the commitment hash is SHA-256 of the seed bytes there too).
Rock Paper Scissors: A player-versus-player game has no house randomness. Before anyone reveals, each player commits SHA-256 of `choice|clientKey` (a 32-byte key generated in their browser); after both commits each releases the key, and the referee — or anyone with the four values — finds the one choice of rock, paper, scissors whose hash matches. Neither player nor the house can change or learn a throw early; a key that opens nothing is an invalid reveal. Same scheme as duel.com/provably-fair/verify → Rock Paper Scissors: the four values paste into either page.
Rock Paper Scissors vs House: HMAC-SHA256(server seed bytes, clientSeed:nonce:cursor) read as 32-bit words; the first word below the largest multiple of 3 (rejection sampling) mod 3 is the house hand — 0 rock, 1 paper, 2 scissors — at cursor 0. Your hand never enters the hash: it only decides win, lose or tie. A tie replays on the next cursor until a hand decides — with the same hand, or with the hand you picked next ("let me choose"), one per throw, the last one repeating; the win pays 2 × (1 − edge) = 1.98× at the 1 % edge (a 50 % chance once ties replay, RTP 99 %). 30 ties in a row would be a push.

Verify a round

Pick the game, paste the seeds from your bet details and the round is recomputed here in your browser. Nothing is sent to us.

Game

Number of mines

Grid size

Client seed

Server seed (revealed after rotation)

Nonce

The result appears here as soon as the seeds are filled in.

HMAC-SHA256(server seed, clientSeed:nonce:cursor) read as 32-bit words with rejection sampling drives a Fisher-Yates shuffle of the tiles; the first N are the mines.

Standalone code — run it in any browser console

// Kingz Originals — Mines provably-fair verifier (plain JavaScript, no dependencies)

// Inputs
const serverSeed = '';   // revealed after you rotate your seed pair
const clientSeed = '';
const nonce      = 0;
const minesCount = 3;
const gridSize   = 25;

function hexToBytes(hex) {
  const out = new Uint8Array(hex.length / 2);
  for (let k = 0; k < out.length; k++) out[k] = parseInt(hex.slice(k * 2, k * 2 + 2), 16);
  return out;
}
function bytesToHex(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
}
async function sha256Hex(bytes) {
  return bytesToHex(new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)));
}
async function hmacSha256Hex(keyHex, message) {
  const key = await crypto.subtle.importKey('raw', hexToBytes(keyHex), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
  const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(message));
  return bytesToHex(new Uint8Array(sig));
}

// Fisher-Yates shuffle of [0..gridSize) driven by HMAC-SHA256(serverSeed, clientSeed:nonce:cursor),
// reading the digest as 32-bit big-endian words with rejection sampling (no modulo bias).
async function minesPositions(serverSeed, clientSeed, nonce, gridSize, minesCount) {
  const MAX_UINT32 = 0xffffffff;
  const positions = Array.from({ length: gridSize }, (_, k) => k);
  for (let idx = gridSize - 1; idx > 0; idx--) {
    const range = idx + 1;
    const limit = MAX_UINT32 - (MAX_UINT32 % range);
    let cursor = gridSize - 1 - idx;
    for (;;) {
      const hash = await hmacSha256Hex(serverSeed, clientSeed + ':' + nonce + ':' + cursor);
      let j = null;
      for (let off = 0; off + 8 <= hash.length; off += 8) {
        const value = parseInt(hash.slice(off, off + 8), 16);
        if (value < limit) { j = value % range; break; }
      }
      if (j !== null) { [positions[idx], positions[j]] = [positions[j], positions[idx]]; break; }
      cursor++; // every word rejected (≈ never) → draw a fresh digest
    }
  }
  return positions.slice(0, minesCount).sort((a, b) => a - b);
}

(async () => {
  if (!/^[0-9a-f]{64}$/i.test(serverSeed)) return console.log('Enter the revealed 64-hex server seed first.');
  console.log('Server seed hash (compare with the hash shown before you played):', await sha256Hex(hexToBytes(serverSeed)));
  console.log('Mine positions (0 = top-left, row by row):', await minesPositions(serverSeed, clientSeed, nonce, gridSize, minesCount));
})();

Your revealed seeds

Nothing revealed yet. Rotate your seed from any game and the server seed you were playing with appears here, ready to verify.

Loading verifier…

Provably fair

Before you play

Every round

After you rotate

Verify a round

Your revealed seeds

Verify a round

Your revealed seeds