Verify any result, step by step

Every Gamba in-house game has a result that can be reproduced from its revealed data. You do not need to trust a result on screen: enter the values from a settled round and follow the same calculation that produced it.

Start here

1. Choose the game you played.
2. Enter the public values from that round: seeds and nonce for player-seed games, or public round data for Marble Race.
3. Review every generated value and compare the final result with the one you received.

The interactive guides keep all inputs editable and always show the technical details: the functions, HMAC messages, bytes, intermediate numbers, and final result.

What a verification proves

There are two parts to a fair result:

Check	What it tells you
Commitment	The seed that decides a round was fixed before a bet was placed.
Calculation	The revealed values produce the same result that the game reported.

Both matter. Reproducing a result is useful only when the deciding seed was already committed before anyone could see the wager.

One shared algorithm

Dice, Mines, and Snake use the same deterministic source of randomness. Each game differs only in how it turns those numbers into a roll, board, or set of dice.

client mnemonic ──► binary seed ─┐
                                 ├─► HMAC-SHA256 stream ─► bytes / floats / integers ─► result
server mnemonic ──► binary seed ─┘             + nonce

Each 32-byte block is produced as:

HMAC-SHA256(serverSeed, "<clientSeed>:<nonce>:<block>")

The two mnemonics are converted independently. The nonce does not change that conversion; it is added when the random stream is read, so every bet gets its own deterministic sequence.

Marble Race uses public round data instead of player mnemonics. Its round seed, public hash, and round ID produce a sequence of exact 64-bit draws that shuffle the finishing order.

Explore a game

Game	What the seeds determine	Open the guide
Dice	One roll from 0 to 100, kept to four decimal places.	Verify Dice
Mines	Unique mine positions on a 5 × 5 board.	Verify Mines
Snake	Five rounds of two or four dice.	Verify Snake
Marble Race	The finishing order of six marbles.	Verify Marble Race

Each guide is self-contained. You can start with the game you want to check.

All game guides

Every verifier published by the library has a matching interactive guide. The four detailed guides above introduce the shared algorithm; use the links below to open the verifier for the game you played.

Game	Guide	Game	Guide
Baccarat	Open	Blackjack	Open
Blitz	Open	Cash Hunt	Open
Coin Flip	Open	Crash	Open
Darts	Open	Dragon Slayer	Open
Dragon Tiger	Open	Dragon Tower	Open
Flappy	Open	HiLo	Open
Keno	Open	Limbo	Open
Plinko	Open	Progressive Coin Flip	Open
Pump	Open	Rock Paper Scissors	Open
Russian Roulette	Open	Slide	Open
Slice	Open	Wheel	Open

What the seeds do not determine

Seeds determine the random outcome, not its commercial settings. Payout percentages, coefficient tables, and house edge are game configuration. The guides show them separately from the seed-derived result so it is clear which values cryptography can verify.

Learn the functions behind the result

The Algorithm Reference documents the reusable JavaScript functions behind every guide:

• generateMnemonic() creates a secure 12-word mnemonic.
• binarySeedFromMnemonic() converts one mnemonic into the seed used by the byte stream.
• bytes(), floats(), and integers() expose every stage of the draw.
• uint64() and roundSeeds() support public-round games such as Marble Race.

Use the reference when you want to reproduce a calculation in your own code or inspect the meaning of each parameter.

Parity is checked outside the browser

The verifier runs entirely in JavaScript in the browser. Go is used only during development to generate the values that the JavaScript implementation must reproduce; a player never needs a backend request or a Web Worker to verify a result.

Coverage	Parity check
Dice	Binary seeds, raw float, four-decimal roll, and settlement.
Mines	Raw floats and unique selections on the 25-tile board.
Snake	Every die across all five rounds, including each four-byte cursor step.
Marble Race	64-bit shuffle draws, finishing order, physics seed, and full fingerprints for all six maps.

Marble Race physics is checked against Go running on AMD64, the production reference architecture. The public verifier itself stays small: it needs only the deterministic five-draw shuffle that decides the payout.

The guarantees

• Committed in advance — the deciding seed is published as a commitment before the round.
• Deterministic — identical inputs always produce identical outputs.
• Unique per round — a nonce or round ID keeps one round's draw distinct from another's.
• Inspectable — every game guide exposes the inputs and intermediate steps, not only the final answer.

Every value shown here is computed by the same JavaScript library used by the interactive verifiers. Nothing is entered by hand.