Crash games
Provably fair crash games
A provably fair crash game publishes a cryptographic commitment to each result before the round and reveals the data behind it afterward, so anyone can check that the two match. A successful check shows the result was not altered after it was committed; it does not by itself show the house edge.
Key takeaways
- According to its documentation, bustabit commits to a whole chain of SHA-256 hashes at once and plays it in reverse; its current chain, from February 2024, holds 100 million hashes.
- The result formula that bustabit publishes uses the number 99 to encode a 1% house edge. Neither Spribe nor the Spaceman Game Help publishes an equivalent formula.
- Aviator, per Spribe, combines an operator server seed with client seeds from players and hashes them with SHA-512.
What provably fair means in a crash game
Provably fair relies on a technique called commit-and-reveal. The everyday version is a sealed envelope: before the round, the game writes down the result, seals it and leaves the envelope on the table, and after the round the envelope is opened so everyone can see that the result inside matches what was played.
Online, the envelope is a hash. A hash function such as SHA-256 turns any piece of data into a fixed-length string of characters. The same data always gives the same string, and the string cannot practically be worked backward into the data.
- Commitment Before the round, the game publishes the hash of a value that determines the result.
- Round The round runs. The hash is visible throughout but reveals nothing usable about the result.
- Reveal After the round, the game publishes the value itself.
- Verification Anyone can hash the revealed value and compare it with the hash published earlier. If the two match, the value was not changed in between.
The first provably fair seeding event for bustabit was posted on BitcoinTalk on 12 January 2015, a step described in the history of crash games.
How bustabit’s hash chain works
The game generally accepted as the first crash game, bustabit, commits to millions of rounds at once instead of one at a time. According to its published documentation, the scheme works like this.
- The chain is built Starting from one secret, SHA-256 is applied again and again, each hash becoming the input for the next. The current chain, from February 2024, holds 100 million hashes; the 2015 and 2018 chains held 10 million each.
- The end is published The final hash of the chain is made public before any round from it is played. That is the commitment.
- An outside salt is added A “game salt” is taken from a Bitcoin block that had not yet been mined when it was announced. Nobody could know that value in advance, which prevents the operator from picking a favorable chain.
- Rounds run in reverse Rounds use the chain backward, so each round’s hash is the SHA-256 of the next round’s hash.
- Results can be verified When a round’s hash is revealed, hashing it should give the hash of the round before. Repeating the step leads back to the published final hash.
From hash to multiplier
The same documentation sets out how a hash becomes a crash point. The round’s hash and the game salt go through HMAC-SHA256, 52 bits of the output are turned into a number X from 0 up to (but not including) 1, and X goes into this formula.
bustabit only: crash point = floor(99 ÷ (1 − X)) ÷ 100, with a minimum of 1.00x
| X | 99 ÷ (1 − X), rounded down | Crash point |
|---|---|---|
| 0.005 | 99 | 1.00x (0.99 raised to the minimum) |
| 0.50 | 198 | 1.98x |
| 0.75 | 396 | 3.96x |
| 0.90 | 990 | 9.90x |
| 0.99 | 9,900 | 99.00x |
The 99 is where the house edge sits: it encodes bustabit’s 1% edge, and the documentation gives the chance of reaching a target t as 99 ÷ t percent. That relationship, a reach chance of roughly RTP (return to player) divided by the target, is the idea behind the constant-RTP model, where the figures are worked through.
Note
This is bustabit’s formula. It is not Spaceman’s and not Aviator’s. Spribe publishes no hash-to-multiplier formula, and the Spaceman Game Help does not describe how its crash value is distributed.
Aviator’s seed scheme, per Spribe
Aviator, from Spribe, uses seeds for each round instead of a pre-generated chain. Spribe describes the scheme as follows.
- The operator generates a server seed. A SHA-256 hash of the next round’s server seed is visible before the round.
- Client seeds come from players. The in-game description says they are taken from the first three bettors.
- The seeds are combined and hashed with SHA-512 to derive the result.
- Everything can be checked afterward from the game history.
In our reading, the client seeds do the job that the Bitcoin block does for bustabit: they add input that was not known when the commitment was made.
What verification proves, and what it does not
A successful check is a narrow result.
| Question | Answered by the hash check? |
|---|---|
| Was this round’s result changed after it was committed? | Yes. That is what the check is for. |
| What is the game’s RTP or house edge? | Not by itself. That takes a published formula or the RTP stated in the game’s rules. |
| Will the next round be high or low? | No. The commitment reveals nothing usable before the round. |
| Has a lab tested the game, and does a regulator oversee it? | No. That is a separate form of assurance. |
The second row is easy to misread. The 1% edge of bustabit is known because its formula is published, not because the hashes match. A game can pass every check and still have any house edge its math specifies.
The last row describes the other fairness model in use: a certified RNG, which rests on independent lab evaluation and regulatory oversight instead of a per-round player check. The page on RNG testing compares the two.
Implementations also vary. “Provably fair” names an approach, and each game’s own documentation defines what can be checked.
Verification in bustabit, Aviator and Spaceman compared
| Aspect | bustabit | Aviator (per Spribe) | Spaceman |
|---|---|---|---|
| Commitment before the round | Final hash of a SHA-256 chain, published before play | SHA-256 hash of the next round’s server seed | Not described in Game Help version 1.7 |
| Input the operator does not choose | Game salt from a Bitcoin block not yet mined when announced | Client seeds from players | Not described in Game Help version 1.7 |
| Result formula | Published | Not published | Not published |
| Where it is documented | Its published documentation | Spribe’s provably fair page and the in-game description | Description removed from the Game Help in July 2024; check the information inside the game |
For Spaceman the record is a dated one. Pragmatic Play’s press release of 24 March 2022 referred to the game’s “provably fair mechanics”, and an older, undated copy of the Game Help described a SHA-256 hash check in the Statistics section. The change log of Game Help version 1.7 notes that this description was removed on 10 July 2024, and the document does not say whether the in-game check itself was removed or only its description. This site therefore does not describe Spaceman as provably fair and does not say that it is not; the full timeline is on the page about whether Spaceman is fair, and the information inside the game is the authority.
Sources
- Spribe — Provably Fair
- Spribe, Aviator in-game rules, as reproduced by licensed operators (cited by name, not linked)
- bustabit — published documentation, including its provably fair article (cited by name, not linked)
- BitcoinTalk — bustabit seeding-event threads: 2015, 2018 and 2024 (cited by name, not linked)
- Pragmatic Play — Pragmatic Play blasts off with Spaceman (press release, 24 March 2022)
- Pragmatic Play — Spaceman Game Help, version 1.7 (change log to 10 July 2024), as distributed to licensed operators (cited by name, not linked)