Verification protocol

Verify the process, not a promise.

Roat Pkz commits to hidden server input before play, reveals it afterward, and publishes deterministic verifier implementations so the recorded outcome can be independently reproduced.

Open source · MIT licensed
Digest
SHA-256
Verification
Local and offline
Implementations
5
Protocol sequence

Commit. Lock. Reveal. Replay.

Each phase preserves evidence needed to audit the final result.

01

Commit

Before play, the server publishes a SHA-256 fingerprint of its hidden server seed.

02

Lock

The wager and player-controlled seed inputs are fixed before the outcome is generated.

03

Reveal

After the session or round, the original server seed is disclosed for independent checking.

04

Replay

The matching verifier recomputes the deterministic outcome from the recorded inputs.

Technical model

Game-specific inputs. Deterministic output.

Every game uses SHA-256, but its exact input order, counter rules, and output mapping are defined by that game’s verifier. Always use the matching implementation.

A matching commitment confirms the revealed seed was not substituted. A matching replay confirms the disclosed inputs reproduce the recorded outcome.

verification.pseudo
committedHash = SHA-256(serverSeed)

assert SHA-256(revealedSeed)
       == committedHash

gameInput = gameSpecificMaterial(...)
outcome   = map(SHA-256(gameInput), rules)
Verifier registry

Choose the exact game implementation.

Each verifier is a self-contained browser tool and can be saved for offline inspection.

Review source code

Blackjack

ProvablyFairBlackjack
Output domain8-deck shoe · 416 cards
Required inputs clientSeed · serverSeed · nonce 
hash = SHA256(clientSeed + ":" + serverSeed + ":" + nonce + ":" + counter);
j = unsigned64(hash[0..7]) % (i + 1); swap(deck[i], deck[j]);
Open verifier View Source Code

Dice

ProvablyFairDice
Output domain0.00–100.00% · 10,001 values
Required inputs clientSeed · serverSeed · nonce 
hash = SHA256(clientSeed + ":" + serverSeed + ":" + nonce);
roll = (unsigned32(hash[0..3]) % 10_001) / 100.0;
Open verifier View Source Code

Mines

ProvablyFairMines
Output domain5 × 5 grid · 25 positions
Required inputs clientSeed · serverSeed · nonce · mineCount 
hash = SHA256(clientSeed + ":" + serverSeed + ":" + nonce + ":" + counter++);
index = unsigned64(hash[0..7]) % remaining;
mine = bag[index]; bag[index] = bag[--remaining];
Open verifier View Source Code

Flower Poker

ProvablyFairFlowerPoker
Output domainDeterministic flower stream
Required inputs player1Seed · player2Seed · serverSeed 
hash = SHA256(player1Seed + ":" + player2Seed + ":" + serverSeed + ":" + index);
value = unsigned64(hash[0..7]) & 0x7FFF_FFFF_FFFF_FFFF;
roll = (value % 500) + 1; flower = roll == 1 ? BLACK : roll == 2 ? WHITE : common[(roll - 3) % 7];
Open verifier View Source Code

Boxing

ProvablyFairBoxing
Output domainHit stream · values 0–16
Required inputs player1Seed · player2Seed · serverSeed · hit counter 
hash = SHA256(player1Seed + ":" + player2Seed + ":" + serverSeed + ":" + hitNo);
hit = unsigned64(hash[0..7]) % 17;
Open verifier View Source Code
Independent audit

Verify a recorded game.

  1. 1
    Preserve the inputs

    Copy the values exactly as displayed in-game. Seed values are case-sensitive.

  2. 2
    Open the matching verifier

    Select the same game and enter every required seed, nonce, counter, or game parameter.

  3. 3
    Recompute and compare

    Generate the result and compare the complete output with the recorded game outcome.

Technical FAQ

Verification questions.

Is Roat Pkz rigged?

No. Before play, Roat Pkz commits to a hidden server seed by publishing its SHA-256 hash. Afterward, the seed is revealed and the published verifier can reproduce the outcome from the recorded inputs. A substituted seed or altered result would produce a mismatch.

Is Roat Pkz gambling open source?

Yes. The provably fair gambling implementations and browser verifiers are published on GitHub under the MIT License. This allows anyone to inspect the exact seed handling, hashing, and outcome-mapping logic, reproduce recorded results independently, and audit how each supported game works.

What does a successful verification prove?

It confirms that the revealed server seed matches the earlier commitment and that the disclosed inputs reproduce the recorded outcome under that game’s published algorithm.

Why is only a hash shown before play?

Publishing the raw server seed early would reveal secret input material. Its SHA-256 hash commits the server to that seed without exposing it until the game is complete.

Why do some games use a nonce or counter?

A nonce or counter gives each result a distinct deterministic input while the same seed pair remains active. Use the exact value recorded for the result you are checking.

Can I choose my own client seed?

Yes. Use the seed control in the gambling interface before placing your wager. Player-controlled input prevents the server from choosing every input on its own.

Do identical client seeds create identical results?

No. The server seed and, where applicable, the nonce or counter also form part of the input. The complete set of inputs must match to reproduce a result.

What should I do if a verifier does not match?

Do not alter the recorded values. Save the client seed or player seeds, revealed server seed, nonce or counter, wager details, and observed result, then send the complete record to support.