BITS-LAND
Login Register
Transparency Lab

Provably Fair checker for all Bits-Land Play game modes

On this page you can switch between all games, compare hashes, seeds and ticket ranges, and manually recalculate the result right in your browser. Supported games are verified fully on the client, and for the remaining tabs we honestly show the current state of the integration.

Games
10
separate switchers
Live Verify
3
Crash, Roulette, Jackpot
Entropy
2
Limbo and Plinko

Choose a game

The switchers show the real verification status based on the current project code.

Crash verifier

Crash point verification

Uses the same HMAC-SHA256 and the same formula from the Go server: the key is the public `server_seed_hash`, the message is `round_id`.

Formula: `h = hash[:13]` → `h % 33 == 0 ? 1.00 : floor(((100*2^52-h)/(2^52-h))*100)/100/100`
Enter the Crash round parameters to recalculate the hash and crash point.
Roulette verifier

Winning number and color verification

Roulette requires a revealed server seed. The page checks the SHA-256 of the seed, computes the HMAC of `round_id` and takes the first 8 bytes mod 15.

Formula: `winningNumber = bigInt(resultHash[:16]) % 15`
Add a server seed and round id to get the winning number, color and hashes.
Jackpot verifier

Winner verification by ticket range

Jackpot can be recalculated if you have the server seed, round id, total pot and each participant's ticket ranges.

Formula: `threshold = uint64(sha256(seed:round)[:8]) / maxUint * totalPot`
Paste the ticket ranges so the page can compute the threshold and determine the winner id.
CoinFlip Battle verifier

PvP flip verification

Requires a revealed server seed and round id. The page checks the SHA-256 of the seed and computes HMAC-SHA256(server_seed, "round_id:coinflip"); an even first byte → heads, an odd one → tails.

Formula: `side = HMAC(seed, "round:coinflip")[0] & 1 ? tails : heads`
Add a server seed and round id to recalculate the resulting side and hashes.
Dice Duel verifier

PvP dice duel verification

Requires a revealed server seed and round id. Each player's roll = HMAC-SHA256(server_seed, "round_id:dice:seat"), first 8 bytes → uint64 → [0,100). Higher wins (on a tie, the creator).

Formula: `roll = uint64(HMAC[:8]) / 2^64 × 100`
Add a server seed and round id to recalculate both rolls and the winner.
Mines Battle verifier

Mine positions verification

Requires a revealed server seed and round id. Mines = Fisher–Yates permutation [0..24], driven by the bytes of HMAC-SHA256(server_seed, "round_id:mines:0"); the first 5 elements are taken.

Formula: `shuffle(perm, bytes); mines = perm[:5]`
Add a server seed and round id to recalculate the mine positions.
Limbo verifier

Multiplier verification (Stake-style)

After rotate your server_seed becomes public. Enter it, the client_seed and nonce — the page recalculates the multiplier with the same algorithm as the server.

Formula: `h = HMAC(server,"client:nonce:0")[:13]` → `multiplier = floor(0.99 / (h/2^52) × 100)/100`
Enter the server_seed (after rotate), client_seed and nonce — the page will show the multiplier.
Plinko verifier

Path and bucket verification (Stake-style)

Plinko takes the first 16 hex of HMAC(server, "client:nonce:0") → uint64 → path bits. After rotate, enter your seeds.

`bit i = (uint64(randomBytes) >> i) & 1`
Enter rows, risk and entropy bytes to get the path, bucket, multiplier and HMAC hash.
Dice verifier

Dice (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `roll = floor(float × 10001)/100 → win = condition(roll, target)`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Coin Flip verifier

Coin Flip (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `side = float < 0.5 ? heads : tails`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Mines verifier

Mines (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `mine_positions = Fisher–Yates shuffle(0..24) → take first mines_count`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Tower verifier

Tower (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `Each level: shuffle positions → first N as traps, then per-cell check of special blocks`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Lucky Wheel verifier

Lucky Wheel (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `threshold = float × Σweights → pick the prize by accumulating weights`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Glass Bridge verifier

Glass Bridge (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `safe_sides[i] = shuffle(0..size)[i] % 2 === 0 ? "left" : "right" (size = max(rows*2, 24))`
Enter the parameters — the page recalculates the result and compares it with what the server showed.
Road verifier

Road (Stake-style)

After rotate your server_seed is published. Enter it, the client_seed and the bet nonce — the page recalculates the result.

Formula: `survival_pattern[i] = floats(tiles)[i] < p_difficulty (24 steps)`
Enter the parameters — the page recalculates the result and compares it with what the server showed.