Provably Fair
Before you bet, the result is already locked. After you play, you can open the seed, run the hash, and confirm the outcome yourself. No trust required — just math.
How It Works
Before betting opens, the server generates a secret seed and publishes SHA-256(seed) as a public fingerprint. The result is locked. We can't change it — and neither can you.
The round runs. Every outcome — the crash point, the winning number, the card order — was already determined by the committed seed before a single chip was placed.
The seed is revealed. Hash it yourself in the verifier below. If it matches the commit hash published before the round, the result was fair. If it doesn't, we cheated.
The commit hash is on the table before you bet. After that, the result is sealed — by cryptography, not by our word. We can't pick winners. We can't see the outcome before you can. We can't adjust the edge based on your balance or history. Every single result is independently auditable by anyone with a SHA-256 function.
Game-by-Game Breakdown
The commit hash is published before the race begins. Start prices are snapshotted and included in the hash so the server cannot swap them after the fact. Once the race ends the server seed is revealed — you can recompute the hash yourself and confirm it matches.
Server seed, start prices (locked at countdown), race number
The crash point is pre-determined before any player places a bet. During betting, SHA256(serverSeed) is committed. After the round, the seed is revealed for verification. Formula: crash point = 0.85 / r, where r is the first 8 hex chars of the combined hash converted to a float in (0,1). Result is clamped to 1.01x – 50.00x. The 0.85 numerator reflects a 15% house edge on the crash formula; combined with the 5% jackpot pool that is fully returned to players long-run, total player RTP is 90%.
Server seed, client seed (generated at countdown), round number
Each bet is committed individually at placement time. The target price, resolve time, and bet ID are hashed with a server seed before you know the outcome. After resolution the seed is revealed — you can recompute the hash and confirm it matches.
Server seed, target price, resolve time, bet ID
The winning number for each spin is calculated before the wheel turns. The ball lands where the math says it will — not where the house wants. Every spin result is independently verifiable.
Server seed, client seed (server-generated per round), round number
Monster stat rolls, battle damage, ability triggers, and dodge/crit rolls all derive from a seeded RNG chain. The commit hash is published before pairing begins. After the result, the server seed is revealed so you can replay every roll and confirm the battle played out honestly.
Server seed, client seed, round number, sequence counter
Bounty Hold'em uses a dual commit-reveal system. During betting, the server commits SHA-256(serverSeed) and each player commits SHA-256(theirSeed). At dealing, all player seed hashes are combined with server entropy to form the final clientSeed used to shuffle. After showdown, both server and client seeds are revealed. Players can verify their seed was included in the shuffle and that SHA-256(serverSeed) matches the committed hash. Neither side can manipulate the deck alone.
Server seed, player-committed client seeds (combined), round number
Each key purchase produces a unique HMAC-SHA256 digest. The hit damage and Lucky Strike roll are derived from the first bytes of this digest. The server seed is committed at vault creation and revealed when the vault breaks — you can verify every individual hit replayed the same way using the revealed seed.
Server seed (per-vault), player ID, key purchase index
Before betting opens the server generates a secret seed and publishes SHA-256(serverSeed) as the commit hash. The hit target is determined by the combined hash — neither party can predict or influence the result. The Golden Star card is selected independently using cryptographic rejection sampling (no modulo bias). After the result phase, the server seed is revealed so you can verify the hit target and star card yourself.
Server seed, client seed, round number
At session start the server generates a secret seed and publishes SHA-256(serverSeed) as the commit hash. Mine positions are placed using a Fisher-Yates shuffle driven by HMAC-SHA256 with rejection sampling — no modulo bias. After the session ends (cashout or mine hit), the server seed and full mine map are revealed. You can reproduce the exact shuffle in your browser using the disclosed seed, your client seed, and the session ID — every mine position is deterministic and verifiable.
Server seed (per session), player client seed, session ID
Each player has their own serverSeed cycle. Before your first spin the server publishes SHA-256(serverSeed) as the commit hash. Each reel stop is derived independently using HMAC-SHA256 with rejection sampling — no modulo bias. After the spin the original serverSeed is revealed so you can verify every reel position, then a new seed is committed for the next spin. Your client seed is mixed in, so neither party can manipulate results alone.
Server seed (per-player session), player client seed, spin nonce, reel index
Before the match begins the server generates a random serverSeed and publishes SHA-256(serverSeed) as the commitHash. The rack is built from a deterministic Fisher-Yates shuffle seeded by the serverSeed — neither player can know the ball order in advance. All shot physics run server-side. At match end, the full serverSeed is revealed so you can verify the initial rack layout was not manipulated.
Server seed (per-match), used to deterministically shuffle the rack using Fisher-Yates
Verify It Yourself
Paste the revealed seed and any additional inputs from a completed round. Runs entirely in your browser — nothing is sent to our servers. If the computed hash matches the commit hash published before that round, the result was honest.
For Price Race: paste seed + JSON.stringify(startPrices) + raceNumber as one string, or fill in the fields below.
Appended to the seed before hashing. Use this for start prices + race number, round number, etc.
Transparent House Edge
Every game publishes its edge in the formula cards above. CryptoCrash uses a 15% house edge factor built into the crash formula (crashPoint = 0.85 / r), delivering 85% RTP from crash payouts plus 5% from jackpots long-run — 90% total player return. Paydirt is 3% — in the multiplier formula itself. Every other game's math is in the hash formula card for that game.
The edge is fixed for every player, every bet, every round. It doesn't change based on your history, your balance, or whether you're on a hot streak. That consistency is the point — a fair edge you can calculate is better than a mystery percentage you have to take on faith.