Keno Verifier

The mechanics of digital Keno draws

Online Keno requires you to select a set of numbers (typically up to 10 or 15) from a pool of 80 options. The casino then draws 20 winning numbers. If your selected numbers match the drawn numbers, you win a payout based on your hit ratio.

Because the draw happens instantly in a digital environment, it is easy to feel skeptical, especially when you miss a high-match draw. A provably fair Keno verifier (or our general universal verifier) reproduces the exact drawing sequence by running your seeds through a standard shuffling algorithm, confirming that the drawn numbers were locked in before the round started.

The math: Fisher-Yates Keno shuffling

To ensure a completely random, duplicate-free draw, the verifier uses the standard **Fisher-Yates Shuffle** powered by your seeds:

1. Initializing the board array

The verifier first creates a sorted array containing all 80 numbers on a standard Keno board:

Board = [1, 2, 3, ..., 80]

2. Running the HMAC-driven shuffle

Starting from the end of the array (index 79) down to index 60 (to get 20 numbers), the verifier extracts a random float U from the HMAC-SHA256 seed stream:

U = Hex_To_Decimal(4_Bytes_i) / 4294967296

It then maps this float to an integer index j between 0 and the current index i:

j = Floor(U * (i + 1))

3. Swapping the elements

The verifier swaps the element at the current index i with the element at the random index j:

Temp = Board[i]; Board[i] = Board[j]; Board[j] = Temp;

This shuffle is repeated exactly 20 times. The final 20 shuffled numbers at the end of the array represent the winning Keno draw.

Data Sandwich: Auditing a 20-number Keno draw

Let’s audit a Keno draw. You bet on 5 numbers: [12, 24, 38, 45, 72]. The casino draws their 20 numbers, and you hit a solid 4-match payout.

To verify the draw was random, you rotate your seeds and paste the details into the verifier:

• Server Seed: c18f2d...
• Client Seed: keno_player_luck
• Nonce: 54

The verifier initializes the array [1..80] and runs the HMAC shuffle.

For the first draw (index 79), the HMAC stream yields a decimal float of 0.154283.

The target index is calculated as: Floor(0.154283 * 80) = 12.

The verifier swaps Board[79] (80) with Board[12] (13). The number 13 becomes the first drawn number.

This loop continues for 20 steps, yielding the exact drawing list of 20 numbers shown in your game history. The draw is cryptographically validated as fair.

Frequently asked questions