HS

Provably fair

The deal you can prove

Every hand’s deck is fixed by a cryptographic recipe beforeyou see a single card — and after the hand you get everything needed to re-run that recipe yourself. If it matches, the deal was honest. You don’t have to take our word for it.

Open the verifier →Provably fair is a transparency & trust feature.

What “provably fair” means here

A normal online shuffle asks you to trust that the house dealt honestly. Provably fair removes the trust: the shuffle is a public, deterministic function of three values, and the house commits to its secret input before the hand. Afterward, anyone can reproduce the deck and confirm nothing was changed mid-hand.

Provably fair isn’t a wager guarantee — it’s how we keep the game demonstrably honest, so a bad beat is just a bad beat.

How commit-reveal works

01

Commit

Before the hand, the server generates a secret server seed and publishes only its SHA-256 hash — the commitment. That locks in the deck without revealing it: the server can't swap the seed later without breaking the published hash.

02

Deal

The deck is shuffled deterministically from three values — the server seed (still secret), the table's client seed (public), and the hand number. The same three values always produce the exact same deck.

03

Reveal & verify

After the hand, the server reveals the server seed. Anyone can hash it (it must match the commitment) and re-run the shuffle to reproduce the exact deck — which is precisely what this site's verifier does, in your browser.

The three inputs

These are exactly what the verifier asks for. From a finished hand, the app’s Fairness screen gives you all three.

Server seed

secret → revealed

A random secret the server commits to (as a hash) before the hand and reveals afterward. This is the piece that proves the server fixed the deck in advance and didn't rig anything.

Client seed

public

A seed tied to the table, mixed into the shuffle so the deck is never determined by the server alone.

Hand number

nonce

A counter that increases every hand, so the same pair of seeds still produces a fresh, independent deck each time.

The algorithm

For the curious — the deck is produced by a standard, bias-free construction:

  • Keystream

    HMAC-SHA256 keyed by the server seed, over clientSeed:nonce:round for round = 0, 1, 2… Each block yields 32 deterministic bytes, chained until there are enough to shuffle.

  • Shuffle

    A seeded Fisher-Yates shuffle of the ordered 52-card deck. Each swap index is drawn by rejection sampling — discarding the biased tail of the byte range — so every card position is uniformly likely, with no modulo bias.

  • Same code, both sides

    The verifier runs the identical module the dealer uses — copied byte-for-byte and pinned by a golden-vector test — so a match here is a match with the real deal.

Try it on a real hand

Grab the server seed, client seed, and hand number from any finished hand’s Fairness screen, paste them in, and watch the exact deck rebuild in your browser.

Open the verifier →