← All tools

Hash-Chain Auditor

A casino could easily manipulate your results if they generated a new seed for every spin. This Hash-Chain Auditor lets you verify a complete chain of round hashes, proving that the casino pre-generated every single game outcome in advance (a key pillar of modern Provably Fair systems) and could not alter them during play.

Hash-Chain Auditor

Paste a CSV of (revealed_seed, published_hash, optional_label) — one rotation per line. Tool SHA-256s each seed and confirms the chain.

—
LabelComputedPublishedStatus

What is a cryptographic hash chain?

First pioneered by early crypto casinos like Bustabit, a hash chain is a secure method to lock in millions of game results in advance. Instead of generating a random number on the fly, the operator starts with a single random seed and hashes it repeatedly using the SHA-256 algorithm—often up to 10 million times.

The casino publishes the very last hash (the “genesis” hash) before any games are played. Because SHA-256 is a one-way function, players cannot calculate backward to find the next seed. However, as the games are played in reverse order, anyone can verify that each round’s hash is the exact SHA-256 parent of the previous round’s hash.

The Unbroken Chain rule: Because every game’s hash is mathematically linked to the next one, the casino cannot alter a single round’s outcome without breaking the entire chain. If they skipped a round or modified a multiplier, the math would fail to resolve back to the published genesis hash, exposing fraud instantly.

The math: Recursive SHA-256 hashing

The generation of the hash chain works forward, while the game play and verification work in reverse:

1. Forward generation (Casino setup)

The casino starts with a secret base seed ($S_0$) and hashes it recursively $N$ times:

S₁ = SHA-256(S₀)
S₂ = SHA-256(S₁)
...
S_N = SHA-256(S_{N-1})  (This is the Genesis Hash, made public first)

2. Reverse verification (Player audit)

The games are played in reverse order, starting from round $N$ and working down to round 1. To prove that the sequence is intact, you take the hash of the current round ($S_k$) and check if its SHA-256 value matches the hash of the previous round ($S_{k+1}$):

SHA-256(S_k) = S_{k+1}

Step-by-step audit: Verifying a session log

Suppose you want to audit a block of 100 crash rounds you just played. Most provably fair casinos allow you to download a history log as a CSV file containing the round numbers and their respective hashes:

  1. Download the CSV file from your casino’s game history page.
  2. Open the file and copy the column containing the hex hashes.
  3. Paste the hashes into the auditor input box above.
  4. Click “Verify.” The tool will recursively hash each row and compare it to the next.
  5. If the entire chain resolves perfectly, your audit status will show green. This proves that not a single game was skipped, inserted, or altered.

Frequently asked questions

What does a “broken chain” mean?

A broken chain means that the hash of round $k$ does not hash to the value of round $k+1$. This is definitive mathematical proof of manipulation: either the casino altered a game outcome mid-session, skipped a round, or inserted an unrecorded round to evade a winning streak.

How can I be sure the casino didn’t pick a favorable chain?

To prevent the casino from generating millions of chains and picking one that favors them, reputable operators mix in a public “client seed” (like a recent Bitcoin block hash) into the final round outcomes. Since the casino could not predict the future Bitcoin block when generating the chain, they could not optimize the outcomes.

Why is SHA-256 used for hash chains? (Read our step-by-step tutorial on How to Verify outcomes)

SHA-256 is an industry-standard cryptographic hash function. It is completely collision-resistant and behaves pseudo-randomly. Changing a single character in the input seed completely alters the resulting hash output, making pattern prediction impossible.