Provably Fair

Every round on GrowRoll is verifiable. The outcome is locked before you play and you can prove it after — we cannot rewrite history to make the house win.

How it works
3 steps
  1. Step 1
    Commit before play
    The server picks a secret random server seed, hashes it, and shows you only the hash. The real seed is locked away — neither you nor the server can change it after this point.
  2. Step 2
    Outcome derived deterministically
    When you play, the outcome is computed from the server seed + your client seed + a round nonce. Same three inputs → same outcome, every time.
  3. Step 3
    Reveal after rotation
    When you rotate your client seed (any time, from the Provably Fair modal in any game header) the server reveals the previous server seed. The hash you saw earlier must match — if it does, every round in that batch is verifiably honest.
Per-round flow
4 steps
  1. Step 1
    Round starts
    The server increments your nonce by 1 (atomic — concurrent plays each get a unique number) and records your bet.
  2. Step 2
    Outcome computed
    HMAC-SHA256 of (server seed, client seed:nonce) is split into 32-bit floats; the game uses those floats to pick a tile, draw numbers, set a multiplier, etc.
  3. Step 3
    Round resolves
    Server credits any payout, writes a ledger row, and emits a balance push. Your bet, the nonce, and the resulting outcome are all recorded.
  4. Step 4
    Reveal on rotation
    You can rotate your client seed at any time. When you do, the previous server seed is released and you can re-run the formula on every round you played with it.
The three seeds
3 steps
  1. Step 1
    Server seed
    64 hex characters generated server-side and hashed with SHA-256 before you see it. Rotates when you ask, or automatically on a sane schedule.
  2. Step 2
    Client seed
    A value YOU control. Default is a fresh random hex string; you can replace it any time from the Provably Fair modal. Different client seed → different outcomes from the same server seed.
  3. Step 3
    Nonce
    A counter that increments each round so two plays with the same seeds still produce different outcomes. The nonce is the reason a verifier needs to know which round number they are checking.
Verify a round yourself
3 steps
  1. Step 1
    Rotate your client seed
    Open the Provably Fair pill in any game header, copy your current server-seed hash, then rotate. The server seed for the just-finished batch is now revealed.
  2. Step 2
    Recompute the hash
    Run SHA-256 on the revealed server seed. It must match the hash you copied earlier — otherwise the server cheated.
  3. Step 3
    Replay the round
    Run HMAC-SHA256 with the revealed server seed as the key and "<clientSeed>:<nonce>" as the message. Take the first bytes as floats and run them through the game's outcome function — you should get the exact result you saw.
Built-in verifier

Paste the revealed server seed, your client seed, and the round nonce. The hash + HMAC + first eight floats are computed live in your browser using Web Crypto — no data leaves this page.

Revealed after rotation — 64 hex chars.
Which gameSets how the numbers are read

This round was

Enter the three values above and the result appears here.

This is the same calculation the game itself ran. If it matches what you saw, the round came from the seed we committed to before you bet. The raw values below show every step.

SHA-256 of server seed
Must match the commit hash you saved before rotating.
enter a server seed above
HMAC-SHA256 output (raw bytes)
enter all three inputs above
First 8 floats (input to game outcome)
  • enter all three inputs above
Algorithm

GrowRoll uses HMAC-SHA256 commit-reveal. The exact recipe — readable pseudocode that maps 1-1 to the server implementation:

hash    = SHA256(serverSeed)                 // shown before play
outcome = HMAC_SHA256(
            key:     serverSeed,
            message: clientSeed + ':' + nonce
          )
floats  = chunks of 4 bytes of outcome
            → uint32 / 2^32                  // [0, 1)
result  = game.applyFloats(floats)           // tile / draw / mult …

The server seed is generated with crypto.randomBytes(32) and never sent to the client until rotation. Outcomes for every game in the catalogue derive only from the three seeds — no server-side luck, no post-hoc adjustment.