Provably fair

Shared rounds can’t use your seeds, since everyone plays the same round. Each game has a hash chain instead: we generated a secret, hashed it millions of times, and published the last hash (the terminal) before the first round. Rounds use the chain backwards, so each round’s seed hashes to the previous round’s seed and none can be changed or picked later.

To stop us from knowing results in advance, each round’s seed is mixed with a drand beacon that’s only published after betting closes: round hash = HMAC-SHA256(seed, drand randomness).

Crash

h = first 13 hex digits of the round hash. Crash point = (10000 − edge bps) × 100 × 2⁵² / ((2⁵² − h) × 10000) cents, at least 1.00×.

Roulette

slot = floor(float of the hash’s first 4 bytes × 15). Slot 0 is the bonus (14×), 1–7 are T and 8–14 are CT (2×).

Dust2

The hash draws the result first: CT win when the float of bytes 0–4 is below ½, T otherwise (1.92× each), and an ace when the float of bytes 4–8 is below 1/15 (14×). Then the round is played: attempt k’s seed is the first 16 bytes of HMAC-SHA256(round hash, “dust2:k”), and each attempt runs the whole bot simulation from it, every move, shot, flash, plant and defuse, for k = 0, 1, 2… until one ends the drawn way (same winner, and an ace exactly when drawn, by a winning player). That first match is the round everyone watches. If none of the first 50,000 attempts matches, the round is void and bets are refunded.

drand network

quicknet, bls-unchained-g1-rfc9380, a beacon every 3s

Chain hash

52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971

Public key

83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a

Every round page (open one from the history strip on Crash, Roulette or Dust2) checks the chain link, fetches the beacon from drand and recomputes the result. Dust2 round pages also re-run attempts 0…k in your browser with the same WebAssembly simulation the server uses, compare the played round’s event log hash, and replay it on the radar.

A battle can’t use anyone’s seeds either: every seat opens from the same draw. Its server seed is committed by its SHA-256 hash when the battle is created, before anyone joins. When the last seat fills, the battle takes the first drand beacon published after that moment, which nobody (players or us) can know in advance. Battle hash = HMAC-SHA256(server seed, drand randomness).

Openings

Seat s (from 0) in round r (from 0): float₀ of HMAC-SHA256(battle hash, "seat:s:r:0"), read as a case ticket, floor(float₀ × 100000) + 1. The item is the one whose range in that round’s case version holds the ticket, as in Cases.

Classic

The team (or player) with the highest total wins; with Crazy, the lowest.

Terminal

Only the last case counts toward the winner. Everything opened is still in the pot.

Jackpot

roll = float₀ of HMAC-SHA256(battle hash, "winner:0:0"). Teams line up in seat order, each as wide as its total in cents; the team at floor(roll × pot in cents) wins. A bigger haul is a bigger chance, not a sure win.

Ties

The tied teams in seat order; the winner is number floor(roll × tied count), with the same roll as Jackpot.

Splitting

One winner takes everything opened. A winning team (or every seat in Shared) splits the pot equally by value, rounded down to the cent: skins opened in the battle go, most valuable first, to whoever has room for them; catalog skins drawn from HMAC-SHA256(battle hash, "share:k:0:…") fill each share, and coins make up what no skin fits. A bot’s share stays with the house.

Each finished battle’s page runs every one of these steps in your browser under Fairness › Verify this battle: the seed against its hash, the beacon against drand, every ticket and item against the case versions, the winner and the shares. Case battles

You hold a seed pair: our server seed, secret but committed by its SHA-256 hash before you bet, and your client seed, which you can change. Each bet uses the next nonce (0, 1, 2…). Rotating reveals the server seed, so all bets made with it become checkable.

To move the nonce on without staking anything, place a zero bet: an amount of 0 in Dice, Plinko, Keno, Mines, Beef, Blackjack or Video Poker. It takes the next nonce like any bet and checks the same way, but no coins move and it counts toward nothing (rakeback, wagering, VIP levels, leaderboards). Up to five zero bets a second.

Randomness comes in blocks: block k = HMAC-SHA256(server seed, "client seed:nonce:k"). Each block gives 8 floats, 4 bytes each: float = b₀/256 + b₁/256² + b₂/256³ + b₃/256⁴.

Dice

roll = floor(float₀ × 10000) / 100, from 0.00 to 99.99. Over wins when roll > target, under when roll < target.

Plinko

one float per row: floor(float × 2) is left (0) or right (1). The slot is the number of rights.

Mines

tiles 0–24 in a pool; each mine takes pool[floor(floatᵢ × pool size)] and leaves the pool.

Keno

10 numbers drawn the same way from 1–40. Your hits pick the payout in the table for your pick count (1–10) and risk (Classic, Low, Medium or High).

Beef

positions 0–19 in a pool; the 1, 3, 5 or 10 death points are drawn like Mines. The cow steps onto 0, 1, 2… and dies on the first death point.

Blackjack

card i of the shoe = floor(floatᵢ × 52), an infinite deck. Dealt you, dealer, you, dealer, then hits in order.

Video Poker

a 52-card deck shuffled like Mines’ pool. The deal is cards 0–4; each discard is replaced from card 5 on.

Cases

ticket = floor(float₀ × 100000) + 1. Each item owns a ticket range; the case version’s odds hash commits to all ranges.

Upgrade

roll = floor(float₀ × 1000000), from 0 to 999999. chance = floor(stake × (1 − edge) × 1000000 / the targets’ value), 0.1% to 80%. Under wins when roll < chance, over when roll ≥ 1000000 − chance.

In Rock Paper Scissors the randomness is the players themselves, so there’s no seed to check. What matters is that nobody sees a move early: not the opponent, and not us.

Commit

Each round, your browser picks a random salt and sends only sha256("move:salt"), for example sha256("rock:3f9a…"). Your move and salt stay in your browser.

Reveal

Once both players are locked in, each browser sends its move and salt. The server checks they hash to the commitment before scoring the round, so a move can’t change after the opponent’s is known.

Series

Rock Paper Scissors runs best of 3, 5 or 7: first to 2, 3 or 4 round wins. A tie is replayed. The winner gets both stakes minus the rake (0% now).

Clock

Each round has a deadline. Whoever hasn’t locked in (or revealed) by then loses the round. If neither has, the match ends: whoever is ahead wins, and a level score refunds both stakes.

Match seeds

Games with a random part (a toss, a deck) draw it from the match’s seeds. We pick a server seed when a match opens and show its SHA-256 hash in the lobby; each player’s browser adds a client seed, the joiner’s only after the hash is public. Floats come from HMAC-SHA256(server seed, "creator seed:joiner seed:nonce:k") exactly like the single-player games, with a nonce the game defines. The server seed is revealed when the match ends.

Every match page lists each round’s commitments, moves and salts, and recomputes the hashes and winners in your browser.

Connect Four has no hidden information: every drop is public, and the board is the moves replayed in order. Each match page replays every game in your browser, checks that each drop was legal and that the result follows from the board.

Toss

Who drops first in game 1: floor(float₀ × 2) with nonce 0, where 0 is the creator and 1 the joiner. Game 2 starts with the other player, game 3 with the first again, and so on (replayed draws count as games).

Win

Four or more of your discs in a row across, up or diagonally. A full board (42 discs) without one is a draw and is replayed.

Clock

Chess style, picked by the creator: each side has 1:30, 3 or 5 minutes per game plus 2 or 3 seconds added after each drop, running only on its turn and timed by the server. A flag that falls loses the game.

Heads-up No-Limit Hold’em, played as a freezeout. Every hand gets a fresh shuffled deck from the match seeds, so the server can’t stack it and neither player can choose it. The server deals, and sends each player only their own hole cards and the board as it comes; the other player’s cards travel only at a showdown. When the match ends the server seed is revealed and the match page replays every hand.

Deck

Hand n uses nonce n: 52 floats, and the deck is drawn like Video Poker’s, each float picking one of the cards still in the pool (floor(float × cards left)). Cards 0–1 are the creator’s, 2–3 the joiner’s, 4–6 the flop, 7 the turn and 8 the river. Cards are numbered rank + 13 × suit, two to ace, spades, hearts, diamonds, clubs.

Button

Hand 1’s button is floor(float₀ × 2) with nonce 0 (0 is the creator), then it alternates. The button posts the small blind.

Showdown

The best five of seven cards wins the matched pot; chips the other player couldn’t match go back. An exact tie splits the pot, the odd chip to the big blind.

Structure

1,000 chips each. Blinds 5/10 with a 1-chip ante, rising every 5 hands up to 300/600 with a 60 ante. 20 seconds a decision plus a 30-second time bank for the match; out of time you check or fold, three misses in a row lose the match (both players missing ends it with both stakes back).

In the races both players get the same puzzle, and nobody may know it before the round starts. Each match makes a server seed when it opens and shows only its sha256 hash; the creator's browser adds a client seed then, and the joiner's browser adds one after the hash is public. Round n draws its floats from HMAC-SHA256(server seed, "creator seed:joiner seed:n:cursor"), the same bytes as the single-player games, so neither we nor either player picks the puzzle. When the match is over the server seed is revealed: paste the three seeds below (a match page's link fills them in) and the puzzle of any round comes out.

Moves are checked and timed on the server. Results no person could reach (a solve in seconds, typing faster than anyone types, machine-even timing, two seats on one network) hold the payout until support has looked at the match.

Blocks, Flap and 8 Ball use the first 32 bytes of that stream (cursor 0) as the round’s seed: the pieces, the pipes or the rack come from it. Blocks and Flap give it to both browsers at the start, because each plays its own run; the server replays every key press with the same simulation and scores the runs itself. In 8 Ball the server plays every stroke. Every log and shot is published when the round is over, and the match page replays them in your browser.