Wheel guide
Blaze Wheel: from a hash digest to one segment
The name Blaze belongs to this page, not to a version of the game. This guide follows the path from seeds to the segment under the pointer, so that a wheel result can be recomputed by anyone who knows the inputs.
Why the layout order matters
To map a number to a segment, the segments must be numbered. This page uses an illustrative 40-segment wheel, numbered 0 to 39 clockwise from the pointer's starting position. It holds nineteen 0x, twelve 1.5x, six 2x and three 3x segments, mixed around the rim. The full order, from segment 0 onward, is: 0.0, 1.5, 0.0, 2.0, 0.0, 1.5, 0.0, 3.0, 0.0, 1.5, 0.0, 2.0, 0.0, 1.5, 0.0, 3.0, 0.0, 1.5, 0.0, 2.0, 0.0, 1.5, 0.0, 3.0, 0.0, 1.5, 0.0, 2.0, 0.0, 1.5, 0.0, 0.0, 1.5, 0.0, 2.0, 0.0, 1.5, 1.5, 2.0, 1.5.
| Multiplier | Segments | Chance | Contribution to mean |
|---|---|---|---|
| 0.00x | 19 | 47.50% | 0.0000 |
| 1.50x | 12 | 30.00% | 0.4500 |
| 2.00x | 6 | 15.00% | 0.3000 |
| 3.00x | 3 | 7.50% | 0.2250 |
Mean return 0.9750 per unit (EV -2.50%); standard deviation 1.000 per spin.
The order does not change the odds: each segment still has a 1 in 40 chance. It does matter for verification, because a published result is a segment number, and you need the layout to turn that number into a multiplier.
The mapping, step by step
| Server seed (revealed later) | blaze-srv-e83d |
|---|---|
| Commitment shown before play: SHA-256(server seed) | b1f6c3accbd912b3f1bbe4b00491cfdd5c89c8a25317ba3d4e8b22955929e398 |
| Client seed : nonce : round | blaze-reader:31:0 |
| HMAC-SHA256(server seed, message) | fb7a605ebf771e7d65815b6a8d6b86e8c39e4c3587eb684d0387be18e62ce35e |
| First 4 bytes (8 hex digits) | fb7a605e = 4,219,101,278 |
| Float = value / 2^32 | 0.9823360662 |
| Segment = floor(float x 40) | 39 |
One common construction, shown for teaching. Real services document their own message format; check theirs before verifying.
The digest is turned into a float between 0 and 1 using its first 4 bytes. Multiplying the float by 40 stretches it across the 40 segments, and rounding down picks one whole segment number. Here the result is segment 39, which in the layout above is a 1.5x segment.
Is the mapping fair to every segment?
The float comes from a whole number between 0 and 232 - 1. Splitting that range into 40 parts cannot be perfectly even, because 232 is not a multiple of 40. Some segments cover 107,374,182 values and some cover one more. The difference in probability is about 0.0000009% of a segment's chance, far too small to matter. Designs that need exact evenness reject the few leftover values and draw again.
Several rounds in a row
The nonce increases by one each round while the seeds stay the same. The table repeats the mapping for nonces 31 to 35.
| Nonce | First 8 hex digits | Segment (0-39) | Multiplier |
|---|---|---|---|
| 31 | fb7a605e | 39 | 1.5x |
| 32 | 54e01608 | 13 | 1.5x |
| 33 | 98a0779d | 23 | 3.0x |
| 34 | 1fd36d65 | 4 | 0.0x |
| 35 | 0d059029 | 2 | 0.0x |
What verification does and does not tell you
- It confirms that the segment came from the committed server seed and your client seed, not from a choice made after the round.
- It does not confirm the segment layout or the multipliers; compare those with the published table yourself.
- It does not make any segment predictable. Until the server seed is revealed, the next digest is unknown.
The commitment step that makes this meaningful is described in the hash fairness guide. The construction here is a common teaching example; a real service documents its own format, which is the one to use when checking its rounds.