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.

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