Developers
Fairness specification
On this page
- Encodings and units
- Real-round scheme
- Seed chains
- Salt from the named drand beacon
- House-game outcome stream
- Dice
- Reproducing a live Dice round
- Blob Flip
- Blackout
- Reproducing a live Blackout round
- Overhang
- Round key and drops
- Payout
- Commit, reveal and proof
- Reproducing a live Overhang round
- Crash Tower
- Crash point
- Curve and bust time
- Settlement
- Commit, reveal and proof
- Test vectors
- Reproducing a live Crash Tower round
- Pinwheel
- Clash slots
- Ladder and payout
- Commit, reveal and proof
- Test vectors
- Reproducing a live Pinwheel round
Hold'em (Coming soon)- Wick (Coming soon)
- Precision and confirmation limits
- Publication and recovery
- Reference verifiers
Real-round proofs use onchain seed commitments and a future named drand beacon. Crash Tower, Dice, Blob Flip, Blackout, Overhang and Pinwheel publish enough inputs to reconstruct a completed result. Games that are not open yet have no published recipe.
Encodings and units
Seeds, roots and salts are 32-byte values written 0x plus 64 lowercase hex characters. SHA-256 chain links hash raw bytes, not their hex text. HMAC keys are seed bytes; messages are UTF-8 with the separators below. top52 reads the first six bytes times 16 plus the high four bits of byte seven.
House payouts use integer USDC micro-units, 1,000,000 per USDC. Multiplier cents mean 100 = 1.00×; they are not monetary units. Display rounding is separate from exact payout calculation.
Real-round scheme
Seed chains
c[L-1] = 32 random bytes
c[i] = SHA-256(c[i+1])
commit = SHA-256(c[0])
round k uses c[k]
Apply SHA-256 k+1 times to the revealed c[k] and compare with the commit. Consecutive reveals link in one hash; a reveal does not disclose the next preimage. The root is committed onchain before the chain is used. House chains default to 10,000 seeds. Wallet/game scopes isolate private house sessions; always use returned IDs and proof indices.
Salt from the named drand beacon
chainHash = 04f1e9062b8a81f848fded9c12306733282b2727ecced50032187751166ec8c3
period = 3 seconds; genesis = 1727521075
roundAt(t) = t < genesis ? 0 : floor((t - genesis) / 3) + 1
required saltRound >= roundAt(onchain commit timestamp + 3)
salt = SHA-256(signature bytes of the exact named saltRound)
The immutable beacon helper BLS-verifies the 64-byte BN254 signature against the configured evmnet key for that named round. Submission is accepted while the live round is from saltRound through saltRound+240. This twelve-minute window permits late submission; a later beacon's signature cannot replace the named one. No live game starts on an unsalted chain.
The server uses a future-round margin for receipt latency. Development's local salt is a separate offline mode and is disabled in the production host. Beacon liveness/key configuration and operator continuity remain operational dependencies.
House-game outcome stream
message_j = "tilt:v1:" + game + ":" + tableId + ":" + index + ":" + salt + ":" + clientSeed + ":" + nonce + ":" + j
block_j = HMAC-SHA256(key = seed bytes, message = UTF-8(message_j))
Game is crash, dice, flip or blackout. Current selected live house inputs use empty clientSeed and nonce 0; reproduce the actual proof fields. Live Blackout identifies blackoutEntropy:"drand-hmac-v1". Older offline Dice duels and tile-wave Blackout are not Real-round rules.
Overhang uses the same message with game overhang; see Overhang. Pinwheel uses it with game pinwheel; see Pinwheel.
Dice
R = floor(BigInt(top52(block_0)) * 10000 / 2^52) # integer 0..9999
T = targetCents # 200..9800
wins = direction == "over" ? 9999 - T : T
won = direction == "over" ? R > T : R < T
payout = won ? floor(stakeMicro * 9800 / wins) : 0
Ties lose. The payout uses the rational multiplier 9800/wins; a displayed two-decimal multiplier does not set the paid amount. Nominal RTP is 98% before hash-grid/base-unit rounding.
Reproducing a live Dice round
Use the reserved round's proof, selected direction/target and exact integer roll mapping above. Legacy long/short player duels are rejected by the live host.
Blob Flip
side = top52(block_0) < 2^51 ? "heads" : "tails"
payout = correctCall ? floor(stakeMicro * 196 / 100) : 0
Exactly half the draw space selects each side. A correct call pays 1.96× gross; nominal RTP is 98% before payout flooring. Verify the chain/HMAC proof.
Blackout
Real play uses 49 cells numbered 0–48, in row order on a 7×7 grid, with three shorts. For each cursor j, take top52(block_j), reject values at/above 2^52 - (2^52 mod 49), map modulo 49, and reject duplicates until three cells are selected.
M(k) = (98 / 100) * product((49 - i + 1) / (46 - i + 1), i=1..k)
payout = floor(stakeMicro * exactNumerator / exactDenominator)
displayedMultiplierCents = floor(100 * exactNumerator / exactDenominator)
The BigInt fraction determines the payout; the displayed multiplier is separately floored. Cash-out needs at least one safe pick; a short loses, and clearing 46 safe cells cashes out automatically. Nominal 98% RTP is before micro-unit payout flooring.
Reproducing a live Blackout round
The proof must contain the live entropy marker, seed, salt, table/index, ordered picks and terminal result. Recompute HMAC shorts and the exact fraction.
Overhang
Overhang has two tables. The derivation below is the signed live rule.
| Level | tableId | Block lands | m (draw modulus) | Top floor | Rules version |
|---|---|---|---|---|---|
| Normal | overhang-normal | 3 in 4 | 4 | 12 | overhang-v2-normal-12 |
| Hard | overhang-hard | 1 in 2 | 2 | 8 | overhang-v2-hard-8 |
Round key and drops
roundKey = HMAC-SHA256(key = c[k] bytes,
message = "tilt:v1:overhang:" + tableId + ":" + k + ":" + salt + "::0:0")
for drop i = 1 .. top:
for cursor = 0, 1, ...:
h = HMAC-SHA256(key = roundKey bytes,
message = "tilt:v1:overhang:" + level + ":" + (k + 1) + ":" + i + ":" + cursor)
x = top52(h)
if x >= 2^52 - (2^52 mod m): next cursor
value = x mod m; stop
value 0: the tower topples at drop i. Any other value lands.
toppleDrop = first toppling drop, or 0 if all top drops land
The roundKey message is the canonical live message with clientSeed empty, nonce 0 and cursor 0. level is normal or hard; tableId is the full table name. Because m is 4 or 2, which divide 2^52, the rejection never triggers. A round is checked as toppleDrop(roundKey, level, k + 1): the round number in the drop message is k + 1, and drops count from 1.
Payout
M(k) = (98/100) / p^k (p = 3/4 on Normal, 1/2 on Hard)
payout = floor(stakeMicro * M(cashedAt)) # 0 if the last accepted drop was the topple
maxPayoutBps: Normal 309,380, Hard 2,508,800
The payout stays within the table cap at every allowed stake and floor. The top floor cashes out by itself. Stake limits are on the Overhang page and the table settings are in Contracts.
Commit, reveal and proof
The wallet's seed chain for that level is committed onchain, and the drand salt is recorded, before the round opens. The round takes the chain's next index k, so the outcome is fixed before you stake. The server computes each drop only when it is requested and sends nothing about later drops. The seed c[k] is revealed in the settlement transaction. The published proof contains roundId, game, tableId, chainId, commit, index, seed, salt, clientSeed:"", nonce:0, overhangEntropy:"drand-hmac-key-v1", overhangRules, roundKey, stake, drops, toppleDrop, cashedAt, payout.
Reproducing a live Overhang round
Hash the seed k + 1 times and compare it with the onchain commit. Check the salt against the named drand beacon. Recompute roundKey, then toppleDrop, then the payout from your last accepted drop. A verifier cannot prove when requests arrived. For Overhang, timing cannot change the result, only when you stopped.
Crash Tower
Crash Tower has one shared table, crash-main. Every bet in a round rides the same crash point. The derivation below is the live rule. The server counts Real play as ready only when the vault's Crash Tower table is active with a maxPayoutBps of 400,000 (40×) and a 5 USDC maximum stake.
Crash point
message = "tilt:v1:crash:crash-main:" + k + ":" + salt + "::0:0"
block = HMAC-SHA256(key = c[k] bytes, message = UTF-8(message))
h = top52(block) # 0 .. 2^52 - 1
raw = floor(9800 * 2^52 / (100 * (2^52 - h))) # exact integer division
crashCents = min(4000, max(100, raw)) # 100 = 1.00×, 4000 = 40.00×
This is the house-game outcome stream with game crash, clientSeed empty, nonce 0 and cursor 0. Only the first block is used. k is the round's zero-based chain index and salt is the chain's drand salt, written as 0x plus 64 lowercase hex characters. The round ID is not part of the message.
raw is 100 × 0.98 / (1 - h/2^52), rounded down to a whole cent and worked out with integers only. 9800 is 10,000 minus the 200 bps house edge. There is no modulo step, so there is no modulo bias.
- Instant crash. raw is below 101 when h/2^52 < 3/101. Those rounds become 100 and crash at 1.00×, before anyone can cash out. That is about 2.97% of rounds.
- The cap. raw above 4000 becomes 4000. That is about 2.45% of rounds (0.98/40).
- Odds. For m from 101 to 4000 cents, P(crashCents ≥ m) = floor(98 × 2^52 / m) / 2^52, which is 0.98 / (m/100) to within 2^-52.
Curve and bust time
cents(t) = t <= 0 ? 100 : floor(100 * e^(0.00006 * t)) # t = ms since lift-off
bustMs = smallest whole t >= 0 with cents(t) >= crashCents # 0 for 1.00×
The server's clock is the authority. The reference uses JavaScript's Math.exp in double precision. bustMs only sets when the round ends on screen. crashCents is the value that settles bets.
Settlement
auto target a (101..4000): wins if a <= crashCents; cashedAt = a
manual cash-out at time t: accepted only if cents(t) < crashCents; cashedAt = cents(t)
payout = floor(stakeMicro * cashedAt / 100) # 0 for a lost bet
A bet with no earned cash-out when the round ends loses its stake. On a 40× round, an auto target of exactly 40× is paid. A manual press must come before the bust, so the highest manual cash-out on that round is 39.99×. A bet still riding at 40× loses its stake.
The exposure stop is a second way to end a bet. When the round's live profit reaches 25% of the bankroll, every open bet is cashed at the current multiplier, or at its auto target if that is lower. It does not change the crash point.
Commit, reveal and proof
The table's seed chain is committed onchain, and its drand salt is recorded, before its rounds open. Each round takes the chain's next index k when its betting window opens, so the crash point is fixed before anyone bets. During the climb the server sends only the time and the multiplier. When the round ends, the server settles it onchain and reveals c[k] after the settlement confirms. The published proof contains roundId, game:"crash", tableId:"crash-main", chainId, commit, index, seed, salt, clientSeed:"", nonce:0 and outcome {game:"crash", crashCents, bustMs}.
The proof does not list bets. Check your own stake, cash-out multiplier (cashedAt) and payout from your round record against the rule above. Stakes are in micro-USDC.
Test vectors
These are public test values, not live rounds. They come from a made-up test chain with 10,000 seeds, computed by calling the shared game code. Its commit is 0x3c53730f24a28a110a6c22a9c1817a37d31402214214fa686895b90eaa603654. The salt 0xca25ade0c98fbe9a233a2cc4351f251b7920d369f7e23cf77c5071339408227d is SHA-256 of the signature bytes of real evmnet drand round 21302527, the same salt as the Pinwheel vectors.
| k | Seed c[k] | top52(block) | raw | crashCents | bustMs |
|---|---|---|---|---|---|
| 4 | 0x035bd6633d6c63314774298e73be23981fa49c2420c35ba68172b4f5bc1b0e54 | 1898747427396416 | 169 | 169 (1.69×) | 8746 |
| 67 | 0x29c5a37c4c618eed6263d06bca8efc7a8857ebf9e8b0fde8cb971548ff48b35d | 21709905122677 | 98 | 100 (instant crash) | 0 |
| 16 | 0xef507437d8ced8df7446bcf38a42d0a469f77d6a1ab134d9e8861940163132fd | 4433387760498392 | 6286 | 4000 (40× cap) | 61482 |
The message for k = 4 is tilt:v1:crash:crash-main:4:0xca25ade0c98fbe9a233a2cc4351f251b7920d369f7e23cf77c5071339408227d::0:0 and its HMAC is 0x6bee695ed9b4081c808600d84aa2b6abeffb49907648d57f47968c741344546c. Each seed hashes k + 1 times to the commit. The shared code's boundary checks: h = 0 gives 100, h = 2^51 gives 196, and h = 2^52 - 1 gives 4000.
Reproducing a live Crash Tower round
Hash the seed k + 1 times and compare it with the onchain commit. Check the salt against the named drand beacon. Recompute crashCents and bustMs, then check your bet: a win needs a cash-out at or below crashCents (strictly below for a manual press) and pays floor(stake × cashedAt / 100). A verifier cannot prove when a manual press reached the server. Timing cannot change the crash point, only when you cashed out.
Pinwheel
Pinwheel has two tables. The seed hides the clash slots on a wheel of n shots. You fire pins one at a time, and pin p lands on slot p - 1. The first pin that lands on a clash slot ends the round. The derivation below is the signed live rule.
Pinwheel has two rules versions. Version 2 returns 97% and applies to rounds opened from the 97% release on. Version 1 returns 98% and applies to rounds opened before it. A round keeps the version it opened on, and its proof names it in pinwheelRules.version. The draw, seeds, salts and table IDs are the same in both versions. Only the ladder and maxPayoutBps differ.
| Level | tableId | Shots n | Clashes b | Top (most pins) | Rules version | Return | maxPayoutBps |
|---|---|---|---|---|---|---|---|
| Steady | pinwheel-steady | 20 | 1 | 19 | pinwheel-v2-steady-20 | 97% | 194,000 |
| Wild | pinwheel-wild | 10 | 2 | 8 | pinwheel-v2-wild-10 | 97% | 436,500 |
| Steady (earlier rounds) | pinwheel-steady | 20 | 1 | 19 | pinwheel-v1-steady-20 | 98% | 196,000 |
| Wild (earlier rounds) | pinwheel-wild | 10 | 2 | 8 | pinwheel-v1-wild-10 | 98% | 441,000 |
The four maxPayoutBps values are all different, so a round's cap also tells you its version. The vault freezes the cap when the round opens. A proof whose version and cap do not match one row above is refused, and so is any other version.
Clash slots
message_j = "tilt:v1:pinwheel:" + tableId + ":" + k + ":" + salt + "::0:" + j
block_j = HMAC-SHA256(key = c[k] bytes, message = UTF-8(message_j))
slots = []
for j = 0, 1, 2, ... while len(slots) < b:
v = top52(block_j)
if v >= 2^52 - (2^52 mod n): next j # modulo bias
slot = v mod n # 0 .. n-1
if slot in slots: next j # repeat
append slot to slots
clashShot = min(slots) + 1
This is the house-game outcome stream with game pinwheel, clientSeed empty and nonce 0. k is the round's zero-based chain index and salt is the chain's drand salt, written as 0x plus 64 lowercase hex characters. The level only selects the tableId and its n and b. The round ID is not part of the message. One cursor j runs through the whole draw, and a rejected cursor is skipped, not retried. The proof lists slots in the order they were drawn. The v1 in the message is the stream format, not the rules version, so both rules versions use this exact message.
Pin p clashes when p equals clashShot. Pins before it stick. If clashShot is above the top, every pin up to the top sticks: on Steady that is slot 19 (clashShot 20), on Wild the slots 8 and 9 (clashShot 9).
Ladder and payout
R = 97 for version 2, 98 for version 1 # from pinwheelRules.version
M(k) = R * C(n, b) / (100 * C(n - k, b)) # exact fraction, reduced
P(survive k pins) = C(n - k, b) / C(n, b)
payout = floor(stakeMicro * num / den) # 0 after a clash
displayedMultiplier = floor(100 * num / den) / 100
P(survive k) × M(k) is R/100 at every k. So the return is 97% wherever you stop on version 2, and 98% on version 1, before micro-unit flooring. Cash-out needs at least one stuck pin. Reaching the top cashes out by itself. maxPayoutBps is M(top) × 10,000. On version 2 that is 19.40× on Steady and 43.65× on Wild.
| Pins | Steady M(k) | Shown | Wild M(k) | Shown |
|---|---|---|---|---|
| 1 | 97/95 | 1.02 | 97/80 | 1.21 |
| 2 | 97/90 | 1.07 | 873/560 | 1.55 |
| 3 | 97/85 | 1.14 | 291/140 | 2.07 |
| 4 | 97/80 | 1.21 | 291/100 | 2.91 |
| 5 | 97/75 | 1.29 | 873/200 | 4.36 |
| 6 | 97/70 | 1.38 | 291/40 | 7.27 |
| 7 | 97/65 | 1.49 | 291/20 | 14.55 |
| 8 | 97/60 | 1.61 | 873/20 | 43.65 |
| 9 | 97/55 | 1.76 | ||
| 10 | 97/50 | 1.94 | ||
| 11 | 97/45 | 2.15 | ||
| 12 | 97/40 | 2.42 | ||
| 13 | 97/35 | 2.77 | ||
| 14 | 97/30 | 3.23 | ||
| 15 | 97/25 | 3.88 | ||
| 16 | 97/20 | 4.85 | ||
| 17 | 97/15 | 6.46 | ||
| 18 | 97/10 | 9.70 | ||
| 19 | 97/5 | 19.40 |
Version 1 ladder, for rounds opened before the 97% release. Top wins 19.60× on Steady and 44.10× on Wild.
| Pins | Steady M(k) | Shown | Wild M(k) | Shown |
|---|---|---|---|---|
| 1 | 98/95 | 1.03 | 49/40 | 1.22 |
| 2 | 49/45 | 1.08 | 63/40 | 1.57 |
| 3 | 98/85 | 1.15 | 21/10 | 2.10 |
| 4 | 49/40 | 1.22 | 147/50 | 2.94 |
| 5 | 98/75 | 1.30 | 441/100 | 4.41 |
| 6 | 7/5 | 1.40 | 147/20 | 7.35 |
| 7 | 98/65 | 1.50 | 147/10 | 14.70 |
| 8 | 49/30 | 1.63 | 441/10 | 44.10 |
| 9 | 98/55 | 1.78 | ||
| 10 | 49/25 | 1.96 | ||
| 11 | 98/45 | 2.17 | ||
| 12 | 49/20 | 2.45 | ||
| 13 | 14/5 | 2.80 | ||
| 14 | 49/15 | 3.26 | ||
| 15 | 98/25 | 3.92 | ||
| 16 | 49/10 | 4.90 | ||
| 17 | 98/15 | 6.53 | ||
| 18 | 49/5 | 9.80 | ||
| 19 | 98/5 | 19.60 |
The fraction sets the payout; the shown multiplier is floored separately. Stake limits are on the Pinwheel page.
Commit, reveal and proof
The seed chain is committed onchain, and its drand salt is recorded, before the round opens. The round takes the chain's index k, so the clash slots are fixed before you stake. The server answers each pin only with stuck or clash, and sends nothing about later pins. The seed c[k] is revealed in the settlement transaction. The published proof contains roundId, game:"pinwheel", tableId, chainId, commit, index, seed, salt, clientSeed:"", nonce:0, entropy:"drand-hmac-v1", pinwheelRules {version, shots, clashes, top, maxPayoutBps, maxStake} and outcome {game, slots, clashShot, pinsFired, pinsStuck, result, multiplier {num, den}, stake, payout}. Both versions use this shape.
pinsFired counts a clashing pin. result is clash or cashout; a run to the top is a cashout. A clash has pinsStuck = clashShot - 1, multiplier 0/1 and payout 0. Stakes are in micro-USDC.
A clash pays 0 on either ladder, so a clash proof alone cannot show its version. Compare pinwheelRules.maxPayoutBps with the cap the vault froze for that round. A cash-out proof is tied to its version by its multiplier and payout.
Test vectors
Public test values from pinwheel-live-v2-proofs.json (version 2) and pinwheel-live-proofs.json (version 1). Both rounds use chain index k = 3 of the same test chain, with seed c[3] 0xc5d880db8746cd1e7df0b00d006a8b0408895676f0a0e7c496e8886381b9cdaf and commit 0xaa746801e117563edd7a12848efde4c4e1b8f43636f31e426021749d1dbbc449. The salt 0xca25ade0c98fbe9a233a2cc4351f251b7920d369f7e23cf77c5071339408227d is SHA-256 of the signature bytes of real evmnet drand round 21302527. The slots are the same in both versions; only the cash-out pays differently.
| Field | Steady | Wild |
|---|---|---|
| tableId | pinwheel-steady | pinwheel-wild |
| Slots, clashShot | [17], 18 | [2, 8], 3 |
| Play | 4 pins, then cash out | 3 pins; pin 3 clashes |
| Stake (micro-USDC) | 3000000 | 1500000 |
| Version 2: multiplier, payout | 97/80, 3637500 (3.6375 USDC) | 0/1, 0 |
| Version 1: multiplier, payout | 49/40, 3675000 (3.675 USDC) | 0/1, 0 |
More version 2 results from the same file. Steady, same round, cash out at 17 pins with stake 100000 (0.10 USDC): 97/15, payout 646666. Steady top run, seed 0x1111…11 (32 bytes of 0x11), salt 0x2222…22, k = 7: slots [19], clashShot 20, 19 pins at 97/5; stake 5000000 pays 97000000 and stake 100000 pays 1940000. Wild top run, same seed and salt, k = 22: slots [9, 8], clashShot 9, 8 pins at 873/20; stake 4640000 pays 202536000.
A Wild draw with repeats, from pinwheel-live.json (the same draw is in pinwheel-live-v2.json): seed 0x1e75c6b6baed1738b06abd94324aacc8611aca5df82ee90a17fd1c7dc2952c5e, k = 4, salt 0xbfaac098e61f4a0ff4b8b66b1ffe2d7d02de9c0c2751118a3970f79479a87535. Cursors 0 to 3 give top52 values 1190139122760049 (slot 9, kept), 3431166830078039 (9, repeat), 1610848694502099 (9, repeat) and 4295229509113292 (slot 2, kept). Slots [9, 2], clashShot 3. The first message is tilt:v1:pinwheel:pinwheel-wild:4:0xbfaac098e61f4a0ff4b8b66b1ffe2d7d02de9c0c2751118a3970f79479a87535::0:0.
Reproducing a live Pinwheel round
Hash the seed k + 1 times and compare it with the onchain commit. Check the salt against the named drand beacon. Read the rules version from the proof and check its terms against the table above. Recompute the slots and clashShot, then the result and payout from pinsFired, the stake and that version's ladder. A verifier cannot prove when requests arrived. For Pinwheel, timing cannot change the clash slots, only when you stopped.
Hold'em Coming soon
Wick Coming soon
Precision and confirmation limits
Live chain seeds hash bytes. Dice's roll mapping and Blackout's payout fractions use integer math. Financial confirmation waits for twelve canonical L2 blocks and a canonical hash check; that policy does not claim irrevocable L1/bridge finality.
Publication and recovery
The server durably saves exact final allocations before submitting an opaque seal. Only after twelve canonical L2 confirmations does it expose the matching seed/payout preimage. The vault checks the seal, chain and frozen allocation caps; outcome arithmetic remains in the game verifier. Sealed outcomes cannot become refunds. If the private journal and unpublished preimage are both lost, safe unconditional recovery is not available.
Reference verifiers
House proofs use the shared RNG/math/Crash/Dice/Blackout helpers (and the Overhang and Pinwheel helpers) and the page verifier. Copy the proof inputs exactly, hash seed bytes through the chain, recompute the stream and compare the result/payout. The API's own ok:true is useful but is not independent local recomputation.
Use the proof controls inside the game you played. The verification guide shows how to check a completed round.