What is Provably Fair?
Provably fair is an approach used in online gaming that allows every result to be independently verified as genuinely random.
It provides a cryptographic guarantee that game outcomes cannot be altered after a bet is placed. By combining player-provided data, server-generated data and publicly verifiable cryptographic commitments, anyone can independently reproduce and verify the outcome of a round.
This ensures that every result remains both unpredictable before the round and verifiable after it has completed.
How We Keep Our Original Games Provably Fair
Every outcome is generated using three components:
Server Seed
A secret random value generated by the server.
Before gameplay begins, the server publishes a cryptographic hash of the Server Seed. This acts as a commitment, proving the Server Seed existed before the round started without revealing its value.
After the round resolves, the Server Seed is revealed and can be verified against the previously published hash. Every round uses a new Server Seed.
Client Seed
A value contributed by the player.
Players may choose their own Client Seed or use a system-generated value. The Client Seed becomes part of the randomness generation process and can be changed anytime, but not during an active round. In games played in several steps (Mines, Hi-Lo and Blackjack), a change made during a round applies from the next round.
Nonce
A counter that increases with every random event in a round.
Because every round uses a new Server Seed, the Nonce starts again each round. The round's first random event uses Nonce 1. Always use the Nonce shown for the round in the Verify tab.
Provably Fair - Verification Guide
This guide explains how the provably fair system generates randomness and how you can independently verify the outcome of any round.
The system operates using a simple principle:
Commit → Play → Reveal
The server first commits to a Server Seed by publishing its hash. Gameplay then takes place using the Server Seed, Client Seed and Nonce. Once the round has completed, the Server Seed is revealed so that the entire process can be independently verified.
Table of Contents
- Trust Model
- Seeds, Hashes and Nonces
- Randomness Generation
- RNG Translation
- Shuffling
- Game Setup Commitment
- Outcome Mapping
- How to Verify a Result
- Reference Verifier
- Worked Example
- Notes
Trust Model
Before a round begins, the server generates a secret Server Seed and publishes:
serverSeedHash = SHA256(serverSeed)
Because cryptographic hashes are one-way functions, the Server Seed remains hidden while the commitment remains publicly visible.
After the round resolves, the Server Seed is revealed. Players can then verify:
SHA256(serverSeed) == serverSeedHash
If the values match, the Server Seed could not have been modified after the commitment was made.
Seeds, Hashes and Nonces
| Value | Origin | Meaning |
|---|---|---|
| serverSeed | Server | Secret random value, revealed after the round |
| serverSeedHash | Derived | SHA256 hash of the Server Seed |
| clientSeed | Player | Player-provided source of randomness |
| nonce | Counter | Increases with every random event in a round, starting at 1 |
| initialShuffle | Server | The game's starting setup: the ordered deck for card games, or the range, wheel, grid or payout table for other games |
| initialShuffleHash | Derived | Commitment to the starting setup, tied to the round's Server Seed |
| finalShuffle | Server | The round's raw result: the shuffled deck, mine positions, roll or draw |
What Is Published When
| Value | Before / During Round | After Round Resolves |
|---|---|---|
| clientSeed | ✓ | ✓ |
| serverSeedHash | ✓ | ✓ |
| nonce | ✓ | ✓ |
| initialShuffleHash | ✓ | ✓ |
| serverSeed | — | ✓ |
| initialShuffle | — | ✓ |
| finalShuffle | — | ✓ |
Randomness Generation
Every random value is generated from the combination of the Server Seed, the Client Seed and the Nonce. The inputs are combined using HMAC-SHA256, and the result initializes a ChaCha20 random number generator. Exactly:
mac = HMAC-SHA256(key = serverSeed, message = clientSeed + ":" + nonce)
chachaKey = SHA256(mac)
chachaNonce = first 12 bytes of mac
stream = ChaCha20 keystream (IETF variant: 96-bit nonce,
block counter starting at 0)
The Server Seed is used as text (its UTF-8 characters), not decoded from hexadecimal. The Client Seed and Nonce are joined with a colon, for example
myClientSeed:1
.
ChaCha20 is a widely used cryptographic algorithm designed to generate secure and statistically uniform random values.
Because the process is deterministic, the same inputs will always produce the same output. This allows every outcome to be independently reproduced and verified after the Server Seed has been revealed.
RNG Translation
The generator's output is read 4 bytes at a time as unsigned big-endian integers (0 to 2 32 − 1).
Where a game needs a whole number from 0 to n − 1, rejection sampling is used so every result is equally likely:
limit = 2^32 − (2^32 mod n)
read the next integer; if it is ≥ limit, discard it and read another
result = integer mod n
Each game then turns these numbers into its result (see Outcome Mapping ).
Shuffling
Card games and Mines use the Fisher-Yates shuffle algorithm. Fisher-Yates is a mathematically proven method for generating unbiased random permutations and is widely used throughout the gaming industry.
for i from (size − 1) down to 1:
j = random whole number from 0 to i (using the method above)
swap items i and j
One shuffle uses a single random stream (one Server Seed, Client Seed and Nonce) from start to finish. Because the shuffle is deterministic, any player can reproduce the exact order once the Server Seed has been revealed.
Game Setup Commitment
Every game commits to its starting setup (
initialShuffle
) before the round begins:
initialShuffleHash = SHA256(initialShuffle + "|" + serverSeed)
The starting setup and the Server Seed are joined with a vertical bar (
|
).
The hash is published before gameplay begins. After the round resolves, the starting setup and Server Seed are revealed and can be checked against it. This ensures that the deck, grid or game setup could not have been changed after the commitment was made.
Outcome Mapping
Dice
A whole number from 0 to 10000 is drawn and divided by 100, giving a roll from 0.00 to 100.00.
Limbo
A whole number from 1 to 100,000,000 is drawn (the "raw draw"). The result multiplier is:
result = RTP × 100,000,000 ÷ rawDraw
rounded down to 2 decimals and kept between 1.00 and 10,000.00. RTP is the game's return to player, for example 99%. The round wins when the result is equal to or higher than your target multiplier.
Roulette
A whole number from 0 to 36 is drawn: the winning number.
Plinko
Each combination of rows and risk level has a published payout table, in which each landing slot has a weight. A whole number is drawn from 0 up to (but not including) the table's total weight. Going through the slots in order and adding up their weights, the ball lands in the first slot where the running total is higher than the drawn number. That slot sets the multiplier. Slots with a higher weight are proportionally more likely.
Mines
The grid's cells are numbered 0 to N − 1 (N = grid size, for example 25 for a 5×5 grid). The cells are shuffled once per round using Fisher-Yates. The first m cells of the shuffled list are the mines, where m is the number of mines chosen. The mine layout is fixed before the first tile is revealed and does not change during the round.
Baccarat and Blackjack
An 8-deck shoe (416 cards) is shuffled once per round using Fisher-Yates, and cards are dealt from it according to the game rules.
Hi-Lo
Each card is drawn from a freshly shuffled 52-card deck: card 1 uses Nonce 1, card 2 uses Nonce 2, and so on. The top card of each shuffle is the card dealt.
How to Verify a Result
For a completed round, verification consists of three steps.
Step 1 - Verify the Server Seed
Confirm that the revealed Server Seed matches the Server Seed Hash shown before the round:
SHA256(serverSeed) == serverSeedHash
This proves that the Server Seed was committed before gameplay began.
Step 2 - Reproduce the Outcome
Using the revealed Server Seed, the Client Seed and the Nonce shown for the round, reproduce the random values generated during the round. The reproduced values should match the published game result exactly.
Step 3 - Verify the Game Setup Commitment
SHA256(initialShuffle + "|" + serverSeed) == initialShuffleHash
This confirms that the starting deck, grid or game setup was committed before gameplay began and was not modified afterwards.
Reference Verifier
Every Originals game has a built-in verifier: open the game, then Provably Fair → Verify . It shows the last round's Server Seed, Client Seed and Nonce, and recalculates its result. You can also enter any revealed seeds and nonce to check another round.
If the reproduced values match the published results, the round has been verified successfully.
Worked Example (Dice)
serverSeed = 1d9339ea6c9e0abc843a07ae63369f2ca65682a327efb8d849c6a1d12ae96bf5
serverSeedHash = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
clientSeed = l9Chl4f9OV7AP3Pf
nonce = 1
initialShuffle = 0,10000
Step 1:
SHA256(serverSeed) = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
✓ matches serverSeedHash
Step 2:
The generator described above gives the whole number 2897, so the roll is 2897 ÷ 100 = 28.97. A bet of Over 50.00 loses on this roll.
Step 3:
SHA256("0,10000|" + serverSeed) = a98a9aa999ea5d4ad8fb8802c871eaa37713c861612d14c8ac57e1ee0e476c65
✓ matches initialShuffleHash
Notes
- Server Seed, Client Seed and Nonce fully determine every outcome.
- The same inputs will always generate the same result.
- Every round uses a new Server Seed; the Nonce starts at 1 each round.
- HMAC-SHA256 is used to derive cryptographic randomness from the seed values.
- ChaCha20 is used as the deterministic random number generator.
- Fisher-Yates is used for shuffling decks and the Mines grid.
- Rejection sampling keeps every result equally likely where a range is needed.
- Any modification to the Server Seed after commitment would invalidate the published hash and be immediately detectable.
- Every result can be independently reproduced and verified after the Server Seed has been revealed.