Provable fairness

Verify a round

Before you play, the server generates a random seed and publishes only its SHA-256 hash. That hash is a promise it cannot take back: any other seed produces a different hash.

You choose your own client seed, and a nonce counts up by one every round. The outcome is derived from those three values and nothing else — not the size of your bet, not your balance, not the time of day.

When you rotate your seed pair, the old server seed is revealed. Hash it yourself to check it matches what was published, then replay any round you played on it.

Everything on this page works signed out, and it works on someone else’s round just as well as your own.

Recompute a round

Game

Server seed (revealed)

Client seed

Nonce

Result

Paste the three values from any round — yours or someone else’s — and the outcome is recomputed here from scratch. Nothing is looked up; it is derived.

The exact steps

Check the commitment

Take the revealed server seed and hash it with SHA-256. The result must equal the hash the site showed you before the round. If it does, the seed could not have been chosen after you played.

sha256(serverSeed) === publishedHash

Build the byte stream

HMAC-SHA256, keyed on the server seed, over the string clientSeed:nonce:cursor. The cursor starts at 0 and increases by one each time another 32 bytes are needed.

hmacSha256(key = serverSeed, message = `${clientSeed}:${nonce}:${cursor}`)

Turn bytes into numbers

Take four bytes at a time and divide them down into a number between 0 and 1, in the standard base-256 arrangement.

float = b0/256 + b1/256² + b2/256³ + b3/256⁴

Apply the game

Keno — ten floats drive a partial Fisher–Yates shuffle over 1–40; the first ten values are the draw.
Dice — one float, scaled to 0.00–100.00 as floor(f × 10001) / 100.
Limbo — one float, as max(1, floor((1 / (1 − f)) × 0.99 × 100) / 100).
Wheel — one float, scaled to a segment index as floor(f × 24). The multiplier is then read off the published table for the risk level played, which is why this page recomputes the segment rather than the payout: the seeds decide where the wheel stops, not what that slice is worth.

The 0.99 in the limbo formula is the house edge, and it is the only place the edge enters the arithmetic for that game. Keno carries it in its paytables instead, and dice carries it in the payout multiplier. It is 99% everywhere.