Verify a game

How provably fair works

Every Bustabyte game result is predetermined before any bets are placed. Here's exactly how it works, step by step.

Step 1

A chain of secrets is created

Before any games begin, we generate a random seed and hash it millions of times using SHA-256. Each hash becomes a future game's result. The final hash in the chain (the terminal hash) is published publicly, locking in every result.

a7f3e9c1...
Seed
SHA-256
Hash 1
SHA-256
Hash 2
...
Millions
SHA-256
Hash N-1
d4e8f2b1...
Terminal
Each hash is the SHA-256 of the previous one. This means once we publish the terminal hash, every result in the chain is locked. We can't change any hash without breaking the chain.
Step 2

Why games must play in reverse

This is the most important part of the whole system. To understand why, let's look at what would go wrong if we played games forwards instead.

Problem: Playing forwards
Game 1 uses
Hash 1
SHA-256
Game 2 uses
Hash 2
SHA-256
Game 3 uses
Hash 3
After Game 1, Hash 1 is revealed. Since SHA-256 is computed forwards, anyone who knows Hash 1 can calculate SHA-256(Hash 1) = Hash 2. That means every player can predict Game 2's result before it starts. The whole chain unravels.
Solution: Playing in reverse
The chain is linear — each hash only links to the next:
Seed
→
H1
→
H2
→
H3
→
Terminal
Game 1 Published
Game 1 uses H3 (the one right before the terminal). After the game, H3 is revealed. You verify it: SHA-256(H3) = Terminal. This works because each hash only produces the one directly after it — not all of them.
Game 2 will use H2. To predict it, you'd need to figure out what input was hashed to produce H3. But SHA-256 only works forwards — you can't reverse it. So H2 remains completely unknown until it's revealed after Game 2.
After Game 2 reveals H2, you verify: SHA-256(H2) = H3. Each game's hash proves the link to the one already revealed, forming a verifiable chain.
In short: the chain is a one-way road. Each game reveals one link, and you verify it by hashing it forward to match the link already revealed. But the next game's link is behind you on that road, and SHA-256 can't go backward. So you get verifiability without predictability.

See it in action

Step through the animation below to watch the chain being built, then see how games play through it in reverse.

Forward is easy
Given any hash, anyone can compute SHA-256 to get the next hash. This is how you verify the chain after a game.
Backward is impossible
Given a hash, nobody can figure out what was hashed to produce it. This means the next game's hash is unknowable.
Results are locked in
Because the terminal hash is published first, every game result is already determined. We can't change any result without breaking the chain.
Step 3

Each hash determines a crash point

Every game hash is converted into a crash multiplier using a deterministic formula. The same hash always produces the same result.

1
Extract 52 bits
Take the first 13 hex characters of the hash and convert to an integer. This gives a number between 0 and 252.
h = parseInt(hash[0:13], 16) e = 2^52
2
Check for instant crash
If h % 20 == 0, the game instantly crashes at 1.00x. This creates the 5% house edge, and is the only element of randomness that favors the house.
// 1 in 20 chance of instant crash if (h % 20 == 0) return 1.00x
3
Calculate crash point
The crash multiplier is derived from a formula that maps the hash value to a smooth distribution. Higher hash values produce higher multipliers.
crash = floor((100 * e - h) / (e - h)) / 100
Step 4

You can verify every game

After each game, the hash is revealed. You can independently verify that SHA-256 of the current game's hash equals the previous game's hash, proving the chain is unbroken.

Game ends

The game hash is revealed publicly after the round crashes

Compute SHA-256

Hash the revealed value with SHA-256 using any tool you trust

Compare

The result must match the previous game's hash. If it does, the chain is valid

Try it

Calculate a crash point yourself

Paste any game hash below and calculate its crash point entirely in your browser. Nothing is sent to the server.

-
Crash point
Hash -
SHA-256 -
52-bit int -
Instant? -
Current chain

Active hash chain

This chain's terminal hash was published before the first game was played. Every result is locked in.

Games played
47,559
Chain length
100,000
House edge
5%
Terminal hash 4204875bbb0cf304b3aba01076b179282a5b37c8ded6eb1b3093ce83c32d473d

Ready to verify?

Use our verification tool to check any game result independently.

Verify a game