Crash guide
Cyber Crash: committing to rounds with a hash chain
Cyber is the page's label and implies no special technology beyond what is described here. The guide explains commit-reveal for crash games, and in particular the seed chain, a design that lets a service fix thousands of future rounds in advance with one published hash.
The problem commit-reveal solves
If a service could pick the crash point after seeing everyone's targets, it could always end the round just below the most popular one. Commit-reveal blocks that. Before any round, the service publishes a hash of the secret it will use. After the round, it reveals the secret. Anyone can hash the revealed value and confirm that it matches the earlier commitment. SHA-256 makes it infeasible to find a second secret with the same hash, so the service cannot swap secrets later.
Why crash games often use a chain
Some crash designs run one shared round for everyone, with no per-player client seed. One known approach is a chain built backwards. The service picks one random origin seed, hashes it, hashes the result, and repeats many times. It publishes only the final hash in the chain, often called the terminal hash. Rounds then use the chain in reverse: the first round uses the value just before the terminal hash, the next round uses the one before that, and so on.
Each revealed seed checks the one before it. If round 1 used seed s1, then SHA-256(s1) must equal the terminal hash. If round 2 used s2, then SHA-256(s2) must equal s1. Because hashing only runs forwards, nobody can compute s2 from s1, so future rounds stay hidden even though they were fixed at the start.
A four-link chain, computed
The table builds a short chain from the origin seed cyber-chain-origin-5b. Real chains have millions of links, but four are enough to see the structure. To turn each seed into a crash point, this example uses HMAC-SHA256 with the seed as key and a fixed public message, cyber-public-salt:0:0, then applies the 1% edge formula to the first 4 bytes.
| Link | Value | Role | Crash point |
|---|---|---|---|
| 0 | 555aff11c5e7f774ada328177bbe45967732915199616c4fc2232ecbb5681e42 | terminal hash, published before round 1 | none |
| 1 | 3bec99d2e9b24bcd5117f811b89f62e305c1ca124a8a505bb733082be13aebe7 | seed for round 1 | 1.89x |
| 2 | bfc88a7ab981864e490265b54e590856b57e39826099aafa33a30549213519a8 | seed for round 2 | 1.20x |
| 3 | b16e75e5eb5c032e6af162c9ad7502a0272aab4ab3a7dc90bad256433eb97a34 | seed for round 3 | 9.44x |
Link 3 is SHA-256 of the origin string. Each link above it is SHA-256 of the link below. A teaching construction, not any service's exact scheme.
To check round 2, take link 2, hash it once, and compare with link 1. To check the whole chain at once, hash link 3 three times and compare with the terminal hash. If any value had been changed after publication, the comparison would fail.
Why the public salt matters
The chain is fixed by the service alone. A careful design mixes in a value nobody could know when the chain was made, such as a string announced only after the terminal hash is public. That stops the service from searching through many origin seeds for a chain that happens to start with low crash points. Without this step, a user has to trust that the chain was not cherry-picked.
Limits of what this proves
- It proves the crash points were fixed in advance. It does not prove the edge is the one advertised; check that against the published formula.
- It cannot help you predict the next round. Seeing link 2 tells you nothing usable about link 3.
- It only works if you actually run the check. A commitment nobody verifies protects nobody.
For per-player designs with client seeds and nonces, see the Crystal page and the hash fairness guide.