
Keno
Independent verification, backed by open-source code.
- Live Bets Verified
- 5,100
- Parity Rate
- 100%
- Simulated RoundsSimulated RTP 99.970%
- 40M
- Simulated RTP 99.970%
- Proven RTP · base tier
- 99.9%
- Base stake tier, all 40 configurations
Verification pipeline
Real bets. Independently reproduced.
Placed anonymously at Duel.com. We rebuilt the game logic from scratch and matched all 5,100 recorded outcomes.
The casino result, reproduced.
- Casino outcome
- 0 / 10 hits
- Our reproduction
- 0 / 10 hits
- Recorded payout
- $0.0000
- Seed Hash IntegrityPass
- Commitment LinkagePass
- Hash ConsistencyPass
- Draw RecomputationPass
- Client Seed InfluencePass
- Payout MathPass
- Multiplier ProvenancePass
- Bet-Size InvariancePass
- Config & Cell CoveragePass
- Captured Edge FieldsPass
- Consolation DisclosurePass
- Population & PhasesPass
- Dataset HashPass
- Epoch SizePass
- Hit Symmetry (Hypergeom.)Pass
- Anti-Circularity + ClaimPass
- Client Seed VariationPass
- Simulation Pass 1Pass
- Cherry-Pick Test (Pass 2)Pass
- Artifact IntegrityPass
- Draw Bias BoundPass
- Verifier ParityPass
The repo is the credential. Every finding ships as code. At release v1.2.1, npm test runs 30 unit tests and all 23 scored steps against the 5,100 captured bets, then compares the fresh results with the committed ones. It prints 22 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, and exits 0.
PROVABLY FAIR — Full Pass. We captured 5,100 real Keno bets on Duel.com on 11 April 2026 and recomputed every drawn set and payout with our own implementation, written from the specification. 22 of 23 steps pass, with one capture flag (two nonces our capture script missed, not a Duel issue) and no hard fails. Certified under ProvablyFair.org Framework 1.1 at release v1.2.1.
Audit Verdict
| Check | Result | Evidence |
|---|---|---|
| Overall Status | Pass | PROVABLY FAIR — Full Pass. 22 of 23 steps pass, 1 capture flag, 0 hard fails (Framework 1.1, release v1.2.1). The capture flag is Step 4: limited by our capture script, not a Duel issue. |
| Proven RTP | Pass | 99.9000% on all 40 configurations at the base stake tier, from independently derived hypergeometric probabilities and the pinned paytable (Step 17). RTP claim (RTP-CLAIM 1.2.0): Duel's game settings state an edge for every stake tier; all 2,712 rows sit on their stated figure, 0 beyond the ±0.1 pp band: PASS (Step 17). Simulated: 99.970% over 40M rounds |
| Live ↔︎ Verifier Parity | Pass | 5,100 / 5,100 drawn sets reproduced (Step 5). Both ProvablyFair.org verifiers, this site's and the main site's, and Duel's Verify-tab code, run unmodified as a cross-check, reproduce all 5,100 (Step 23) |
| Commit-Reveal System | Pass | 102 / 102 revealed server seeds hash to their commitments; 105 forward links plus the pre-capture anchor are consistent (Steps 1–3). That each commitment was shown before its bets rests on the capture's rotation records |
| Nonce Audit | Capture flag | 100 / 102 epochs complete, no repeats, none out of order. Two nonces were missed when our capture script retried a request: limited by our capture script, not a Duel issue (Step 4) |
| Client Seed | Pass | A genuine HMAC input: a wrong client seed and an empty one each change all 5,100 draws (Step 6); the 100 Phase D bets recompute (Step 9) under two auditor-set seeds (Step 18). Duel's default seed is generated in the browser and players can set their own |
| RNG Analysis | Pass | Our own HMAC-SHA256 backward Fisher–Yates implementation, written from the specification, reproduces every draw; every swap index is exactly uniform, and 0 of 198,900 captured shuffle steps rejected a value (Steps 5, 22) |
| Payout Logic | Pass | 2,209 paying bets and 2,891 zero-paying bets settled exactly (integer units, no tolerance); every served multiplier equals the pinned paytable cell at 13 decimal places (Steps 7, 8) |
| Scaling House Edge | Info | Every captured bet was priced at the 0.1% tier. Duel's 5 October 2026 config adds tiers up to 1.0% above a threshold ($90.20 to $99,546.07) in 35 of the 40 configurations. Explained from the config, not certified |
| Anti-Circularity | Pass | P(hits) from C(n,k) × C(40−n, 10−k) / C(40,10), not the casino's probability field; exact rational RTP equals 999/1000 on 16 configurations and is within 1.125×10⁻¹⁶ on the rest (Step 17) |
| Fairness Integrity | Pass | 15 standard fairness integrity tests — 14 pass, 1 N/A (single-step game) |
| Determinism | Pass | Every draw recomputes from (serverSeed, clientSeed, nonce); no pick, risk or stake input (Step 5) |
| Reproducibility | Pass | npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results |
Overall StatusPass
v1.2.1). The capture flag is Step 4: limited by our capture script, not a Duel issue.Proven RTPPass
Live ↔︎ Verifier ParityPass
Commit-Reveal SystemPass
Nonce AuditCapture flag
Client SeedPass
RNG AnalysisPass
Payout LogicPass
Scaling House EdgeInfo
Anti-CircularityPass
Fairness IntegrityPass
DeterminismPass
ReproducibilityPass
npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed resultsWhat Was Audited
✓ Audited
- Every draw is set by the server seed, client seed and nonce, and recomputes exactly (5,100 / 5,100)
- Your picks, risk level and stake are not inputs to the draw
- Revealed server seeds match their commitments (102 / 102), and the 106 seed records fit together
- Your client seed is a genuine input: changing it changes the draw
- Every payout is exact, and every served multiplier equals the pinned paytable
- Theoretical RTP is 99.9000% on all 40 configurations, matching the 0.1% edge Duel's game settings state for the base stake tier
- The draw is the same at $0.01 and $10
- Players can check every bet
What Audit Excludes
- Scaling house edge above the base stake tier (up to 1.0%) — explained from the config in S4.5
- Max win
- Rakeback, Zero Edge and promotions — 99.9% is the proven RTP; these are operator-side
- Autopick — every captured pick set came from our capture script
- Cross-account sampling
- Duel's server code and seed generation — outcomes are verified from the captured rounds and their commitments
- Infrastructure or server security
- Wallet, payments, or operational systems outside game logic
What Audit Covers
| Area | Description |
|---|---|
| Commit-Reveal System | SHA-256 server seed hashing, the forward commitment chain, reveal on rotation |
| Client Seed Origin | Browser-generated default, player-customisable; the capture's own seeds disclosed |
| Seed Handling | Client seed control, nonce lifecycle, seed pair rotation |
| RNG Analysis | HMAC-SHA256 backward Fisher–Yates over 40 numbers, written from the specification; rejection sampling, bias bound |
| Payout Logic | Exact settlement, 13-decimal multipliers, paytable provenance, consolation cells, stake invariance (Phase D) |
| Live Parity | Our recomputation, Duel's Verify-tab code (cross-check) and both ProvablyFair.org verifiers against every live bet |
| RTP Validation | Anti-circularity (hypergeometric), exact rational RTP, RTP claim rule, 40M-round simulation, cherry-pick test (Pass 2) |
| Fairness Integrity | Standard integrity matrix — 15 tests across commit-reveal, determinism, payout, isolation, and parameter enforcement |
| Game Profile Coverage | All 32 Keno profile checks mapped to a step, a package check, or n/a |
What Audit Guarantees
- Outcomes are deterministic and reproducible from the recorded inputs
- Live results match our recomputation for every captured bet (5,100 / 5,100)
- At the base stake tier, theoretical RTP is 99.9000% on all 40 configurations, derived from hypergeometric probabilities and the paytable alone
- Duel's stated edge holds under the RTP claim rule: 0 of 2,712 rows beyond ±0.1 pp
- The client seed is a genuine input: a wrong seed changes all 5,100 draws
- Your picks, risk and stake are not inputs to the draw
References
Keno — Game Rules7 sections▶
Keno is a draw-based lottery game: pick 1–10 numbers on a 40-number grid, choose a risk level, and watch 10 numbers get drawn. The more of your picks that hit, the bigger the payout.
Game Rules
Keno is a draw-based lottery game. Before the round you pick between 1 and 10 numbers from a 40-number grid (your 'picks') and choose a risk level — Classic, Low, Medium, or High — which shapes the payout curve. The platform then draws 10 numbers from the same grid using a backward Fisher-Yates shuffle seeded with HMAC-SHA256. Your payout depends on how many of your picks land in those 10 drawn numbers: more hits means a bigger multiplier, and higher risk levels shift more of the reward toward rare full-hit outcomes.
How to Play
1. Choose picks — Select between 1 and 10 numbers from the 40-number grid.
2. Choose risk level — Select Classic, Low, Medium, or High. Higher risk shifts payout weight toward rare large hits.
3. Enter bet amount — Choose how much to wager.
4. Draw — The platform draws 10 numbers via the backward Fisher-Yates shuffle.
5. Outcome — Payout = bet amount × multiplier for your hit count.
Win Conditions
The win condition in Keno depends on how many of your picks match the 10 drawn numbers.
| Outcome | Condition | Example (HIGH picks=10) |
|---|---|---|
| Jackpot (all hits) | All picks match drawn numbers | 10/10 hits → 1200× — ~1 in 847 million chance |
| Win (partial hits) | Several picks match drawn | 6/10 hits → 13.1× |
| Loss | Too few picks match | 0–3/10 hits → 0× |
Risk vs Reward
The core mechanic of Keno is the tradeoff between pick count, risk level, and payout shape.
- Pick count controls hit probability — more picks means more chances to match, and the multipliers scale to keep the same RTP
- Risk level controls payout shape — Classic has moderate variance; High concentrates value at rare full-hit outcomes with 0× on low hit counts
- RTP is the same at the base tier — all 40 configurations return 99.9% there, whatever the picks or risk
Parameters
| Parameter | Value | Notes |
|---|---|---|
| Grid Size | 40 (numbers 1–40) | Fixed; all draws from this pool |
| Numbers Drawn | 10 per round | Fixed; drawn via backward Fisher-Yates |
| Player Picks | 1–10 | Player selects; determines hit probability |
| Risk Levels | Classic, Low, Medium, High | Affects multiplier table, not drawn numbers |
| House Edge | 0.1% at the base tier | In 35 of 40 configurations, rises in 0.01% steps above a threshold, to 1.0% at most |
| Theoretical RTP | 99.9% (base tier) | Derived for all 40 configurations from hypergeometric probabilities |
| Configurations | 40 | 10 pick counts × 4 risk levels |
| RNG Algorithm | HMAC-SHA256 | Backward Fisher–Yates with rejection sampling; key = hex-decoded server seed |
Seed Formats
Every Keno bet uses three cryptographic inputs to generate the draw result.
| Seed Type | Format | Example | Purpose |
|---|---|---|---|
| Server Seed | 64-char hex (32 bytes) | 94eee14e882d4332… | Casino-provided randomness |
| Client Seed | Alphanumeric string | dAn1wtkuDAXxQOKP | Player-contributed entropy |
| Nonce | Integer from 0 | 7 | One per bet within an epoch |
Multiplier Tables & Payout
Payouts are set by the hit count, pick count and risk level. These are the base-tier multipliers; in every one of the 40 configurations they return 99.9%.
win_amount = bet_amount × multiplier_table[risk][picks][hits]| Picks | Risk | Max Multiplier (all hits) | Zero-Hit Multiplier | RTP |
|---|---|---|---|---|
| 1 | Classic | 3.996× | 0× | 99.9% |
| 1 | Low | 1.866× | 0.71× | 99.9% |
| 10 | Classic | 200× | 0× | 99.9% |
| 10 | High | 1200× | 0× | 99.9% |
Why Provably Fair Matters▶
Traditional online casinos require players to trust that games are fair. Provably fair systems eliminate this trust requirement by allowing players to mathematically verify that outcomes were not manipulated. In a Provably Fair system:
- The casino commits to a result before the player bets
- The player contributes randomness that the casino cannot predict
- Anyone can verify the outcome after the fact
High-Level Overview7 sections▶
Checklist Reference
Based on the ProvablyFair.org Audit Execution Checklist, here are the tests covered under this audit document.
1. Commit-Reveal System & Seed Handling
| Test | Description |
|---|---|
| Server seed commit exists before play | SHA-256 hash shown to player before betting |
| Server seed reveal matches commit | SHA-256(hexDecode(revealed)) = committed hash |
| Client seed control | Player can set/change client seed via rotation UI |
| Nonce increments correctly | Starts at 0, +1 per bet, resets at epoch boundary |
| Full determinism | Same inputs → same result |
2. Randomness & Entropy Model
| Test | Description |
|---|---|
| RNG depends only on seeds + nonce | No external inputs (drand absent from Keno) |
| No mixed entropy sources | No timestamps, Math.random, etc. |
| Unbiased mapping | Rejection sampling: the accepted values are a whole multiple of every range 2–40, so bias is exactly 0 |
| No state leakage | RNG isolated per round — each shuffle step uses its own cursor in the HMAC message |
3. Verifier ↔︎ Live Parity
| Test | Description |
|---|---|
| Live outcomes match verifier | 5,100 / 5,100 draws recomputed with 0 SET mismatches |
| Multi-phase verification | Phases A (32 configs), B (picks=1), C (picks=10), D (stake equivalence) |
| Bet-size invariance | The stake is not an input to the draw; $10 bets follow the same rules as $0.01 |
4. Game Logic & RTP Validation
| Test | Description |
|---|---|
| Anti-circularity proof | Hypergeometric P(hits) × committed multiplier = 99.9% — independent probabilities, committed table |
| House edge audit | 0.1% at the base tier: effective_edge 0.1 on every captured bet; higher tiers explained from the config (4.5) |
| Payout rules correctness | Win amount equals stake × the 13-decimal multiplier exactly (integer units, no tolerance) |
| Simulated RTP convergence | 40M rounds average 99.970%, consistent with 99.9% |
| Cherry-pick detection | Test B 57 / 1,666 across 102 casino seeds, within its threshold — no sign of seed pre-selection |
| RTP claim rule (RTP-CLAIM 1.2.0) | Every stake tier held to the edge Duel's game settings state for it, scored on Step 17 with a ±0.1 pp band — PASS |
5. Fairness Integrity & Player Verification
| Test | Description |
|---|---|
| Player can reproduce results offline | Using seeds + nonce + backward Fisher-Yates |
| Verifier logic matches live logic | Our RNG (written from the spec), Duel's Verify-tab code and both ProvablyFair.org verifiers agree on all 5,100 bets |
| Verifier publicly accessible | ProvablyFair.org verifier — no login required |
| No reliance on private APIs | Fully client-side verification |
| 23 scored steps | Commit-reveal, determinism, payout, distribution, cherry-pick, draw bias, verifier parity, artifact integrity |
High-Level Flow
To get an overview of how the process works, here is a high-level breakdown:
1. Player Bets — Selects pick count (1–10), risk level, and bet amount
2. Seeds Combined — HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor) for each shuffle step
3. RNG Output — Backward Fisher-Yates: 39 iterations from i=39 downto 1, each step swaps positions[i] with a bias-free random index
4. Draw Result — the first 10 entries of the shuffled list are the 10 drawn numbers (a set)
5. Hit Count — Count of player's picks appearing in drawn set
6. Multiplier Lookup — hits maps to multiplier via kenoConfig[risk][picks][hits]
7. Payout Result — win_amount = bet_amount × payout_multiplier
Provably Fair Model
Provably fair gambling systems use cryptographic primitives so outcomes can be checked after the fact. The model relies on three components: a server seed committed via hash before play, a player-controlled client seed, and an incrementing nonce. These inputs are combined using HMAC-SHA256 to produce deterministic, verifiable results. This section documents the global provably fair architecture used by almost all casinos and all relevant games.
Commit-Reveal Model
The Commit-Reveal model is integral to ensuring fairness and transparency in online gambling. This model involves several key phases:
Commit Phase:
Before any bets are placed, the casino generates a random server seed and sends the player only the SHA-256 hash of the hex-decoded seed. The player can't know the seed beforehand, but can check it once it is revealed.
Bet Phase:
The player places their bet. The server computes the drawn numbers using HMAC-SHA256 with the server seed (hex-decoded) as the HMAC key and the client seed, nonce, and cursor as the message. The same server seed and client seed pair are used for every bet in the epoch; the player can rotate the seed pair at any time to end the epoch.
Reveal Phase:
After the player rotates to a new seed pair, the server reveals the plaintext server seed from the completed epoch. The player can now independently verify SHA-256(hexDecode(serverSeed)) = committedHash.
Verify Phase:
Anyone can recompute every bet's drawn numbers from the revealed server seed, client seed, and nonce using the published backward Fisher-Yates algorithm.
Player-Controlled Client Seed
The player's client seed is generated by the browser and submitted to the server via the seed rotation UI. Players can set their own client seed at any time. This ensures:
- The casino cannot predict the full RNG input
- Players contribute entropy that they control
- Results depend on both parties' inputs
Nonce Lifecycle
The nonce is a counter that increments with each bet within an epoch:
- Starts at 0 for each new server seed
- Increments by exactly 1 per bet
- Never reused within the same seed epoch
- Resets to 0 when the player rotates to a new server seed
Seed Epoch: (serverSeed, clientSeed) Bet 1: nonce = 0 → Draw ABet 2: nonce = 1 → Draw BBet 3: nonce = 2 → Draw C...Bet N: nonce = N−1 → Draw Z [Player rotates seed — epoch complete]Next bet: nonce = 0 → Draw X (new seed pair)Determinism Guarantee
Given identical inputs, the output is always identical:
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor) → Always same hashSame hash per step → Always same swap index in Fisher-YatesSame swaps across all 39 steps → Always same drawn SETSame drawn SET + same picks → Always same hit countSame hit count + same config → Always same payout (for the same stake)Technical Glossary6 categories▶
Framework 1.1
| Term | Definition |
|---|---|
| Framework 1.1 | The ProvablyFair.org audit framework this report is certified under (October 2026). It adds the RTP claim rule, capture flags, the base-stake-tier rule, the standard S5 matrix and game profile coverage. |
| Capture flag | A flag caused by our capture, not by the casino — here, two nonces our capture script missed on retried requests. Disclosed and counted, and verdict-neutral. |
| RTP claim rule | RTP-CLAIM 1.2.0. Holds the audited RTP to the figure the casino publishes (game page, fairness page, help page, bet panel, rules or game settings) within ±0.1 pp. A house-side miss makes the verdict RTP FIGURE OVERSTATED (exit 5). |
| Base stake tier | The lowest tier of Duel's stake-scaled pricing: the 0.1% tier of each Keno configuration, up to a threshold from $90.20 to $99,546.07. Every captured bet was priced here, and the audit's guarantees apply here. |
Core Concepts
| Term | Definition |
|---|---|
| Provably Fair | A cryptographic system that allows players to mathematically verify that game outcomes were not altered. Relies on commit-reveal schemes and deterministic algorithms. |
| Commit-Reveal Protocol | A two-phase process in which the casino commits to a result (by showing its hash) before the player bets, then reveals the actual value after the bet. |
| Determinism | The property that identical inputs always produce identical outputs. Same server seed, client seed, and nonce must always generate the same drawn number set. |
| Client Seed Origin | The method by which the client seed is generated. Full Pass: browser-generated default + player customizable seed. Conditional Pass: server-assigned default + player customizable seed. Hard Fail: player cannot set own seed. |
Seed System
| Term | Definition |
|---|---|
| Server Seed | A random 32-byte value generated by Duel.com, transmitted as a 64-character hex string. Hashed and shown to players before betting, revealed after epoch rotation. |
| Client Seed | A random value controlled by the player, generated by the browser. Players can change it at any time via the seed rotation UI. |
| Nonce | A sequential counter that increments per bet within an epoch. Starts at 0 and resets to 0 when the player rotates to a new server seed. |
| Hashed Server Seed | SHA-256(hexDecode(serverSeed)) — the commitment hash shown before betting. After rotation, players verify the revealed seed produces this hash. |
| Cursor | Index used in the HMAC message during the backward Fisher-Yates shuffle. cursor = gridSize − 1 − i, starting at 0 for the first step (i=39). Each cursor value produces one shuffle step. |
| Epoch | A sequence of consecutive bets sharing the same server seed and client seed pair. Ends when the player rotates to a new seed pair. This audit covered 102 bet-bearing epochs. |
Cryptographic Functions
| Term | Definition |
|---|---|
| HMAC-SHA256 | Hash-based Message Authentication Code using SHA-256. Duel Keno uses HMAC-SHA256 with the hex-decoded server seed as key and clientSeed:nonce:cursor as message: 39 calls per bet, one per shuffle step. |
| SHA-256 | Secure Hash Algorithm 256-bit. Used for server seed commitment: SHA-256(hexDecode(serverSeed)) = serverSeedHashed. |
| Hex Decoding | Converting a 64-character hex string to 32 raw bytes. Critical for the HMAC key — using the hex string as UTF-8 produces wrong outputs. |
| Backward Fisher-Yates Shuffle | A variant of the Fisher-Yates algorithm that iterates from index 39 down to 1, swapping each position with a random index from 0 up to its own. Produces a uniformly random permutation of the 40-number grid. |
Verification Terms
| Term | Definition |
|---|---|
| Verifier | A tool that recomputes the drawn numbers from the seeds and nonce. The ProvablyFair.org verifier's code is the file Step 23 runs on all 5,100 bets. |
| Parity | Degree of matching between verifier and live game results. 100% parity = every draw SET matches. This audit: 5,100/5,100 exact match. |
| Anti-Circularity | Proof that the win probabilities derive from first principles, not the casino's own claims: independently-derived hypergeometric P(hits) applied to the committed multiplier table = 99.9%. |
| Rejection Sampling | Removes modulo bias: values at or above floor(2^32 / range) × range are discarded, so every swap index is exactly uniform for every range 2–40. |
Game Mechanics
| Term | Definition |
|---|---|
| Drawn Numbers | The 10 numbers (1–40) the backward Fisher–Yates shuffle leaves in the first 10 positions. The result is a set: the order Duel displays is presentation only. |
| Pick Count | Player-selected parameter (1–10) determining how many numbers the player chooses from the grid. More picks = more chances to match, but multipliers scale down. |
| Risk Level | Player-selected parameter (Classic, Low, Medium, High) that determines the multiplier table. Higher risk = more value at rare full-hit outcomes. |
| Hypergeometric Distribution | The probability distribution for hit counts: P(k hits) = C(picks,k) × C(40−picks, 10−k) / C(40,10). Used in the anti-circularity RTP proof. |
| Consolation Payout | Two configurations pay non-zero multipliers on zero hits: LOW picks=1 (0.71×) and MEDIUM picks=1 (0.41×). Design choice within the 99.9% RTP constraint. |
Seed, Nonce & Determinism
Can the casino change your outcome after you bet?
Every Keno bet on Duel.com comes from three inputs: server seed, client seed and nonce. Duel commits to the server seed by showing its SHA-256 hash before you bet, and reveals the seed when you rotate. Your picks, risk level and stake are not inputs, so the 10 numbers are fixed before the draw animation plays. A hash match shows the records are consistent; the proof of timing is a copy of the hash you saved before betting.
What we verified
- Every revealed server seed hashes to its commitment (102 / 102)
- The 106 seed records fit together: 105 forward links plus the pre-capture anchor
- That each commitment was shown before its bets rests on the capture's rotation records
- Nonces: 100 / 102 epochs complete, no repeats, none out of order; 2 nonces missed by our capture script
- Identical inputs always produce the same drawn set (5,100 / 5,100)
- Your client seed is a genuine input: a wrong or empty seed changes all 5,100 draws
What this means for you
- Once a server seed is committed, the casino can't swap it for another
- The 10 numbers are fixed by the seeds and nonce before the draw animation plays
- Save the hashed server seed before you bet: your saved copy is what proves the timing
- Setting your own client seed adds your input to every draw
- Any bet can be recomputed after you rotate your seed
- Every revealed server seed hashes to its commitment (102 / 102)
- The 106 seed records fit together: 105 forward links plus the pre-capture anchor
- That each commitment was shown before its bets rests on the capture's rotation records
- Nonces: 100 / 102 epochs complete, no repeats, none out of order; 2 nonces missed by our capture script
- Identical inputs always produce the same drawn set (5,100 / 5,100)
- Your client seed is a genuine input: a wrong or empty seed changes all 5,100 draws
- Once a server seed is committed, the casino can't swap it for another
- The 10 numbers are fixed by the seeds and nonce before the draw animation plays
- Save the hashed server seed before you bet: your saved copy is what proves the timing
- Setting your own client seed adds your input to every draw
- Any bet can be recomputed after you rotate your seed
Seed hash integrityPass
Commitment linkagePass
Hash consistency within epochPass
Nonce sequencingCapture flag
Deterministic outputPass
Client seed participationPass
Client seed originPass
crypto.getRandomValues, and players can set their own (E12). The capture's own seeds are disclosed in 1.4All 102 revealed seeds hash to their commitments and the 106 seed records fit together. Every draw recomputes from (serverSeed, clientSeed, nonce). When each commitment was shown rests on the capture's rotation records. Step 4 is a capture flag: two nonces our capture script missed, disclosed and verdict-neutral.
| Check | Result | Evidence |
|---|---|---|
| Seed hash integrity | Pass | 102 / 102 revealed seeds hash to their commitments; the 4 seeds never revealed carry no bets (Step 1) |
| Commitment linkage | Pass | All 105 forward links recomputed, plus the pre-capture anchor (Step 2). A consistency check: the timing rests on the capture's rotation records |
| Hash consistency within epoch | Pass | Every bet carries its epoch's committed hash and client seed: 102 bet-bearing epochs, 0 orphan bets, 106 distinct commitments (Step 3) |
| Nonce sequencing | Capture flag | 100 / 102 epochs complete, no repeats, 0 out of order. 2 nonces missed on retried requests: limited by our capture script, not a Duel issue (Step 4) |
| Deterministic output | Pass | 5,100 / 5,100 drawn sets recomputed from (serverSeed, clientSeed, nonce) (Step 5) |
| Client seed participation | Pass | A wrong and an empty client seed each change all 5,100 draws (Step 6); the 100 Phase D bets recompute (Step 9) under two auditor-set seeds (Step 18) |
| Client seed origin | Pass | Duel's default seed is browser-generated with crypto.getRandomValues, and players can set their own (E12). The capture's own seeds are disclosed in 1.4 |
Seed hash integrityPass
Commitment linkagePass
Hash consistency within epochPass
Nonce sequencingCapture flag
Deterministic outputPass
Client seed participationPass
Client seed originPass
crypto.getRandomValues, and players can set their own (E12). The capture's own seeds are disclosed in 1.4All 102 revealed seeds hash to their commitments and the 106 seed records fit together. Every draw recomputes from (serverSeed, clientSeed, nonce). When each commitment was shown rests on the capture's rotation records. Step 4 is a capture flag: two nonces our capture script missed, disclosed and verdict-neutral.
How It Works — Seed, Nonce & Determinism7 sections
1.1Server Seed Commitment
Before any bet, Duel commits to a secret server seed by showing its SHA-256 hash. The server seed is a 64-character hex string (32 bytes), and the commitment is SHA-256(hexDecode(serverSeed)). When you rotate, Duel reveals the seed and anyone can check that it hashes to the commitment. A match shows the two are consistent. The proof that the seed was fixed before you bet comes from a copy of the hash you saved before betting.
export function verifyHash(serverSeed: string, serverSeedHashed: string): boolean { if (!/^[0-9a-fA-F]{64}$/.test(serverSeed)) return false; if (!/^[0-9a-fA-F]{64}$/.test(serverSeedHashed)) return false; const commitment = createHash("sha256").update(Buffer.from(serverSeed, "hex")).digest("hex"); return commitment === serverSeedHashed.toLowerCase();}Real Example from Live Data:
// data/keno-master-5100bets.json// bets[0] — the seed fields bet 34309684 carries (nonce 0):"seed": {"serverSeedHashed": "111880213ddf0a3a7b93cf725aeec359113c3986a902fffa0e5a33987600b77a", "clientSeed": "dAn1wtkuDAXxQOKP", "nonce": 0}// seeds[1] — the next rotation reveals the server seed:"serverSeed": "94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9","revealedFrom": {"transactionId": 518502617}Verification:
const crypto = require('crypto'); const serverSeed = "94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9"; const hashedServerSeed = crypto .createHash("sha256") .update(Buffer.from(serverSeed, 'hex')) .digest("hex"); console.log(hashedServerSeed);// Output: 111880213ddf0a3a7b93cf725aeec359113c3986a902fffa0e5a33987600b77a ✅1.2Commitment Linkage (Next-Seed Promotion)
At every rotation Duel shows the hash of the seed it will activate next (nextServerSeedHash). Step 2 recomputes all 105 links from the raw hashes: each epoch's serverSeedHashed must equal the previous record's nextServerSeedHash. The first epoch is checked against the hash the capture read as "next" before its first rotation. The links show the 106 records fit together, not when each hash was shown. That rests on the capture's rotation records, each made before its epoch's first bet.
for (let i = 0; i < seeds.length - 1; i++) { linksChecked++; if (seeds[i].seed.nextServerSeedHash === seeds[i + 1].seed.serverSeedHashed) linksOk++; else chainFailures.push( `seed[${i}].nextServerSeedHash != seed[${i + 1}].serverSeedHashed — epoch ${i + 1} was not pre-committed by epoch ${i}`);}match flags agree with the recomputation on all 106 records.1.3Hash Consistency Within Epoch
The capture holds 106 seed records, one for every rotation. 102 carry bets, 50 each. The other 4 are end-of-phase rotations with no bets.
Step 3 assigns each bet to an epoch by the capture timeline, not by the bet's own hash, and checks that every bet carries its record's committed serverSeedHashed and client seed. A mid-epoch seed change would show up as a disagreement. It also checks that no commitment is used twice.
for (const e of epochs) { if (e.bets.length === 0) { empty++; continue; } betBearing++; const tag = `seeds[${e.index}] (${e.record.seed.serverSeedHashed.substring(0, 16)})`; const hashes = new Set(e.bets.map(b => b.seed.serverSeedHashed)); const clients = new Set(e.bets.map(b => b.seed.clientSeed)); if (hashes.size !== 1) { s3Failures.push(`${tag}: ${hashes.size} distinct serverSeedHashed among its ${e.bets.length} bets`); } else if (!hashes.has(e.record.seed.serverSeedHashed)) { s3Failures.push(`${tag}: its bets carry ${[...hashes][0].substring(0, 16)}, not the hash the rotation committed`); } if (clients.size !== 1) { s3Failures.push(`${tag}: ${clients.size} distinct client seeds among its bets`); } else if (!clients.has(e.record.seed.clientSeed)) { s3Failures.push(`${tag}: its bets carry client seed ${[...clients][0]}, not the rotation record's ${e.record.seed.clientSeed}`); }}1.4Client Seed Origin & Control
Duel generates the default client seed in your browser: 16 characters from a 63-character alphabet, drawn with rejection-sampled crypto.getRandomValues, and filled in by the seed-rotation panel (E12). You can replace it with your own at any time. The client seed is an input to every HMAC, so changing it changes the whole draw.
The capture used its own seeds. Phases A–C took 100 seeds from the capture script's Math.random(). Phase D used two auditor seeds, pfauditmntnvgkk and pfauditmntnwjdi, built from a timestamp. These are choices on our side; they don't change what Duel's server does with a seed.
05c2Ex3iqjnhrWPk0aPrHGFQSzkmvZqv2FyZzGbkRqrxBjW634hzj6BD4gCPaNAM4fUHsJsnDQXEejT6
1.5Nonce Incrementation
The nonce starts at 0 for each server seed and rises by 1 per bet. Duel reveals a server seed only when you rotate. Our capture rotated every 50 bets; that 50-bet epoch is our schedule, not Duel's.
Step 4 checks every epoch for repeats and order in capture order, then for gaps. In two epochs our capture script retried a request and missed one round each: nonce 7 in epoch 505951bc (Phase B) and nonce 43 in epoch 5169f71b (Phase C). Each epoch therefore runs to nonce 50. The revealed seed fixes the draw at each missed nonce, but the served result was not captured, so those two rounds are not verified. Limited by our capture script, not a Duel issue.
const hasOverflow = nonces.includes(windowEnd);const missing = Array.from({ length: EPOCH_SIZE + 1 }, (_, i) => NONCE_BASE + i).filter(n => !nonces.includes(n));const isRetryPattern = hasOverflow && missing.length === 1 && nonces.length === EPOCH_SIZE && new Set(nonces).size === nonces.length; if (isRetryPattern) { const missedNonce = missing[0]; const serverSeed = seedMap.get(hash); if (serverSeed) { // No captured server response exists for this nonce (that is why it is missing), so this is // a reconstruction fixed by the commitment, not a comparison. const draw = computeDraw(serverSeed, epochBets[0].seed.clientSeed, missedNonce); reconstructed.push({ epoch: shortHash, missedNonce, reconstructedDraw: draw }); captureArtifacts.push(`Epoch ${shortHash}: capture retry — nonce ${missedNonce} missed, reconstructed from the revealed seed`); } else { captureArtifacts.push(`Epoch ${shortHash}: capture retry — nonce ${missedNonce} missed; server seed unrevealed`); unverifiable++; }1.6Deterministic Mapping
The draw is fully deterministic: the same server seed, client seed and nonce always give the same 10 numbers. Our src/rng.ts was written from the specification (docs/ALGORITHM.md) by an implementer who never opened Duel's code. The server seed is hex-decoded to 32 bytes for the HMAC key, and the message is clientSeed:nonce:cursor, where the cursor is the shuffle step, 0 to 38. Each step reads the HMAC as eight 4-byte values and takes the first below floor(2^32 / range) × range. The first 10 entries of the shuffled array are the draw, compared with Duel's as a set.
export function computeDraw( serverSeed: string, clientSeed: string, nonce: number, gridSize: number = GRID_SIZE, drawnCount: number = DRAWN_COUNT,): number[] { // §2 Step 1: key = hex_decode(serverSeed), the 32 raw bytes, not the ASCII text. return computeDrawFromBuffer(decodeServerSeed(serverSeed), clientSeed, nonce, gridSize, drawnCount);}(serverSeed, clientSeed, nonce); no drand or other external input.Real Bet Verified:
// data/keno-master-5100bets.json · bet 34309702 (Phase A, MEDIUM, 8 picks, nonce 4)"request": {"amount": "0.01", "picks": 8, "risk": "medium", "difficulty": 3, "selected_positions": [1, 5, 6, 15, 17, 22, 33, 36]}"response": {"id": 34309702, "status": 3, "amount_currency": "0.010000000000000000", "amount_won": "0.0201", "multiplier": "2.01", "difficulty": 3, "selected_positions": [1, 5, 6, 15, 17, 22, 33, 36], "drawn_numbers": [29, 16, 35, 5, 37, 26, 1, 20, 8, 36], "transaction_id": 518501010, "effective_edge": 0.1}"seed": {"serverSeedHashed": "111880213ddf0a3a7b93cf725aeec359113c3986a902fffa0e5a33987600b77a", "clientSeed": "dAn1wtkuDAXxQOKP", "nonce": 4}// revealed server seed (seeds[1]): 94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9Verification:
// computeDraw("94eee14e...", "dAn1wtkuDAXxQOKP", 4) // Backward Fisher–Yates: 39 steps, s = 0 to 38, each fixing index i = 39 − s// Each step: HMAC-SHA256(hexDecode(serverSeed), "dAn1wtkuDAXxQOKP:4:{s}")// Eight 4-byte values; take the first v < floor(2^32 / range) × range// j = v % range; swap a[i] ↔ a[j] // Drawn SET: {1, 5, 8, 16, 20, 26, 29, 35, 36, 37} ✅// Hits (vs selected [1,5,6,15,17,22,33,36]): 3 (matched: 1, 5, 36) ✅// Multiplier (MEDIUM/picks=8, 3 hits): 2.01× ✅// Payout: 0.01 × 2.01 = 0.0201 ✅1.7Client Seed Influence
To confirm the client seed is a genuine HMAC input, Step 6 recomputes all 5,100 bets twice more: once with a deliberately wrong client seed (WRONG_CLIENT_SEED_FOR_AUDIT_TEST) and once with an empty one. By chance alone, a different seed leaves a draw unchanged with probability 1 / C(40,10), about 6 × 10⁻⁶ expected over 5,100 bets, so no unchanged draw is allowed. Every one changed under both. Separately, the 100 Phase D bets used two auditor-set seeds (Step 18) and all recompute (Step 9).
for (const [hash, epochBets] of ctx.byHash) { const ss = seedMap.get(hash); if (!ss) { epochsUnrevealed++; continue; } const key = Buffer.from(ss, 'hex'); let changed = 0; for (const bet of epochBets) { const correctDraw = computeDrawFromBuffer(key, bet.seed.clientSeed, bet.seed.nonce); const wrongDraw = computeDrawFromBuffer(key, wrongClientSeed, bet.seed.nonce); const emptyDraw = computeDrawFromBuffer(key, '', bet.seed.nonce); if (!sameSet(correctDraw, wrongDraw)) changed++; if (sameSet(correctDraw, emptyDraw)) emptyCollisions++; totalChecked++; emptyTested++; } totalChanged += changed; epochsTested++; if (changed === 0) { zeroChangeEpochs.push(`Epoch ${hash.substring(0, 16)}: wrong client seed produced 0 changed draws`); } else if (changed !== epochBets.length) { partialEpochs.push(`Epoch ${hash.substring(0, 16)}: ${epochBets.length - changed} of ${epochBets.length} draws unchanged`); }}Technical Evidence & Verification5 sections
1.8Evidence Coverage Summary6 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Seed hash integrity (Step 1) | 102 / 102 revealed seeds; 3 phase-start records repeat the one before; 4 unrevealed, none with bets | Pass |
| Commitment linkage (Step 2) | 105 / 105 links + the pre-capture anchor | Pass |
| Hash consistency (Step 3) | 102 bet-bearing epochs, 0 orphan bets, 106 distinct commitments | Pass |
| Nonce audit (Step 4) | 100 / 102 complete; 2 capture-retry gaps (limited by our capture script) | Capture flag |
| Draw recomputation (Step 5) | 5,100 / 5,100 | Pass |
| Client seed influence (Step 6) | 5,100 / 5,100 (wrong seed) and 5,100 / 5,100 (empty seed) | Pass |
1.9Code References7 source files
| File | Purpose |
|---|---|
| tests/verify.ts | 23 scored steps (Steps 1–6 cover S1) and the reproduction gate |
| tests/steps/commitment.ts | Steps 1–4: commit-reveal and nonce checks |
| tests/steps/determinism.ts | Steps 5–6: draw recomputation and client seed influence |
| src/rng.ts | HMAC-SHA256 backward Fisher–Yates draw, written from docs/ALGORITHM.md |
| docs/ALGORITHM.md | The written specification the draw code was built from |
| src/loader.ts | Dataset loading, the capture plan and the seed timeline |
| capture/capture-auto.reference.js | Reference record of the capture script |
1.10Datasets UsedSource artifacts
| Property | Value |
|---|---|
| Source | Live Keno bets on Duel.com, 11 April 2026 |
| Total Records | 5,100 bets across 102 epochs (106 seed records) |
| SHA-256 | 841755fdfb268d7796017212f08a18bfea7615c30a4590dd29793b34c5e6bcf9 |
Fields used: serverSeed, serverSeedHashed, nextServerSeedHash, clientSeed, nonce, difficulty, selected_positions, drawn_numbers, multiplier, amount_won
1.11Verified Invariants8 invariants
| Invariant | Result |
|---|---|
| SHA-256(hexDecode(serverSeed)) = serverSeedHashed for all 102 revealed seeds | Pass |
| Forward commitment chain consistent over all 105 links, plus the pre-capture anchor | Pass |
| serverSeedHashed and client seed constant within each of the 102 bet-bearing epochs | Pass |
| No repeated or out-of-order nonce in any epoch | Pass |
| Nonce gaps only where our capture script retried a request (2) | Capture flag |
| Same inputs produce the same drawn set for all 5,100 bets | Pass |
| A wrong or empty client seed changes the drawn set on 5,100 / 5,100 bets | Pass |
| Duel's default client seed is browser-generated (E12) | Pass |
1.12Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 1 — Seed Hash Integrity
[PASS] Step 2 — Next-Seed Promotion (Commitment Linkage)
[PASS] Step 3 — Hash Consistency Within Epoch
[FLAG⚑] Step 4 — Nonce Audit
[PASS] Step 5 — Draw Recomputation (RNG + drand absent)
[PASS] Step 6 — Client Seed InfluenceRNG & Entropy Model
Is the randomness genuinely random, or could it be rigged?
Our RNG is our own implementation, written from the specification without opening Duel's code. It reproduces every one of the 5,100 captured draws, and Duel's own Verify-tab code, run unmodified, agrees as a cross-check. Each of the 39 shuffle steps takes one HMAC-SHA256 value with rejection sampling, so every swap index is exactly uniform.
What we verified
- Our RNG is written from the specification, without opening Duel's code, and reproduces all 5,100 draws
- Duel's own Verify-tab code, run unmodified as a cross-check, gives the same shuffle order on all 5,100
- Only disclosed inputs: server seed, client seed and nonce. No picks, risk, stake, timestamps or outside randomness
- Rejection sampling makes every swap index exactly uniform, for every range from 2 to 40
- 40M simulated rounds find no sign of bias or serial dependence in any of the 40 configurations
- A wrong client seed changes all 5,100 draws
What this means for you
- Each drawn number is chosen fairly and can't be skewed
- All 40 numbers are equally likely to be drawn
- No hidden randomness or server-side state decides which numbers appear
- Past results don't affect future draws
- The draw depends only on seeds you can check
- Our RNG is written from the specification, without opening Duel's code, and reproduces all 5,100 draws
- Duel's own Verify-tab code, run unmodified as a cross-check, gives the same shuffle order on all 5,100
- Only disclosed inputs: server seed, client seed and nonce. No picks, risk, stake, timestamps or outside randomness
- Rejection sampling makes every swap index exactly uniform, for every range from 2 to 40
- 40M simulated rounds find no sign of bias or serial dependence in any of the 40 configurations
- A wrong client seed changes all 5,100 draws
- Each drawn number is chosen fairly and can't be skewed
- All 40 numbers are equally likely to be drawn
- No hidden randomness or server-side state decides which numbers appear
- Past results don't affect future draws
- The draw depends only on seeds you can check
RNG derived only from disclosed inputsPass
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor); the draw takes (key, clientSeed, nonce) only (Step 5)Written from the specificationPass
src/rng.ts rebuilt from docs/ALGORITHM.md by an implementer who never opened Duel's code; 79 / 79 spec checks (unit test)Operator code cross-checkPass
Modulo biasPass
Key encodingPass
Serial independencePass
Client seed influencePass
Our own implementation, written from the specification, reproduces every live draw, and Duel's Verify-tab code agrees as a cross-check. Every swap index is exactly uniform. 40M simulated rounds find no sign of bias or serial dependence in any configuration, and the client seed changes every draw.
| Check | Result | Evidence |
|---|---|---|
| RNG derived only from disclosed inputs | Pass | HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor); the draw takes (key, clientSeed, nonce) only (Step 5) |
| Written from the specification | Pass | src/rng.ts rebuilt from docs/ALGORITHM.md by an implementer who never opened Duel's code; 79 / 79 spec checks (unit test) |
| Operator code cross-check | Pass | Duel's Verify-tab code, run unmodified: same shuffle order on 5,100 / 5,100 (Step 23) |
| Modulo bias | Pass | All 39 ranges enumerated: every index has the same number of accepted values, bias exactly 0. No value rejected in 198,900 captured steps (Step 22) |
| Key encoding | Pass | Server seed hex-decoded to 32 bytes; only the decoded key reproduces the known draws (unit test) |
| Serial independence | Pass | 40M simulated rounds: 0 / 40 configurations fail the lag-1 and runs checks at α/40 (Step 19) |
| Client seed influence | Pass | A wrong and an empty client seed each change all 5,100 draws (Step 6) |
RNG derived only from disclosed inputsPass
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor); the draw takes (key, clientSeed, nonce) only (Step 5)Written from the specificationPass
src/rng.ts rebuilt from docs/ALGORITHM.md by an implementer who never opened Duel's code; 79 / 79 spec checks (unit test)Operator code cross-checkPass
Modulo biasPass
Key encodingPass
Serial independencePass
Client seed influencePass
Our own implementation, written from the specification, reproduces every live draw, and Duel's Verify-tab code agrees as a cross-check. Every swap index is exactly uniform. 40M simulated rounds find no sign of bias or serial dependence in any configuration, and the client seed changes every draw.
How It Works — RNG & Entropy Model7 sections
2.1RNG Function Implementation
Each Keno bet draws 10 numbers from 40 with a backward Fisher–Yates shuffle of [1, 2, …, 40]. Step s runs from 0 to 38 and fixes index i = 39 − s, with range = i + 1. Each step computes one HMAC-SHA256 with the hex-decoded server seed as key and clientSeed:nonce:s as message, reads it as eight 4-byte big-endian values, and takes the first below floor(2^32 / range) × range. Then j = value % range and a[i] swaps with a[j]. The first 10 entries are the draw.
| Component | Detail |
|---|---|
| Hash function | HMAC-SHA256 |
| Key | hexDecode(serverSeed): 32 bytes |
| Message | clientSeed:nonce:s, s = 0 to 38 |
| Extraction | Eight 4-byte big-endian values per HMAC |
| Rejection | value < floor(2^32 / range) × range |
| Reduction | value % range → swap index j ∈ [0, range) |
| Shuffle | Backward Fisher–Yates: step s fixes index i = 39 − s |
| Output | a[0..9]: the 10 drawn numbers, compared as a set |
// §2 Step 2: a = [1, 2, ..., gridSize], 0-indexed.const a: number[] = [];for (let n = 1; n <= gridSize; n++) a.push(n); // §2 Steps 1+2: steps s = 0 .. gridSize-2; step s fixes index i = (gridSize-1) - s.for (let s = 0; s <= gridSize - 2; s++) { const i = gridSize - 1 - s; const r = i + 1; // range size for this step const limit = maxFairFor(r); // §2 Step 1: one HMAC-SHA256 per step, key = raw seed bytes, // message = UTF-8 of "clientSeed:nonce:s" (decimal, no padding). UTF-8 per §2 Step 1 / O6. const message = `${clientSeed}:${nonce}:${s}`; const digest = createHmac("sha256", keyBuffer).update(message, "utf8").digest(); if (census) census.hmacCalls++; // §2 Step 2: walk the digest in 4-byte big-endian chunks, accept the first below LIMIT. let accepted: number | undefined; for (let offset = 0; offset + CHUNK_BYTES <= DIGEST_BYTES; offset += CHUNK_BYTES) { const v = digest.readUInt32BE(offset); if (census) census.chunksScanned++; if (v < limit) { accepted = v; break; } if (census) census.chunksRejected++; } if (accepted === undefined) { // Open point O2: the spec does not say what follows when all 8 chunks are // rejected (probability < 1e-60 per step). Refuse rather than invent a rule. throw new Error( `computeDrawFromBuffer: all ${DIGEST_BYTES / CHUNK_BYTES} chunks rejected at step ${s} (ALGORITHM.md O2, unspecified)`, ); } // §2 Step 2: j = v mod r, then swap a[i] and a[j]. const j = accepted % r; const tmp = a[i] as number; a[i] = a[j] as number; a[j] = tmp;} // §2 Step 2: drawn = the first drawnCount entries of the shuffled array.return a.slice(0, drawnCount);docs/ALGORITHM.md by an implementer who never opened Duel's code, and its self-test runs the specification's 79 vector and property checks (79 / 79).2.2Entropy Sources
All randomness derives exclusively from the deterministic HMAC-SHA256 function combining three cleanly separated inputs, plus a per-step cursor:
| Source | Controlled By | Purpose |
|---|---|---|
| Server Seed | Casino | Base randomness (committed via SHA-256 hash before betting) |
| Client Seed | Player | Player-contributed input |
| Nonce | System | One per bet; rises by 1 within each epoch |
| Cursor | System | One per shuffle step, 0 to 38 |
How we know: all 5,100 bets were recomputed from these inputs alone. A hidden input would make recomputation fail; it does not. Step 5 also checks that the draw function takes only (key, clientSeed, nonce), so your picks, risk and stake never reach it.
No timestamps, external APIs or server-side state: only HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor).
2.3Modulo Bias Analysis
Each swap index is value % range, with range 40 down to 2. Where 2^32 is not a whole multiple of the range, a plain modulo would favour low indexes. The draw removes this with rejection sampling: only values below LIMIT = floor(2^32 / range) × range are used, and that window is a whole multiple of the range.
For range = 40 (first step, s = 0, i = 39):
LIMIT = floor(2^32 / 40) × 40
= 107,374,182 × 40
= 4,294,967,280 (= 0xFFFFFFF0)
Rejected values: 4,294,967,280 … 4,294,967,295 = 16 values
Rejection chance: 16 / 2^32 ≈ 3.7 × 10⁻⁹
Accepted values: 4,294,967,280, a whole multiple of 40
→ each index 0–39 equally likely (zero bias)The largest rejection is 22 values, at range 39. On the power-of-two ranges (2, 4, 8, 16, 32) the limit is 2^32 and nothing is rejected. A step reads up to eight values; all eight being rejected has a probability below 10⁻⁶⁰. The specification leaves that case open, so our code stops rather than invent a rule.
Duel's Verify-tab code uses the ceiling 0xFFFFFFFF − (0xFFFFFFFF % range). That is the same window except on the power-of-two ranges, where it rejects the top range values; and when all eight are rejected it hashes the next cursor. No captured value fell in either case.
2.4RNG Isolation
Each shuffle step within a bet uses its own cursor in the HMAC message (clientSeed:nonce:cursor), and each bet its own nonce, so every step and every bet gets its own HMAC output. HMAC-SHA256 is a pseudorandom function: one output tells you nothing practical about another. No state is shared between steps, bets or epochs.
Evidence: computeDrawFromBuffer in 2.1 is a pure function: no module state, no external calls, no memory between bets. It takes (keyBuffer, clientSeed, nonce) and returns the draw. Same inputs, same output.
2.5Monte Carlo Simulation (40M Rounds)
A 40,000,000-round simulation, 1,000,000 rounds for each of the 40 configurations, checks that the draw gives the expected hit distribution at scale. Each configuration has its own seed pair, generated once and pinned in src/sim-seeds.ts, so the run is reproducible.
| Metric | Value |
|---|---|
| Average simulated RTP | 99.970% |
| Average theoretical RTP | 99.900% |
| Hit distribution (α = 0.01) | 0 / 40 configs fail |
| Bonferroni-corrected (α/40) | 0 / 40 fail |
| Grid uniformity (α/40) | 0 / 40 fail |
| Serial independence (α/40) | 0 / 40 fail |
// Each config uses its own seed pair — independent HMAC streams avoid// cross-config correlation from shared draw sequences.const seedPair = SIM_SEEDS[ci];const keyBuffer = Buffer.from(seedPair.server, 'hex');const clientSeed = seedPair.client; const { hitCounts, hitSequence, simulatedRTP, rtpSnapshots, numberCounts } = runConfig( keyBuffer, clientSeed, risk, picks, ROUNDS_PER_CONFIG,);Methodology: chi-squared goodness-of-fit of the hit counts against the hypergeometric P(k) = C(picks,k) × C(40−picks, 10−k) / C(40,10); grid uniformity of all 40 numbers; serial independence by lag-1 autocorrelation and a runs test. Every statistic is re-derived from the shipped rows by Step 19.
2.6Serial Independence
Serial independence means consecutive results are not correlated: one bet does not shape the next. Two checks run on each configuration in the simulation (1,000,000 rounds each), at the Bonferroni-corrected α/40:
Lag-1 autocorrelation: Correlation between consecutive hit counts. Expected r ≈ 0 for an independent sequence; z = r × √n.
Wald–Wolfowitz runs test: Counts runs above and below the median. On the 8 picks-1 and picks-2 configurations the median split is degenerate (z = 0, p = 1 by construction), so there the lag-1 check carries the result.
export function lag1Autocorrelation(series: number[]): number { const n = series.length; const mean = series.reduce((a, b) => a + b, 0) / n; let num = 0, den = 0; for (let i = 0; i < n - 1; i++) num += (series[i] - mean) * (series[i + 1] - mean); for (let i = 0; i < n; i++) den += (series[i] - mean) ** 2; return den === 0 ? 0 : num / den;}2.7Worked Example — Full RNG Trace
Real bet from the dataset: bet 34309702, MEDIUM risk, 8 picks, nonce 4. From keno-master-5100bets.json:
serverSeed = 94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9
clientSeed = dAn1wtkuDAXxQOKP
nonce = 4
risk = MEDIUM (difficulty=3)
picks = 8
selected = [1, 5, 6, 15, 17, 22, 33, 36]| i | cursor | range | HMAC[:8] | uint32 | j | swap |
|---|---|---|---|---|---|---|
| 39 | 0 | 40 | b8feba71 | 3,103,701,617 | 17 | pos[39]↔︎pos[17] |
| 38 | 1 | 39 | 5a417f90 | 1,514,241,936 | 12 | pos[38]↔︎pos[12] |
| 37 | 2 | 38 | e435da0a | 3,828,734,474 | 14 | pos[37]↔︎pos[14] |
| 36 | 3 | 37 | 34334094 | 875,774,100 | 10 | pos[36]↔︎pos[10] |
| 35 | 4 | 36 | 7ea8251d | 2,124,948,765 | 21 | pos[35]↔︎pos[21] |
2.01×. Payout: 0.01 × 2.01 = 0.0201.Technical Evidence & Verification5 sections
2.8Evidence Coverage Summary6 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Draw recomputation (Step 5) | 5,100 / 5,100 bets | Pass |
| Duel's Verify-tab code, cross-check (Step 23) | 5,100 / 5,100, same shuffle order | Pass |
| Key encoding (hex vs UTF-8) | Unit test: only the decoded key reproduces the known draws | Pass |
| Modulo bias (Step 22) | All 39 ranges enumerated; 0 of 198,900 steps rejected a value | Pass |
| No drand or other outside input (Step 5) | 5,100 / 5,100 reproduced from seeds and nonce alone | Pass |
| Simulation (Step 19) | 0 / 40 configs fail at α/40 | Pass |
2.9Code References8 source files
| File | Purpose |
|---|---|
| src/rng.ts | HMAC-SHA256 backward Fisher–Yates draw (computeDraw, computeDrawFromBuffer) |
| docs/ALGORITHM.md | The written specification src/rng.ts was built from |
| tests/keno/RngSpecTests.ts | The specification's 79 vector and property checks |
| src/operator-verifier.ts | Runs Duel's Verify-tab code unmodified (cross-check) |
| src/simulate.ts | Monte Carlo simulation (40M rounds Pass 1, Pass 2 on casino seeds) |
| src/stats.ts | Chi-squared, lag-1 autocorrelation, Wald–Wolfowitz runs test |
| tests/steps/bias.ts | Step 22: every shuffle range enumerated |
| tests/steps/simulation.ts | Steps 19–20: simulation results re-derived and replayed |
2.10Verified Invariants8 invariants
| Invariant | Result |
|---|---|
| Our draw matches the live game for all 5,100 bets | Pass |
| Key is hex-decoded (not UTF-8); the wrong encoding gives wrong draws | Pass |
| Every range 2–40: accepted values a whole multiple of the range (bias 0) | Pass |
| No outside input needed to compute a draw | Pass |
| Hit distribution consistent with the hypergeometric model in all 40 configs (1M rounds each) | Pass |
| Lag-1 and runs checks: 0 / 40 configs fail at α/40 | Pass |
| Simulated RTP per config consistent with 99.9% theoretical | Pass |
| A wrong client seed changes the drawn set on 5,100 / 5,100 bets | Pass |
2.11Datasets UsedSource artifacts
2.12Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 5 — Draw Recomputation (RNG + drand absent)
[PASS] Step 6 — Client Seed Influence
[PASS] Step 19 — Simulation Results — Pass 1 Integrity
[PASS] Step 22 — Draw Bias Bound (rejection ceiling, every range enumerated)
[PASS] Step 23 — Player-Verifier Parity (docs-site + live-site)Verifier Parity
Does the live game actually follow its own rules?
The verifier must produce the exact same drawn set as the live game for every bet, and the payout must follow from it exactly. Four implementations check every bet: ours, Duel's Verify-tab code and both ProvablyFair.org verifiers.
What we verified
- Every bet recomputed from seeds: the full drawn set, not just the payout
- Four implementations agree on every bet: ours, Duel's Verify-tab code and both ProvablyFair.org verifiers
- Payouts exact on integer units: stake × the paytable cell at 13 decimal places
- Every served multiplier equals the pinned paytable for all 40 configurations
- Picks, risk and stake are not inputs to the draw
- All four capture phases recompute: all 40 configurations at $0.01, and MEDIUM with 10 picks at $10
What this means for you
- The verifier isn't a simulation: it produces the same drawn set as the live game
- Every bet you play can be recomputed by anyone
- No hidden logic changes the draw based on how much you bet or what you pick
- Duel's published Verify code and our own implementation agree on every captured bet
- Every bet recomputed from seeds: the full drawn set, not just the payout
- Four implementations agree on every bet: ours, Duel's Verify-tab code and both ProvablyFair.org verifiers
- Payouts exact on integer units: stake × the paytable cell at 13 decimal places
- Every served multiplier equals the pinned paytable for all 40 configurations
- Picks, risk and stake are not inputs to the draw
- All four capture phases recompute: all 40 configurations at $0.01, and MEDIUM with 10 picks at $10
- The verifier isn't a simulation: it produces the same drawn set as the live game
- Every bet you play can be recomputed by anyone
- No hidden logic changes the draw based on how much you bet or what you pick
- Duel's published Verify code and our own implementation agree on every captured bet
Draw recomputationPass
Payout correctnessPass
amount_won = stake × the cell at 13 decimal places, exact on integer units, no tolerance (Step 7)Multiplier table integrityPass
kenoConfig.json cell; 40 / 40 configurations served (Step 8)Player verifiers & Duel's codePass
Bet-size independencePass
Config completenessPass
Multi-phase coveragePass
All 5,100 bets match our recomputation: the drawn set, the hits, the multiplier and the payout, across all four capture phases. Duel's Verify-tab code and both ProvablyFair.org verifiers agree on every bet.
| Check | Result | Evidence |
|---|---|---|
| Draw recomputation | Pass | 5,100 / 5,100: the drawn set matches for every bet (Step 5) |
| Payout correctness | Pass | All 5,100: amount_won = stake × the cell at 13 decimal places, exact on integer units, no tolerance (Step 7) |
| Multiplier table integrity | Pass | Every served multiplier equals the pinned kenoConfig.json cell; 40 / 40 configurations served (Step 8) |
| Player verifiers & Duel's code | Pass | This site's verifier and the main site's reproduce all 5,100 sets; Duel's Verify-tab code, run unmodified, gives the same shuffle order on all 5,100 (Step 23) |
| Bet-size independence | Pass | The draw takes no stake input; the 100 $10 bets recompute and settle by the same rules (Steps 5, 9) |
| Config completeness | Pass | All 40 configurations played live, at least 73 bets each; 190 of 260 payout cells reached (Step 10) |
| Multi-phase coverage | Pass | A: 32 configurations (picks 2–9) · B: picks 1 · C: picks 10 · D: $10 stake (Step 13) |
Draw recomputationPass
Payout correctnessPass
amount_won = stake × the cell at 13 decimal places, exact on integer units, no tolerance (Step 7)Multiplier table integrityPass
kenoConfig.json cell; 40 / 40 configurations served (Step 8)Player verifiers & Duel's codePass
Bet-size independencePass
Config completenessPass
Multi-phase coveragePass
All 5,100 bets match our recomputation: the drawn set, the hits, the multiplier and the payout, across all four capture phases. Duel's Verify-tab code and both ProvablyFair.org verifiers agree on every bet.
How It Works — Verifier Parity9 sections
3.1Why Parity Matters
If the verifier gives a different result from the live game, players can't rely on it. Parity has to be 100%: a single difference would point to a bug in the verifier, a change in the live game, or a different RNG. A player must be able to take the revealed seeds, run them through an independent verifier, and get the same drawn set they saw live.
3.2Four-Phase Collection Design
Data was captured in four phases on 11 April 2026, each aimed at a specific property. Together they cover every configuration, the smallest and largest pick counts, and the stake.
| Phase | Bets | Config | Bet Amount | Purpose |
|---|---|---|---|---|
| A — Configuration coverage | 3,000 | 32 configs (picks 2–9) | $0.01 | Mid-range pick counts at all 4 risk levels |
| B — Picks 1 | 1,000 | 4 configs (picks 1) | $0.01 | Smallest selection; the two consolation payouts |
| C — Picks 10 | 1,000 | 4 configs (picks 10) | $0.01 | Largest selection; highest per-bet variance |
| D — Stake equivalence | 100 | 1 config (MEDIUM, 10 picks) | $10.00 | Same rules at a higher stake; two auditor-set client seeds |
3.3Draw Recomputation (Step 5)
For every bet, the verifier computes the drawn set with computeDrawFromBuffer(key, clientSeed, nonce) from the epoch's revealed seed and compares it, as a set, with the served drawn_numbers. It also checks that every served and recomputed draw is exactly 10 distinct numbers from 1 to 40, and that each pick set is legal and echoed back unchanged.
for (const b of bets) { if (!structOk(b.response.drawn_numbers)) servedStructBad++; const picks = b.request.selected_positions; const picksLegal = Array.isArray(picks) && picks.length >= ctx.cfg.minPicks && picks.length <= ctx.cfg.maxPicks && new Set(picks).size === picks.length && picks.every(n => Number.isInteger(n) && n >= 1 && n <= G) && b.request.picks === picks.length; if (!picksLegal) illegalPicks++; if (JSON.stringify(b.response.selected_positions) !== JSON.stringify(picks) || b.response.difficulty !== b.request.difficulty) echoMismatch++; const ss = seedMap.get(b.seed.serverSeedHashed); if (!ss) { skipped++; recomputed.push(null); continue; } const key = Buffer.from(ss, 'hex'); const computed = computeDrawFromBuffer(key, b.seed.clientSeed, b.seed.nonce, G, DRAWN, census); recomputed.push(computed); if (!structOk(computed)) recomputedStructBad++; const apiSet = new Set(b.response.drawn_numbers); const compSet = new Set(computed); if (apiSet.size !== compSet.size || [...apiSet].some(n => !compSet.has(n))) { mismatches++; }}3.4Payout Math (Step 7)
For each bet, the verifier takes the paytable cell for the recomputed hit count, rounds it to the 13 decimal places Duel serves, multiplies by the stake, and compares the result with amount_won on integer units, with no tolerance. Every zero-paying cell must credit exactly 0. For example, MEDIUM/8 picks/4 hits has table value 4.035047673782158 and served multiplier 4.0350476737822; a $0.01 stake returns exactly $0.040350476737822.
let errors = 0, checked = 0, paying = 0, zeroPaid = 0, currencyEcho = 0, offGrid = 0;for (let i = 0; i < bets.length; i++) { const b = bets[i], c = cells[i]; checked++; if (c.cell === null) { errors++; continue; } try { const expected = settledPayoutUnits(b.request.amount, c.cell); const served = servedPayoutUnits(b.response.amount_won); if (expected !== served) errors++; if (c.cell > 0) paying++; else { zeroPaid++; if (served !== 0n) errors++; } if (toUnits(b.response.amount_currency, MONEY_DP) !== toUnits(b.request.amount, MONEY_DP)) currencyEcho++; } catch { offGrid++; }}3.5Multiplier Table Provenance (Step 8)
For each bet, the served multiplier string must equal the pinned kenoConfig.json cell for its risk, pick count and recomputed hits, displayed at 13 decimal places. Hits counted on the served draw must agree with hits on the recomputed draw. The config's own probability field is never read.
| Metric | Count |
|---|---|
| Bets checked | 5,100 |
| Served at the cell's full precision | 4,662 |
| Served rounded to 13 decimal places | 438 |
| Mismatches | 0 |
let mismatches = 0, servedHitDisagree = 0, exactCells = 0, roundedCells = 0;const rowsServed = new Set<string>();for (let i = 0; i < bets.length; i++) { const b = bets[i], c = cells[i]; if (countHits(b) !== c.hits) servedHitDisagree++; if (c.cell === null) { mismatches++; continue; } rowsServed.add(`${c.risk}|${c.picks}`); if (b.response.multiplier !== displayMultiplier(c.cell)) mismatches++; else if (String(c.cell) === b.response.multiplier) exactCells++; else roundedCells++;}const s8Ok = mismatches === 0 && servedHitDisagree === 0 && bets.length === EXPECTED_BETS;kenoConfig.json, all 40 rows. The pinned config has scaling_edge = []: every captured bet was priced at the 0.1% tier. Duel's stake tiers are covered in 4.5.3.6Consolation Payout Verification (Step 12)
Two of the 40 configurations pay something on zero hits. Step 12 checks every one of the 260 cells for anything out of pattern: a payout on zero hits, a zero between paying cells, or a cell lower than the one before it. Only the two declared consolation cells qualify.
| Config | Zero-Hit Multiplier | Verified |
|---|---|---|
| LOW picks=1 | 0.71× | ✅ |
| MEDIUM picks=1 | 0.41× | ✅ |
| All 38 other configs | 0× | ✅ |
3.7Phase D — Bet-Size Equivalence (Step 9)
Phase D placed 100 bets at $10 on MEDIUM, 10 picks, a configuration also played at $0.01. All 100 draws recompute from the revealed seeds, every multiplier is the same table cell the $0.01 stake is priced by, and every payout settles by the same exact rule. Phase D used two auditor-set pfaudit client seeds.
3.8Worked Example — Full Parity Verification
Real bet from Phase C: bet 34333136, LOW risk, 10 picks, nonce 0. From keno-master-5100bets.json:
serverSeed = d978b0fb5a2b9690a0052c0a232845d6b79b3cfd13976b6b75f14dcfd3716461
clientSeed = DJPPRaQ41Tl9XchI
nonce = 0
risk = LOW (difficulty=2)
picks = 10
selected = [6, 11, 13, 14, 16, 19, 21, 27, 32, 39]| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher–Yates: 39 HMAC-SHA256 calls, cursor 0–38 | Shuffled array |
| 2 | a[0..9] → drawn set | {4, 16, 19, 22, 30, 32, 33, 36, 37, 39} |
| 3 | Count hits: selected ∩ drawn | 4 hits (16, 19, 32, 39) |
| 4 | Multiplier lookup: LOW/10 picks, 4 hits | 1.31× |
| 5 | Payout: 0.01 × 1.31 | 0.0131 ✅ |
// computeDraw("d978b0fb...", "DJPPRaQ41Tl9XchI", 0)// 39 Fisher-Yates steps → drawn SET//// Multiplier lookup: kenoConfig.multipliers.LOW["10"][4]// = 1.31//// Payout: 0.01 × 1.31 = 0.0131// Live amount_won: 0.0131 ✅3.9Player Verifiers & Duel's Code (Step 23)
Step 23 runs three more implementations on all 5,100 bets, each from pinned bytes:
This site's verifier (derive.js, paytables.js, hmac-sha256.js): prints the drawn set our recomputation gives on every bet; its paytable equals the pinned config on 260 / 260 cells, and the multiplier it prints equals the served one on 5,100 / 5,100. The code on this site is byte-identical to the pinned copy.
The main-site verifier (www.provablyfair.org/verify-bets): prints the same drawn set on every bet. It shows no Keno multiplier.
Duel's Verify-tab code, copied on 25 September 2026 and run unmodified as a cross-check: returns our draw in the same shuffle order on every bet.
Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary7 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Draw recomputation (Step 5) | 5,100 / 5,100 bets: full drawn set | Pass |
| Payout math (Step 7) | 5,100 / 5,100, exact on integer units | Pass |
| Multiplier provenance (Step 8) | 5,100 / 5,100; all 40 configurations | Pass |
| Consolation payouts (Step 12) | The 2 declared cells, and no other out-of-pattern cell in 260 | Pass |
| Phase D at $10 (Step 9) | 100 / 100 draws and payouts | Pass |
| Config completeness (Step 10) | 40 / 40 configs, at least 73 bets each; 190 / 260 cells reached | Pass |
| Player verifiers and Duel's code (Step 23) | 5,100 / 5,100 on each | Pass |
3.11Code References6 source files
| File | Purpose |
|---|---|
| tests/steps/determinism.ts | Step 5: draw recomputation |
| tests/steps/payouts.ts | Steps 7–12: payout math, multiplier provenance, Phase D, coverage, edge fields, consolation cells |
| tests/steps/dataset.ts | Steps 13–18: population, dataset hash, epoch size, hit model, anti-circularity, Phase D seeds |
| tests/steps/parity.ts | Step 23: player verifiers and Duel's Verify-tab code |
| src/money.ts | Exact settlement on integer units |
| src/config.ts | Paytable lookup and hit probabilities |
3.12Datasets UsedSource artifacts
3.13Verified Invariants8 invariants
| Invariant | Result |
|---|---|
Recomputed drawn set matches the live drawn_numbers for all 5,100 bets | Pass |
amount_won = stake × the cell at 13 decimal places, exact, for all 5,100 bets | Pass |
Every served multiplier matches kenoConfig.json for all 40 configurations | Pass |
| Consolation payouts: LOW/1 pick (0.71×), MEDIUM/1 pick (0.41×), no others | Pass |
| Phase D ($10) draws and payouts follow the same rules as $0.01 | Pass |
| No inputs beyond (serverSeed, clientSeed, nonce) | Pass |
| All 40 risk/picks configurations present in live data | Pass |
| Both ProvablyFair.org verifiers and Duel's code agree on all 5,100 bets | Pass |
3.14Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 5 — Draw Recomputation (RNG + drand absent)
[PASS] Step 7 — Payout Math
[PASS] Step 8 — Multiplier Table Provenance
[PASS] Step 9 — Phase C Bet-Size Invariance (Phase D at $10)
[PASS] Step 10 — Configuration Completeness & Payout-Cell Coverage
[PASS] Step 11 — Captured Edge Fields (pinned scaling_edge empty)
[PASS] Step 12 — Consolation Payout Disclosure (LOW/MEDIUM picks=1 zero-hit)
[PASS] Step 23 — Player-Verifier Parity (docs-site + live-site)RTP & Payout Logic
Is the house edge what the casino claims?
The theoretical RTP is derived from first principles: hypergeometric hit probabilities applied to the pinned paytable give 99.9000% on all 40 configurations at the base stake tier, with no casino probability data. Duel's game settings state an edge for every stake tier, and the RTP claim rule finds every one of the 2,712 rows on its stated figure: PASS. In 35 of the 40 configurations the edge scales with stake above a threshold; that is explained from the config, not certified.
What we verified
- Theoretical RTP is 99.9000% on all 40 configurations at the base stake tier
- Derived from first principles: hypergeometric P(hits) × the paytable, with no casino probability data
- Exact rational arithmetic: 999/1000 on 16 configurations, within 1.125×10⁻¹⁶ on the other 24
- RTP claim rule: every stake tier sits on the edge Duel's game settings state for it; 0 of 2,712 rows beyond ±0.1 pp — PASS
- 40M simulated rounds average 99.970%, consistent with 99.9%
- Pass 2 finds no sign of server-seed cherry-picking, at its stated power
What this means for you
- At the base tier the house keeps 0.1% over the long run, whatever picks and risk you choose
- In 35 of the 40 configurations, Duel's edge rises above a threshold in 0.01% steps, to as much as 1.0%. Explained from the config, not certified
- The RTP figure is derived independently, not taken from the casino
- Duel's stated edge holds at every stake tier it lists
- Theoretical RTP is 99.9000% on all 40 configurations at the base stake tier
- Derived from first principles: hypergeometric P(hits) × the paytable, with no casino probability data
- Exact rational arithmetic: 999/1000 on 16 configurations, within 1.125×10⁻¹⁶ on the other 24
- RTP claim rule: every stake tier sits on the edge Duel's game settings state for it; 0 of 2,712 rows beyond ±0.1 pp — PASS
- 40M simulated rounds average 99.970%, consistent with 99.9%
- Pass 2 finds no sign of server-seed cherry-picking, at its stated power
- At the base tier the house keeps 0.1% over the long run, whatever picks and risk you choose
- In 35 of the 40 configurations, Duel's edge rises above a threshold in 0.01% steps, to as much as 1.0%. Explained from the config, not certified
- The RTP figure is derived independently, not taken from the casino
- Duel's stated edge holds at every stake tier it lists
Anti-circularityPass
Theoretical RTPPass
RTP claim (RTP-CLAIM 1.2.0)Pass
Captured edge fieldsPass
scaling_edge = []; effective_edge 0.1 on all 5,100 bets, at $0.01 and $10 (Step 11)Payout exactnessPass
Simulation (Pass 1)Pass
Cherry-pick test (Pass 2)Pass
Consolation payoutsPass
Stake tiersInfo
Independently derived hypergeometric probabilities applied to the pinned paytable give 99.9000% on all 40 configurations, computed exactly, not estimated. Duel's stated edge holds under the RTP claim rule on every stake tier it lists. Payouts are exact on every captured bet, and the simulation and cherry-pick test find no sign of bias. Tiers above the base tier are explained from the config, not certified.
RTP claim (RTP-CLAIM 1.2.0): all 2,712 stake-tier rows on their stated figure, PASS.
| Check | Result | Evidence |
|---|---|---|
| Anti-circularity | Pass | P(hits) = C(n,k) × C(40−n, 10−k) / C(40,10) in exact integers; the casino's probability field is never read; both negative controls rejected (Step 17) |
| Theoretical RTP | Pass | 99.9000% on all 40 configurations; exact rational 999/1000 on 16, the other 24 within 1.125×10⁻¹⁶ (Step 17) |
| RTP claim (RTP-CLAIM 1.2.0) | Pass | Claim: tiered, from Duel's game settings (91 stated edges, 0.1% to 1.0%). 2,712 rows, the 40 audited configurations and 2,672 tiers of the 5 October 2026 config: 0 beyond ±0.1 pp (Step 17). A house-side miss would read RTP FIGURE OVERSTATED (exit 5) |
| Captured edge fields | Pass | Pinned config scaling_edge = []; effective_edge 0.1 on all 5,100 bets, at $0.01 and $10 (Step 11) |
| Payout exactness | Pass | 2,209 paying and 2,891 zero-paying bets exact; served multiplier = pinned table on 5,100 / 5,100 (Steps 7, 8) |
| Simulation (Pass 1) | Pass | 40M rounds, 1M per configuration; average 99.970%; 0 / 40 fail at α/40 (Step 19) |
| Cherry-pick test (Pass 2) | Pass | Test A 13 / 1,666 (binomial p 0.848); Test B 57 / 1,666 (p 0.9992); served-return screen z = +1.49, bootstrap p 0.919; 80% power for a 0.234× per-bet shortfall (Step 20) |
| Consolation payouts | Pass | LOW and MEDIUM with 1 pick pay 0.71× and 0.41× on zero hits: partial returns of the stake (Step 12) |
| Stake tiers | Info | 2,672 tiers in Duel's 5 October 2026 config. In 35 of the 40 configurations, above a threshold ($90.20 to $99,546.07), the edge rises 0.01% per tier, to 1.0% at most. Explained from the config, not certified |
Anti-circularityPass
Theoretical RTPPass
RTP claim (RTP-CLAIM 1.2.0)Pass
Captured edge fieldsPass
scaling_edge = []; effective_edge 0.1 on all 5,100 bets, at $0.01 and $10 (Step 11)Payout exactnessPass
Simulation (Pass 1)Pass
Cherry-pick test (Pass 2)Pass
Consolation payoutsPass
Stake tiersInfo
Independently derived hypergeometric probabilities applied to the pinned paytable give 99.9000% on all 40 configurations, computed exactly, not estimated. Duel's stated edge holds under the RTP claim rule on every stake tier it lists. Payouts are exact on every captured bet, and the simulation and cherry-pick test find no sign of bias. Tiers above the base tier are explained from the config, not certified.
How It Works — RTP & Payout Logic11 sections
4.1Anti-Circularity Proof (Step 17)
The anti-circularity proof derives the 99.9% RTP from hypergeometric probabilities applied to the pinned multiplier table, without using any casino-supplied probability data. The multipliers come from Duel's config and are hash-pinned; the probabilities are derived independently. The proof has two parts:
| Component | Formula | Source |
|---|---|---|
| Hit probability | P(hits=k) = C(picks,k) × C(40−picks, 10−k) / C(40,10) | Hypergeometric distribution: counting, not casino data |
| Multiplier | kenoConfig.multipliers[risk][picks][k] | Casino-supplied, from the pinned kenoConfig.json |
| RTP | Σ P(k) × multiplier(k), k = 0 to picks | Independent probability × pinned multiplier |
| Result | = 0.999 for all 40 configurations (exactly 999/1000 on 16; within 1.125×10⁻¹⁶ on the other 24) | Computed exactly, not estimated |
| Picks | Risk | P(0 hits) | Multiplier(0) | Σ P×M | RTP |
|---|---|---|---|---|---|
| 1 | Classic | 0.75000 | 0× | 0.99900 | 99.9% |
| 1 | Low | 0.75000 | 0.71× | 0.99900 | 99.9% |
| 5 | Classic | 0.21657 | 0× | 0.99900 | 99.9% |
| 10 | High | 0.03544 | 0× | 0.99900 | 99.9% |
Anti-Circularity Verification:
const RTP_DEVIATION_BOUND = 16 * Number.EPSILON;let maxDeviation = 0;let worstConfig = '';let worstRTP = 0;let configsEvaluated = 0;for (const { risk, picks } of cfg.allConfigs()) { configsEvaluated++; let indepRTP = 0; for (let k = 0; k <= picks; k++) { indepRTP += cfg.hitProbability(picks, k) * cfg.multiplier(risk, picks, k); } // A non-finite RTP (a NaN multiplier) must not compare its way past the bound. const deviation = Number.isFinite(indepRTP) ? Math.abs(indepRTP - 0.999) : Infinity; if (deviation > maxDeviation) { maxDeviation = deviation; worstConfig = `${risk}/picks=${picks}`; worstRTP = indepRTP; }}Why this is non-circular: P(hits) comes from sampling 10 of 40 without replacement, a property of the game, not of Duel's data. The non-selected population is 40 − picks. The multiplier table is the only casino input. Step 17 also checks, in integer arithmetic, that the weights sum to C(40,10) = 847,660,528 for every pick count, and rejects two negative controls: a corrupted probability and a corrupted table cell.
4.2Captured Edge Fields (Step 11)
The 0.1% house edge is built into the multiplier values themselves: each base-tier table returns 99.9% (4.1). Step 11 checks the two edge fields the capture carries. The pinned kenoConfig.json has scaling_edge: [], and every one of the 5,100 bets reports effective_edge 0.1 (percent), at both captured stakes, $0.01 and $10.
That covers the captured stakes only. Both sit below the lowest threshold in Duel's 5 October 2026 config ($90.20), so the capture alone can't show whether a stake ladder was live in April. Duel's Keno page also shows a "Zero Edge" panel (0% edge within a daily allowance). That is noted, not tested.
scaling_edge = [] in the pinned config, and effective_edge 0.1 on all 5,100 bets. Every captured bet was priced at the 0.1% tier. The draw and the payout never read the field.4.3Full RTP Table — All 40 Configurations
All 40 configurations have the same theoretical RTP, 99.900%. The simulated RTP varies by configuration with sampling variance, most in the high-risk configurations where rare large multipliers dominate.
| Config | Theoretical RTP | Simulated RTP | Deviation |
|---|---|---|---|
| CLASSIC/p1 | 99.900% | 100.059% | +0.159% |
| CLASSIC/p2 | 99.900% | 99.991% | +0.091% |
| CLASSIC/p3 | 99.900% | 99.860% | −0.040% |
| CLASSIC/p4 | 99.900% | 99.958% | +0.058% |
| CLASSIC/p5 | 99.900% | 100.028% | +0.128% |
| CLASSIC/p6 | 99.900% | 99.870% | −0.030% |
| CLASSIC/p7 | 99.900% | 99.778% | −0.122% |
| CLASSIC/p8 | 99.900% | 99.614% | −0.286% |
| CLASSIC/p9 | 99.900% | 100.242% | +0.342% |
| CLASSIC/p10 | 99.900% | 99.931% | +0.031% |
| LOW/p1 | 99.900% | 99.912% | +0.012% |
| LOW/p2 | 99.900% | 99.741% | −0.159% |
| LOW/p3 | 99.900% | 99.817% | −0.083% |
| LOW/p4 | 99.900% | 99.439% | −0.461% |
| LOW/p5 | 99.900% | 99.759% | −0.141% |
| LOW/p6 | 99.900% | 100.714% | +0.814% |
| LOW/p7 | 99.900% | 99.499% | −0.401% |
| LOW/p8 | 99.900% | 99.726% | −0.174% |
| LOW/p9 | 99.900% | 99.958% | +0.058% |
| LOW/p10 | 99.900% | 99.936% | +0.036% |
| MEDIUM/p1 | 99.900% | 99.908% | +0.008% |
| MEDIUM/p2 | 99.900% | 99.745% | −0.155% |
| MEDIUM/p3 | 99.900% | 99.638% | −0.262% |
| MEDIUM/p4 | 99.900% | 99.489% | −0.411% |
| MEDIUM/p5 | 99.900% | 101.340% | +1.440% |
| MEDIUM/p6 | 99.900% | 99.029% | −0.871% |
| MEDIUM/p7 | 99.900% | 99.751% | −0.149% |
| MEDIUM/p8 | 99.900% | 100.278% | +0.378% |
| MEDIUM/p9 | 99.900% | 99.840% | −0.060% |
| MEDIUM/p10 | 99.900% | 100.030% | +0.130% |
| HIGH/p1 | 99.900% | 100.014% | +0.114% |
| HIGH/p2 | 99.900% | 99.931% | +0.031% |
| HIGH/p3 | 99.900% | 99.178% | −0.722% |
| HIGH/p4 | 99.900% | 98.846% | −1.054% |
| HIGH/p5 | 99.900% | 101.786% | +1.886% |
| HIGH/p6 | 99.900% | 101.685% | +1.785% |
| HIGH/p7 | 99.900% | 99.991% | +0.091% |
| HIGH/p8 | 99.900% | 100.440% | +0.540% |
| HIGH/p9 | 99.900% | 100.290% | +0.390% |
| HIGH/p10 | 99.900% | 99.774% | −0.126% |
4.4RTP Claim Rule (RTP-CLAIM 1.2.0)
Framework 1.1 holds the audited RTP to the figure the casino publishes. The rule looks for a claim in six places: the game page, fairness page, help page, bet panel, rules or game settings. For Keno, Duel's game settings (the Keno config, as fetched on 5 October 2026) state a house_edge for every stake tier of every configuration: 91 distinct edges, from 0.1% to 1.0%. So the claim is tiered: each row is held to 1 minus the edge stated for its tier. The 40 audited configurations are held to the 0.1% tier, where every captured bet was priced.
The claim is scored on Step 17 against a ±0.1 pp band. A figure more than 0.1 pp below its claim, on the house side, makes the verdict RTP FIGURE OVERSTATED (exit 5). It never makes it NOT PROVABLY FAIR, because the draws themselves pass.
The help page's site-wide line, "At the moment we stand at 99.9%", names no game or stake, so it is noted, not tested. So is the "Zero Edge" panel.
| Rows | Settings | Exact RTP | Beyond the band |
|---|---|---|---|
| Audited April table (0.1% tier) | 40 | 99.900000% | 0 |
| 5 October 2026 config, 0.1% tier | 40 | 99.900000% | 0 |
| 5 October 2026 config, scaled tiers | 2,632 | 99.000000% – 99.890000% | 0 |
rtp-claim: ENFORCED — PASSrtp-claim: claim stake tiers house_edge=0.001 99.900000% · house_edge=0.0011 99.890000% · … · house_edge=0.01 99.000000% (91 tiers) — source: game settings …rtp-claim: band ±0.10 pp · 2,712 settings · true min 99.000000% (live-2026-10-05 risk=LOW picks=1 house_edge=0.01 bet 983346.462246445007622–993259.519384399522096) · true max 99.900000% (live-2026-10-05 risk=MEDIUM picks=10 house_edge=0.001 bet 0–2502.085070892410386)rtp-claim: house side beyond band: 0 · player-favourable beyond band: 0 · worst live-2026-10-05 risk=CLASSIC picks=5 house_edge=0.0049 bet 28134.85443866390051–28717.174295956523565 at 0.000000 pprtp-claim: outcome PASS · minimal fix: none — the claim holds for every setting it states a figure forrtp-claim: committed table outputs/rtp-claim-table.json: equals this run; sha256 01af5577a3032d46… matches the pinoutputs/rtp-claim-table.json, pinned by SHA-256.4.5House Edge & Stake Tiers (5 October 2026 config)
Duel's Keno config as fetched on 5 October 2026 gives each of the 40 configurations a list of contiguous stake tiers, 2,672 in all. Each list starts with a 0.1% tier. Above a per-configuration threshold the edge rises in 0.01% steps to as much as 1.0% (99.0% RTP), and the multipliers shrink to match. The draw is the same at every tier; only the payout per outcome changes.
Thresholds run from $90.20 (HIGH, 6 picks) to $99,546.07 (LOW, 1 pick). The config has no maximum-profit field, but in 15 configurations the last tier ends where the top payout's profit reaches $3,000,000. Five of them, LOW with 8–10 picks and MEDIUM with 9–10, reach that point inside the 0.1% tier and never scale.
This audit certifies the 0.1% tier, where every captured bet was priced. No bet on a scaled tier was captured.
Tier selection: The tiers are contiguous (each tier's max_bet is the next tier's min_bet), so a stake falls in exactly one tier, and that tier's edge and multipliers apply. Every tier's exact RTP is within 3.31 × 10⁻⁹ of 1 minus its stated edge.
Two 0.1% tables: The 5 October 0.1% tier equals the audited table on 236 of 260 cells; the other 24 are the audited value rounded to 8 decimal places, at most 4.49 × 10⁻⁹ away. Which of the two paid a bet that day was not captured.
| Bet range (CLASSIC, 1 pick) | House edge | RTP | 1-hit multiplier |
|---|---|---|---|
| $0 – $8,344 | 0.1% | 99.9% | 3.996× |
| $15,874 – $16,711 | 0.2% | 99.8% | 3.992× |
| $41,102 – $41,946 | 0.5% | 99.5% | 3.980× |
| $83,604 – $84,459 | 1.0% | 99.0% | 3.960× |
| Config | Tiers | Base-tier ceiling | Edge range |
|---|---|---|---|
| LOW, 1 pick | 91 | $99,546.07 | 0.1% – 1.0% |
| CLASSIC, 1 pick | 91 | $8,344.46 | 0.1% – 1.0% |
| HIGH, 6 picks | 91 | $90.20 | 0.1% – 1.0% |
| HIGH, 10 picks | 8 | $1,549.74 | 0.1% – 0.17% |
| CLASSIC, 10 picks | 3 | $12,882.75 | 0.1% – 0.12% |
| LOW / MEDIUM, 10 picks | 1 | $2,502.09 | 0.1% (no scaling) |
4.6Simulation Pass 1 — Pinned Seeds (Step 19)
The derivation in 4.1 gives 99.9000% on every configuration. The simulation checks that the draw code behaves that way in practice: 40 million rounds, 1,000,000 per configuration, each configuration on its own pinned seed pair, independent of any casino data.
Hit distribution: Observed hit counts against the hypergeometric expectation. 0 / 40 fail at α = 0.01, and 0 / 40 at the Bonferroni α/40 = 0.00025.
Serial independence: Lag-1 autocorrelation and a runs test on consecutive hit counts. 0 / 40 fail.
RTP: Average simulated RTP 99.970% against 99.900% theoretical, consistent with sampling variance.
for (let nonce = 0; nonce < rounds; nonce++) { const drawn = computeDrawFromBuffer(keyBuffer, clientSeed, nonce, cfg.gridSize, cfg.drawnCount); const drawnSet = new Set(drawn); for (const x of drawn) numberCounts[x - 1]++; let hits = 0; for (let p = 1; p <= picks; p++) { if (drawnSet.has(p)) hits++; } hitCounts[hits]++; hitSequence[nonce] = hits; totalPayout += cfg.multiplier(risk, picks, hits); const roundNum = nonce + 1; if (sampleSet.has(roundNum)) { rtpSnapshots.set(roundNum, totalPayout / roundNum); }} What the simulation adds. Each round computes a draw from scratch with the same HMAC-SHA256 backward Fisher–Yates code used to check the live bets, then pays it from the pinned table. A return consistent with 99.9% over millions of rounds shows the code and the math agree. npm test re-derives every statistic from the committed results and replays the first 1,000 rounds of each configuration; npm run test:full reruns it all.
4.7Cherry-Pick Detection — Pass 2 (Step 20)
Could the casino have chosen server seeds that start badly for players? Pass 2 takes every server seed Duel actually used, 102 of them, plays each for 10,000 nonces on the configurations its epoch served, and compares the early window (nonces 0–49, where the capture bet) with the rest.
Test A — overall distribution: Does a seed × config combination's hit distribution over 10,000 nonces depart from the hypergeometric model? 13 of 1,666 fail at α = 0.01, within the expected range.
Test B — early vs late: Is the early window significant at 0.05 while the later nonces are not? 57 of 1,666 flags. The nominal rate is 0.05 × 0.95 = 0.0475 (79.1 expected); the tail is computed at 0.05, the more lenient choice.
Served-return screen: Is the return of the 5,100 served bets below its exact expectation? Counting each bet once, whatever its stake, they returned 5,656.7× against an expected 5,094.9× (z = +1.49): more than expected, not less. The 91.385% in 4.10 is weighted by stake, so the 100 $10 bets dominate it.
| Test | Result |
|---|---|
| Seeds tested | 102 |
| Seed × config combinations | 1,666 |
| Test A: full-range fails (p < 0.01) | 13 / 1,666 — binomial tail p 0.848 |
| Test B: early-only flags | 57 / 1,666 — binomial tail p 0.9992 |
| Served-return screen | z = +1.49; bootstrap lower-tail p 0.919 (B = 10,000) |
| Detection power | 80% for a per-bet return shortfall of 0.234× |
let testARecount = 0, flagsRecount = 0, flagDisagree = 0, p2NonFinite = 0, bothWindows = 0;for (const r of p2rows) { if (!isNum(r.full_range_p) || !isNum(r.early_p) || !isNum(r.late_p)) { p2NonFinite++; continue; } if (r.full_range_p < 0.01) testARecount++; const flag = r.early_p < 0.05 && r.late_p >= 0.05; if (flag) flagsRecount++; if (flag !== r.cherry_pick_flag) flagDisagree++; if (r.early_p < 0.05 && r.late_p < 0.05) bothWindows++;}4.8Bet-Size Invariance (Step 9)
Phase D placed 100 bets at $10 on MEDIUM with 10 picks, a configuration also played at $0.01. All 100 draws recompute from the revealed seeds through the same HMAC-SHA256 path; the stake is not an input to the draw. Both stakes settle against the same base-tier table. On Duel's live config a larger stake can select a higher-edge tier (4.5), which changes the multiplier, never the draw.
| Metric | Phase C ($0.01) | Phase D ($10) |
|---|---|---|
| Bets | 1,000 | 100 |
| Config | 4 configs (picks=10) | 1 config (MEDIUM picks=10) |
| Draws recomputed | 1,000/1,000 | 100/100 |
| Multiplier table | kenoConfig.json (base tier) | kenoConfig.json (base tier) |
| RNG path | HMAC-SHA256 Fisher-Yates | HMAC-SHA256 Fisher-Yates |
4.9Consolation Payout Design (Step 12)
Two configurations pay something on zero hits, softening the worst outcome for single-pick bets at low and medium risk. The returns are partial (0.71× and 0.41× of the stake), so still a net loss, and they are paid for by lower multipliers on the same configurations.
| Config | P(0 hits) | Zero-Hit Multiplier | Weighted Contribution |
|---|---|---|---|
| LOW picks=1 | 0.750000 | 0.71× | 0.532500 |
| MEDIUM picks=1 | 0.750000 | 0.41× | 0.307500 |
| All 38 others | varies | 0× | 0.000000 |
4.10Informational Items (Not Scored)
Reported for transparency, not scored. They show the return observed during the capture.
| Item | Value | Context |
|---|---|---|
| Phase A observed return | 118.478% | 3,000 bets at $0.01 (picks 2–9) |
| Phase B observed return | 105.378% | 1,000 bets at $0.01 (picks 1) |
| Phase C observed return | 95.821% | 1,000 bets at $0.01 (picks 10) |
| Phase D observed return | 90.388% | 100 bets at $10 (MEDIUM, 10 picks) |
| Overall observed return | 91.385% | 5,100 bets, $1,050 wagered; Phase D is most of the money |
4.11Worked Example — Payout Verification
Real bet from Phase A: bet 34309818, CLASSIC risk, 5 picks, nonce 32. From keno-master-5100bets.json:
serverSeed = 94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9
clientSeed = dAn1wtkuDAXxQOKP
nonce = 32
risk = CLASSIC (difficulty=1)
picks = 5
selected = [3, 4, 22, 30, 40]Step 1 — Draw computation: computeDraw(serverSeed, clientSeed, 32) → 39 Fisher-Yates steps → drawn SET = {2, 3, 4, 13, 18, 21, 23, 26, 31, 32}
Step 2 — Hit count: selected ∩ drawn = {3, 4} → 2 hits
Step 3 — Multiplier lookup: kenoConfig.multipliers.CLASSIC["5"][2] = 1.4
Step 4 — Payout: 0.01 × 1.4 = 0.014
| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher–Yates: 39 HMAC calls | drawn set = {2, 3, 4, 13, 18, 21, 23, 26, 31, 32} ✅ |
| 2 | Count hits: selected ∩ drawn | 2 hits (3, 4) |
| 3 | Multiplier: CLASSIC/5 picks, 2 hits | 1.4× |
| 4 | RTP check: P(2 hits) × 1.4 | P = 0.27766, contribution = 0.38872 |
| 5 | Payout: 0.01 × 1.4 | 0.014 ✅ |
// CLASSIC, 5 picks: the RTP of this bet's configuration// P(hits=k) = C(5,k) × C(35, 10−k) / C(40,10)//// k=0: 0.21657 × 0 = 0.00000// k=1: 0.41648 × 0.25 = 0.10412// k=2: 0.27766 × 1.4 = 0.38872// k=3: 0.07933 × 4.150066896551724 = 0.32923// k=4: 0.00957 × 17 = 0.16276// k=5: 0.00038 × 37 = 0.01417//// Σ P×M = 0.999000 (99.9%) ✅Technical Evidence & Verification5 sections
4.12Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Anti-circularity (Step 17) | 40 / 40 configs; exact rational check; 2 negative controls | Pass |
| RTP claim (Step 17) | 2,712 rows, 0 beyond ±0.1 pp | Pass |
| Captured edge fields (Step 11) | scaling_edge = []; effective_edge 0.1 on 5,100 / 5,100 | Pass |
| Stake tiers (5 October 2026 config) | 2,672 tiers, 0.1%–1.0%; explained from the config | Info — see 4.5 |
| Consolation payouts (Step 12) | The 2 declared cells, no others | Pass |
| Simulation Pass 1 (Step 19) | 40M rounds; 0 / 40 fail at α/40 | Pass |
| Simulation Pass 2 (Step 20) | 1,666 combinations; Test A 13, Test B 57; served-return z = +1.49 | Pass |
| Bet-size invariance (Step 9) | 100 / 100 Phase D at $10 | Pass |
4.13Code References8 source files
| File | Purpose |
|---|---|
| tests/steps/dataset.ts | Step 17: anti-circularity, exact RTP and the RTP claim |
| src/exact.ts | Integer binomials and exact rational RTP |
| src/rtp-claim.ts | Framework rule RTP-CLAIM 1.2.0 |
| src/rtp-settings.ts | The tiered claim and the RTP claim table |
| src/live-config.ts | The 5 October 2026 tiers, recomputed (informational) |
| tests/steps/payouts.ts | Steps 9, 11, 12: bet-size invariance, edge fields, consolation cells |
| tests/steps/simulation.ts | Steps 19–20: simulation re-derived and cherry-pick test |
| src/simulate.ts | Monte Carlo simulation (40M rounds Pass 1, Pass 2) |
4.14Datasets UsedSource artifacts
4.15Verified Invariants9 invariants
| Invariant | Result |
|---|---|
| Σ P(hits) × multiplier = 0.999, to within 1.125×10⁻¹⁶, for all 40 configs (non-circular) | Pass |
| Hypergeometric weights sum to C(40,10) for every pick count (exact integers) | Pass |
| Every RTP-claim row within ±0.1 pp of its stated tier | Pass |
Every captured bet priced at the 0.1% tier (effective_edge 0.1) | Pass |
| Simulated RTP average 99.970% across 40M rounds | Pass |
| 0 / 40 configs fail at Bonferroni α/40 | Pass |
| Pass 2 within its declared thresholds across 102 casino seeds | Pass |
| Phase D ($10) bets follow the same draw and table as $0.01 | Pass |
| Consolation payouts (LOW/MEDIUM, 1 pick) consistent with 99.9% RTP | Pass |
4.16Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 9 — Phase C Bet-Size Invariance (Phase D at $10)
[PASS] Step 11 — Captured Edge Fields (pinned scaling_edge empty)
[PASS] Step 12 — Consolation Payout Disclosure (LOW/MEDIUM picks=1 zero-hit)
[PASS] Step 16 — Hit Symmetry (hypergeometric mode verification)
[PASS] Step 17 — Probability Independence (Anti-Circularity)
[PASS] Step 19 — Simulation Results — Pass 1 Integrity
[PASS] Step 20 — Simulation Results — Pass 2 Cherry-Pick TestFairness Integrity Testing
Does the implementation maintain fairness under non-standard conditions?
Sections 1–4 prove the game is mathematically fair. Section 5 proves the implementation maintains integrity under non-standard conditions. We applied 15 standard fairness integrity tests covering nonce integrity, seed commitment, outcome determinism, cross-player isolation, and payout integrity. 14 tests passed and 1 is not applicable to this game type.
What we verified
- Nonce tampering — can the sequence be forced, replayed, or skipped?
- Seed injection — can server or client seed fields be overridden via API?
- Outcome replay — can a completed bet be replayed for duplicate payouts?
- Cross-player isolation — can one player's seeds or outcomes affect another's?
- Payout tampering — can multiplier or payout values be injected client-side?
- Parameter limits — can invalid pick counts or risk levels be submitted?
What this means for you
- Across the 15 tests we ran, no API path allowed outcomes to be altered, replayed, or injected — by player or casino
- Once a bet is placed, the result cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player
- The server rejects malformed, out-of-range, and duplicate requests
- Nonce tampering — can the sequence be forced, replayed, or skipped?
- Seed injection — can server or client seed fields be overridden via API?
- Outcome replay — can a completed bet be replayed for duplicate payouts?
- Cross-player isolation — can one player's seeds or outcomes affect another's?
- Payout tampering — can multiplier or payout values be injected client-side?
- Parameter limits — can invalid pick counts or risk levels be submitted?
- Across the 15 tests we ran, no API path allowed outcomes to be altered, replayed, or injected — by player or casino
- Once a bet is placed, the result cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player
- The server rejects malformed, out-of-range, and duplicate requests
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
15 standard fairness integrity tests: 14 pass, 1 N/A (single-step game).
Category Coverage
| Check | Result | Evidence |
|---|---|---|
| Nonce integrity | Pass | Sequential, server-controlled, no duplicates across 102 epochs; 2 nonces missed on retried requests (capture script, not Duel) |
| Seed commitment integrity | Pass | Locked at bet acceptance, unique per epoch — 102/102 verified |
| Outcome determinism | Pass | Identical inputs produce identical outcomes — 5,100/5,100 confirmed |
| Round & player isolation | Pass | Per-user seeds, serial independence confirmed (0/40 fail in simulation) |
| Payout integrity | Pass | Parameter limits enforced (6/6 invalid selectedPositions rejected); injected payout fields ignored (0 honoured); server-computed multiplier consistent across all probes |
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
15 standard fairness integrity tests: 14 pass, 1 N/A (single-step game).
How It Works — Fairness Integrity Testing2 sections
5.1Framework Overview
Testing follows the ProvablyFair.org Fairness Integrity Framework — a structured methodology derived from real, historically observed failures in provably fair systems. Five categories target specific fairness properties. Scope boundary: S5 tests whether fairness guarantees hold under non-standard API interaction. Platform-level implementation testing falls outside standard certification.
| Category | Tests | What It Catches |
|---|---|---|
| Nonce Integrity | 4 | Sequence gaps, server-side nonce manipulation, session continuity |
| Seed Commitment | 5 | Mid-epoch seed changes, seed reuse, predictable seed generation |
| Outcome Determinism | 2 | Non-deterministic outputs, outcome replay |
| Player Isolation | 2 | Cross-round correlation, cross-user outcome dependence |
| Payout Integrity | 2 | Parameter enforcement, server-side computation verification |
5.2Severity Framework & Hard Fail Criteria
Findings are classified by severity. Hard fail criteria — any one triggers a NOT PROVABLY FAIR verdict.
| Severity | Meaning | Action |
|---|---|---|
| PASS | Test passed — no issue detected | None |
| N/A | Test not applicable to this game type | None |
| FLAG | Anomaly detected, documented for transparency | Disclosed |
| HARD FAIL | Fairness guarantee cannot be confirmed | Certification blocked until remediated |
| Condition | Consequence |
|---|---|
| Nonce gap or duplicate within epoch | Outcome sequence integrity broken |
| Server seed changed mid-epoch | Commit-reveal guarantee broken |
| Draw recomputation mismatch | Undisclosed inputs affecting outcomes |
| Client seed not used in HMAC | Player has no influence on outcomes |
15 tests · 14 pass · 1 N/A
Nonce Integrity4/4
FI-NONCE-001PassEach bet increments the nonce sequentially with no gaps, repeats, or resets — preventing the server from skipping unfavourable outcomes
FI-NONCE-002PassNonce progression is server-controlled — the client cannot inject, skip, or replay a nonce value via the API
S1, Step 4 — server controls nonce assignment. Client bet requests do not include a nonce field.
FI-NONCE-003PassSubmitting an invalid or out-of-sequence nonce does not produce a game outcome — the server rejects the request
API probe — 7 adversarial nonce values (−1, 0, 999999999, 'abc', INT32_MAX, INT32_MAX+1, 9e18) injected into bet requests. All 7 silently ignored; server assigned valid sequential nonces. Continuity preserved (baseline 9 → post-test 17); no stack traces leaked.
FI-NONCE-004PassNonce sequence continues correctly after disconnect/reconnect — no reset to zero mid-epoch
Seed Commitment5/5
FI-SEED-001PassEmpty, null, or invalid client seeds are handled deterministically — the server enforces input requirements
API probe — 7/7 invalid client seeds rejected (empty, null, oversized >1000 chars, special chars, emoji, CJK, whitespace-only). All Keno bets after each rejection remained functional; no stack traces leaked.
FI-SEED-002PassOnce a bet is accepted, the seed pair is locked for the epoch — no mid-epoch mutation of server or client seed is possible
FI-SEED-003PassEach epoch uses a unique server seed — no seed is reused across epochs or sessions
S1, Step 1 — 102 distinct revealed server seeds, 0 reuse detected.
FI-SEED-004PassNo shared seed pool across users — each player's seeds are independently generated and isolated
API probe — 10 concurrent seed rotations on Account A and 10 on Account B. Zero hash collisions across 20 rotations; all hashes within each account distinct. Full account isolation confirmed.
FI-SEED-005PassServer seeds show no correlation with timestamps, sequential patterns, or other predictable inputs
API probe — 10 rotations spaced 5 seconds apart over ~50.6 seconds. All 10 server seed hashes distinct; no two shared 6+ leading hex characters. Time-correlated derivation ruled out.
Outcome Determinism2/2
FI-OUTCOME-001PassGiven identical inputs (serverSeed, clientSeed, nonce), the game always produces the same drawn number set — verified across all 5,100 live bets
S3, Step 5 — 5,100/5,100 bets independently recomputed from seeds, 0 SET mismatches.
FI-OUTCOME-002N/AA completed bet cannot be replayed via the API to generate a duplicate payout
Keno auto-resolves — single-step game with no separate cashout action. Nonce increments server-side after each bet. No replay surface exists.
Player Isolation2/2
FI-ISO-001PassRNG state is fully independent across rounds — no carry-over from one bet to the next. Each nonce produces a fresh HMAC-SHA256 computation
FI-ISO-002PassOne player's seeds, nonces, and outcomes cannot be observed or influenced by another player — complete cross-user isolation
Follows from seed uniqueness (FI-SEED-003) — if each user has a unique server seed, outcomes are isolated by construction. Confirmed by FI-SEED-004 — zero hash collisions across 20 cross-account rotations.
Payout Integrity2/2
FI-PAYOUT-001PassGame parameters cannot exceed defined limits — only valid pick counts (1–10) and risk levels (Classic, Low, Medium, High) are accepted
API probe — 6/6 invalid selectedPositions combinations rejected with HTTP 422 (0 picks, 11 picks, value=0, value=41, duplicate picks, non-integer pick). Both controls (3-pick and 10-pick max) and recovery bet accepted. No out-of-range values silently coerced.
FI-PAYOUT-002PassMultiplier and payout fields in the API request are ignored — the server computes all values from its own formula, not from client-supplied values
API probe — 5 injected fields (payout_multiplier=1000, drawn_numbers, matches=10, multiplier='99999', amount_won='999999') all silently ignored. Server computed drawn numbers and multiplier from the seed chain on every request. noInjectionHonoured=true.
Technical Evidence & Verification4 sections
5.3Coverage Summary15 checks
| Test ID | Category | Verification Source | Status |
|---|---|---|---|
| FI-NONCE-001 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-002 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-003 | Nonce | API probe | Pass |
| FI-NONCE-004 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-SEED-001 | Seed | API probe | Pass |
| FI-SEED-002 | Seed | S1, Steps 3 & 6 (data-driven) | Pass |
| FI-SEED-003 | Seed | S1, Step 1 (data-driven) | Pass |
| FI-SEED-004 | Seed | API probe | Pass |
| FI-SEED-005 | Seed | API probe | Pass |
| FI-OUTCOME-001 | Determinism | S3, Step 5 (data-driven) | Pass |
| FI-OUTCOME-002 | Determinism | Structural — single-step game | N/A |
| FI-ISO-001 | Isolation | S2, Step 19 (simulation) | Pass |
| FI-ISO-002 | Isolation | Structural — seed uniqueness | Pass |
| FI-PAYOUT-001 | Payout | API probe | Pass |
| FI-PAYOUT-002 | Payout | API probe | Pass |
5.4Additional Integrity Evidence (S1–S4)6 records
| Property | Source | Finding |
|---|---|---|
| 102/102 seed hashes verified | S1, Step 1 | Commit-reveal chain intact |
| 106/106 next-seed promotions | S1, Step 2 | Seed rotation chain intact |
| 5,100/5,100 exact parity | S3, Step 5 | No post-RNG conditional logic |
| Anti-circularity proven | S4, Step 17 | 0.1% house edge — independent probabilities, committed table |
| 57 cherry-pick flags (≤80) | S4, Step 20 | No seed pre-selection bias |
| 100.0% client seed influence | S1, Step 6 | Player entropy is genuine |
5.5Scope
This certification covers the 15 standard fairness integrity tests listed above — the minimum required to verify that the provably fair implementation holds up under non-standard conditions. This is not a penetration test. It focuses specifically on the provably fair implementation — not the operator's broader platform security.
Standard scope: The 15 tests above are our standard fairness integrity matrix. The list is applied to every game we audit, with per-game adaptations where a test does not apply (e.g. multi-step replay tests are N/A on auto-resolving single-step games like this one).
No infrastructure testing: Server security, network-level protections and operational controls fall under platform-level security, not game-level fairness, and sit outside this certification.
Point-in-time: Results apply to the game configuration and codebase at the time of audit. Post-audit changes require re-certification.
5.6Reproduction InstructionsRun locally
Data-driven tests (8 of 15): Fully reproducible from the open-source repo. These tests run against the captured dataset and produce deterministic results.
API probe tests (6 of 15): Verified by issuing live adversarial requests against the running game. Per-test evidence (HTTP status codes, server-assigned nonces, seed hashes, server-computed multipliers, drawn numbers) is retained in our private adversarial-testing archive and summarised in the integrity test review document. The testing harness itself is kept private so it can't be reused against the game.
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (S5-related steps, mapping added):
[PASS] Step 1 — Seed Hash Integrity → FI-SEED-003
[PASS] Step 3 — Hash Consistency Within Epoch → FI-SEED-002
[FLAG⚑] Step 4 — Nonce Audit → FI-NONCE-001, 002, 004
[PASS] Step 5 — Draw Recomputation (RNG + drand absent) → FI-OUTCOME-001
[PASS] Step 6 — Client Seed Influence → FI-SEED-002
[PASS] Step 19 — Simulation Results — Pass 1 Integrity → FI-ISO-001API Probe Tests (completed):
[PASS] FI-NONCE-003 — Invalid nonce handling → 7/7 invalid nonces ignored (HTTP 200)[PASS] FI-SEED-001 — Invalid client seed handling → 7/7 invalid seeds rejected[PASS] FI-SEED-004 — Cross-user seed pool check → 0/20 collisions across 2 accounts[PASS] FI-SEED-005 — Seed timing analysis → 10 distinct hashes, no time correlation[PASS] FI-PAYOUT-001 — Invalid parameter handling → 6/6 boundary violations rejected (HTTP 422)[PASS] FI-PAYOUT-002 — Field injection handling → 0 injections honouredPlayer Verification
Can a player verify their own bets without trusting anyone?
Every Keno bet can be checked from public inputs. Save the hashed server seed before you bet. After you rotate, compare the revealed seed's hash with your saved copy, then recompute the draw. This section walks through it, with the ProvablyFair.org verifier, whose code the package pins and runs on all 5,100 captured bets (Step 23).
Key principles
- Save the hashed server seed before you bet: your saved copy is what proves the timing
- Every bet can be reproduced from the server seed, client seed and nonce
- If your recomputed numbers match the draw as a set, the draw was the committed one
- Payouts use the table for your stake's tier; the captured base-tier table covers every captured bet
What you need
- Server Seed — revealed after seed rotation (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the bet number in sequence (ensures uniqueness)
- Your picks and risk level — to count hits and find the multiplier
- Save the hashed server seed before you bet: your saved copy is what proves the timing
- Every bet can be reproduced from the server seed, client seed and nonce
- If your recomputed numbers match the draw as a set, the draw was the committed one
- Payouts use the table for your stake's tier; the captured base-tier table covers every captured bet
- Server Seed — revealed after seed rotation (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the bet number in sequence (ensures uniqueness)
- Your picks and risk level — to count hits and find the multiplier
Player can access all required inputsPass
Client seed origin transparentPass
crypto.getRandomValues (E12); players can set their ownVerification steps documentedPass
SHA-256(hexDecode(serverSeed)), the draw, hit counting, the paying cellCasino UI exposes verification panelPass
Independent verifier availablePass
Manual recomputation possiblePass
No hidden or proprietary stepsPass
Only disclosed inputs are used, and identical inputs always give the same draw. Save the hashed seed before you bet, so the timing rests on your own record.
- 1
Save the Commitment
Before your first bet on a seed pair, open the Provably Fair panel and copy the hashed server seed. Keep it outside Duel.
- 2
Bet, Then Rotate
Place your bets. When you're done, rotate the seed pair to reveal the server seed.
- 3
Open a Past Bet
Open the bet from Transactions. Its Verify tab shows the client seed, the revealed server seed and the nonce.
- 4
Check and Recompute
Check that SHA-256 of the hex-decoded server seed equals the hash you saved, not one shown after the reveal. Then recompute the 10 numbers and compare them with the draw as a set.
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
Verify with ProvablyFair.org
Recompute any Keno draw from its revealed seeds, independently of the casino. The audit package pins this verifier and runs it on all 5,100 captured bets.
Open independent verifierBuilt-in verification
The operator’s own verification page. This tool is controlled by Duel.com.
Open Duel verifierVisual Walkthroughstep-by-step
Pick your numbers on the 40-number grid, choose a risk level, and place a bet. Duel draws 10 numbers with the provably fair backward Fisher–Yates shuffle. The draw is fixed by the seeds and nonce before the animation plays.

Illustrative: Duel.com Keno, with the 40-number grid and the pick and risk controls.
Open the Provably Fair panel on the game page. You'll see the active client seed, the hashed server seed (the casino's commitment) and your current nonce. Copy the hashed server seed now, before you bet, and keep it outside Duel: it is your proof of when the seed was fixed. You can also set the client seed for the next pair. Clicking "Rotate seed" retires the active pair and reveals its server seed for your past bets.

Illustrative: Provably Fair panel — active client seed, hashed server seed, nonce, new client seed, next pair commitment and the Rotate seed action.
Open Transactions and click a past Keno round. Its Verify tab shows the revealed server seed with the client seed and nonce. SHA-256 of the hex-decoded revealed seed must equal the hash you saved in Step 2:
Server Seed (revealed) — the plaintext value the casino committed to before your bet. Hash it and compare with the commitment you saved before betting.
Client Seed — your player-controlled entropy input.
Nonce — the sequential bet counter for this seed pair.

Per-bet Verify tab — client seed, revealed server seed and nonce for the round (account details masked).
Click Verify to open the Provably Fair page with the seeds filled in. It recomputes the 10 drawn numbers and highlights them on the grid. If they match your live result as a set, and the hash matches your saved copy, the draw was the one committed before you bet.

Provably Fair page — seeds filled in from the Verify tab, recomputed numbers highlighted on the grid.
Manual Verification (Advanced)7 sections
6.5Why Manual Verification Matters
True provably fair verification means you don't trust any casino-provided tool. Manual verification allows you to run calculations on your own machine, eliminate any possibility of a tampered verifier, and understand exactly how results are generated.
6.6How the Algorithm Works (Plain English)
Before you bet, the draw is fixed by three ingredients:
- The server's secret seed — committed by showing its hash before you bet
- Your client seed — generated in your browser by default, or set by you
- The nonce — a counter that makes each bet unique
These go into HMAC-SHA256 to drive a backward Fisher–Yates shuffle of the numbers 1 to 40. The first 10 positions of the shuffled list are the drawn numbers. Your picks and risk level only decide how many hits you have and which multiplier pays; they never touch the draw. Because the server committed to its seed before you sent your client seed, it can't change the draw afterwards.
6.7Casino Verifier vs ProvablyFair.org Verifier5 records
Two verification tools are available. Both should produce identical results — if they don't, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent (audit codebase) |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Checked by this audit | Duel's Verify-tab code, run unmodified as a cross-check on 5,100 bets: 0 differ | Same code Step 23 runs on 5,100 bets: 0 differ |
| Trust model | Requires trusting the casino | Open-source, version-controlled |
| Payout shown | Drawn numbers only | Drawn numbers only (no Keno multiplier) |
6.8JavaScript Verification Script
Run this in Node.js to verify any bet. It checks the commitment against the hash you saved, recomputes the draw as the specification describes, and counts your hits. It matches our RNG on all 5,100 captured bets. On the rare values where Duel's own code would reject instead (ranges 2, 4, 8, 16 and 32; about 62 in 2^32 per bet) it prints a note. The verifier on this site follows Duel's rule there.
const crypto = require('crypto'); // Keno draw, as written in the audit's specification (docs/ALGORITHM.md).function computeDraw(serverSeed, clientSeed, nonce) { const key = Buffer.from(serverSeed, 'hex'); // 32 bytes, not the hex text const a = Array.from({ length: 40 }, (_, n) => n + 1); let duelWindow = false; // see the note printed below for (let s = 0; s <= 38; s++) { // step s fixes index i = 39 - s const i = 39 - s, range = i + 1; const limit = Math.floor(2 ** 32 / range) * range; const hmac = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${s}`).digest(); let v; for (let off = 0; off < 32; off += 4) { // eight 4-byte big-endian chunks const x = hmac.readUInt32BE(off); if (x < limit) { v = x; break; } } if (v === undefined) throw new Error(`all 8 chunks rejected at step ${s}`); if ((range & (range - 1)) === 0 && v >= 2 ** 32 - range) duelWindow = true; // range is a power of two const j = v % range; [a[i], a[j]] = [a[j], a[i]]; } return { drawn: a.slice(0, 10), duelWindow };} function verifyHash(serverSeed, savedHash) { const hash = crypto.createHash('sha256').update(Buffer.from(serverSeed, 'hex')).digest('hex'); return hash === savedHash;} // Replace with your values. savedHash is the hashed server seed you saved BEFORE betting.const serverSeed = 'YOUR_REVEALED_SERVER_SEED';const savedHash = 'YOUR_SAVED_SERVER_SEED_HASH';const clientSeed = 'YOUR_CLIENT_SEED';const nonce = 0;const picks = []; // your selected numbers, e.g. [3, 16, 27, 35] console.log('Hash check:', verifyHash(serverSeed, savedHash) ? 'PASS' : 'FAIL');const { drawn, duelWindow } = computeDraw(serverSeed, clientSeed, nonce);const hits = picks.filter(n => drawn.includes(n));console.log('Drawn numbers:', [...drawn].sort((x, y) => x - y).join(', '), '(compare as a set)');console.log('Hits:', hits.length, hits.length ? `(${hits.join(', ')})` : '');if (duelWindow) console.log('Note: a value here falls in the window where Duel\'s own Verify code rejects it; its draw may differ.');6.9Python Verification Script
The same verification in Python (standard library only):
import hashlib, hmac # Keno draw, as written in the audit's specification (docs/ALGORITHM.md).def compute_draw(server_seed, client_seed, nonce): key = bytes.fromhex(server_seed) # 32 bytes, not the hex text a = list(range(1, 41)) duel_window = False # see the note printed below for s in range(39): # step s fixes index i = 39 - s i = 39 - s rng = i + 1 limit = (2**32 // rng) * rng h = hmac.new(key, f'{client_seed}:{nonce}:{s}'.encode(), hashlib.sha256).digest() v = next((x for x in (int.from_bytes(h[o:o + 4], 'big') for o in range(0, 32, 4)) if x < limit), None) if v is None: raise ValueError(f'all 8 chunks rejected at step {s}') if rng & (rng - 1) == 0 and v >= 2**32 - rng: duel_window = True j = v % rng a[i], a[j] = a[j], a[i] return a[:10], duel_window def verify_hash(server_seed, saved_hash): return hashlib.sha256(bytes.fromhex(server_seed)).hexdigest() == saved_hash # Replace with your values. saved_hash is the hashed server seed you saved BEFORE betting.server_seed = 'YOUR_REVEALED_SERVER_SEED'saved_hash = 'YOUR_SAVED_SERVER_SEED_HASH'client_seed = 'YOUR_CLIENT_SEED'nonce = 0picks = [] # your selected numbers, e.g. [3, 16, 27, 35] print('Hash check:', 'PASS' if verify_hash(server_seed, saved_hash) else 'FAIL')drawn, duel_window = compute_draw(server_seed, client_seed, nonce)hits = [n for n in picks if n in drawn]print('Drawn numbers:', ', '.join(map(str, sorted(drawn))), '(compare as a set)')print('Hits:', len(hits), f'({", ".join(map(str, hits))})' if hits else '')if duel_window: print("Note: a value here falls in the window where Duel's own Verify code rejects it; its draw may differ.")6.10Payouts and Stake Tiers
For a bet priced like the captured ones, take kenoConfig.json → data.multipliers[RISK][picks][hits], round it to 13 decimal places, and multiply by the stake. For a current bet, use the tier your stake falls in. In Duel's config (E14), data.scaling_edge[picks][RISK] lists the tiers; find the one whose min_bet and max_bet bracket your stake and read its multipliers, indexed by hits. The verifier on this site shows the captured base-tier multiplier.
6.11Evidence Screenshots5 records
| Evidence | Description |
|---|---|
| E02 | Fairness page overview: where the seed information is shown |
| E03 | Illustrative: Duel's verify page with Keno selected. Its Code panel is collapsed; the full source is E13 |
| E11 | Illustrative, recorded on Duel's Dice page: the rotation response echoes the client seed you submit and returns the active and next commitments |
| E12 | Duel's browser seed generator: 16 characters from a 63-character alphabet, rejection-sampled crypto.getRandomValues |
| E13 | Duel's Keno Verify-tab source, copied 25 September 2026 and run unmodified as a cross-check |
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
How it works
- 1
Save the Commitment
Before your first bet on a seed pair, open the Provably Fair panel and copy the hashed server seed. Keep it outside Duel.
- 2
Bet, Then Rotate
Place your bets. When you're done, rotate the seed pair to reveal the server seed.
- 3
Open a Past Bet
Open the bet from Transactions. Its Verify tab shows the client seed, the revealed server seed and the nonce.
- 4
Check and Recompute
Check that SHA-256 of the hex-decoded server seed equals the hash you saved, not one shown after the reveal. Then recompute the 10 numbers and compare them with the draw as a set.
Visual Walkthroughstep-by-step
Pick your numbers on the 40-number grid, choose a risk level, and place a bet. Duel draws 10 numbers with the provably fair backward Fisher–Yates shuffle. The draw is fixed by the seeds and nonce before the animation plays.

Illustrative: Duel.com Keno, with the 40-number grid and the pick and risk controls.
Open the Provably Fair panel on the game page. You'll see the active client seed, the hashed server seed (the casino's commitment) and your current nonce. Copy the hashed server seed now, before you bet, and keep it outside Duel: it is your proof of when the seed was fixed. You can also set the client seed for the next pair. Clicking "Rotate seed" retires the active pair and reveals its server seed for your past bets.

Illustrative: Provably Fair panel — active client seed, hashed server seed, nonce, new client seed, next pair commitment and the Rotate seed action.
Open Transactions and click a past Keno round. Its Verify tab shows the revealed server seed with the client seed and nonce. SHA-256 of the hex-decoded revealed seed must equal the hash you saved in Step 2:
Server Seed (revealed) — the plaintext value the casino committed to before your bet. Hash it and compare with the commitment you saved before betting.
Client Seed — your player-controlled entropy input.
Nonce — the sequential bet counter for this seed pair.

Per-bet Verify tab — client seed, revealed server seed and nonce for the round (account details masked).
Click Verify to open the Provably Fair page with the seeds filled in. It recomputes the 10 drawn numbers and highlights them on the grid. If they match your live result as a set, and the hash matches your saved copy, the draw was the one committed before you bet.

Provably Fair page — seeds filled in from the Verify tab, recomputed numbers highlighted on the grid.
Technical evidence
6.5Why Manual Verification Matters
True provably fair verification means you don't trust any casino-provided tool. Manual verification allows you to run calculations on your own machine, eliminate any possibility of a tampered verifier, and understand exactly how results are generated.
6.6How the Algorithm Works (Plain English)
Before you bet, the draw is fixed by three ingredients:
- The server's secret seed — committed by showing its hash before you bet
- Your client seed — generated in your browser by default, or set by you
- The nonce — a counter that makes each bet unique
These go into HMAC-SHA256 to drive a backward Fisher–Yates shuffle of the numbers 1 to 40. The first 10 positions of the shuffled list are the drawn numbers. Your picks and risk level only decide how many hits you have and which multiplier pays; they never touch the draw. Because the server committed to its seed before you sent your client seed, it can't change the draw afterwards.
6.7Casino Verifier vs ProvablyFair.org Verifier5 records
Two verification tools are available. Both should produce identical results — if they don't, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent (audit codebase) |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Checked by this audit | Duel's Verify-tab code, run unmodified as a cross-check on 5,100 bets: 0 differ | Same code Step 23 runs on 5,100 bets: 0 differ |
| Trust model | Requires trusting the casino | Open-source, version-controlled |
| Payout shown | Drawn numbers only | Drawn numbers only (no Keno multiplier) |
6.8JavaScript Verification Script
Run this in Node.js to verify any bet. It checks the commitment against the hash you saved, recomputes the draw as the specification describes, and counts your hits. It matches our RNG on all 5,100 captured bets. On the rare values where Duel's own code would reject instead (ranges 2, 4, 8, 16 and 32; about 62 in 2^32 per bet) it prints a note. The verifier on this site follows Duel's rule there.
const crypto = require('crypto'); // Keno draw, as written in the audit's specification (docs/ALGORITHM.md).function computeDraw(serverSeed, clientSeed, nonce) { const key = Buffer.from(serverSeed, 'hex'); // 32 bytes, not the hex text const a = Array.from({ length: 40 }, (_, n) => n + 1); let duelWindow = false; // see the note printed below for (let s = 0; s <= 38; s++) { // step s fixes index i = 39 - s const i = 39 - s, range = i + 1; const limit = Math.floor(2 ** 32 / range) * range; const hmac = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${s}`).digest(); let v; for (let off = 0; off < 32; off += 4) { // eight 4-byte big-endian chunks const x = hmac.readUInt32BE(off); if (x < limit) { v = x; break; } } if (v === undefined) throw new Error(`all 8 chunks rejected at step ${s}`); if ((range & (range - 1)) === 0 && v >= 2 ** 32 - range) duelWindow = true; // range is a power of two const j = v % range; [a[i], a[j]] = [a[j], a[i]]; } return { drawn: a.slice(0, 10), duelWindow };} function verifyHash(serverSeed, savedHash) { const hash = crypto.createHash('sha256').update(Buffer.from(serverSeed, 'hex')).digest('hex'); return hash === savedHash;} // Replace with your values. savedHash is the hashed server seed you saved BEFORE betting.const serverSeed = 'YOUR_REVEALED_SERVER_SEED';const savedHash = 'YOUR_SAVED_SERVER_SEED_HASH';const clientSeed = 'YOUR_CLIENT_SEED';const nonce = 0;const picks = []; // your selected numbers, e.g. [3, 16, 27, 35] console.log('Hash check:', verifyHash(serverSeed, savedHash) ? 'PASS' : 'FAIL');const { drawn, duelWindow } = computeDraw(serverSeed, clientSeed, nonce);const hits = picks.filter(n => drawn.includes(n));console.log('Drawn numbers:', [...drawn].sort((x, y) => x - y).join(', '), '(compare as a set)');console.log('Hits:', hits.length, hits.length ? `(${hits.join(', ')})` : '');if (duelWindow) console.log('Note: a value here falls in the window where Duel\'s own Verify code rejects it; its draw may differ.');6.9Python Verification Script
The same verification in Python (standard library only):
import hashlib, hmac # Keno draw, as written in the audit's specification (docs/ALGORITHM.md).def compute_draw(server_seed, client_seed, nonce): key = bytes.fromhex(server_seed) # 32 bytes, not the hex text a = list(range(1, 41)) duel_window = False # see the note printed below for s in range(39): # step s fixes index i = 39 - s i = 39 - s rng = i + 1 limit = (2**32 // rng) * rng h = hmac.new(key, f'{client_seed}:{nonce}:{s}'.encode(), hashlib.sha256).digest() v = next((x for x in (int.from_bytes(h[o:o + 4], 'big') for o in range(0, 32, 4)) if x < limit), None) if v is None: raise ValueError(f'all 8 chunks rejected at step {s}') if rng & (rng - 1) == 0 and v >= 2**32 - rng: duel_window = True j = v % rng a[i], a[j] = a[j], a[i] return a[:10], duel_window def verify_hash(server_seed, saved_hash): return hashlib.sha256(bytes.fromhex(server_seed)).hexdigest() == saved_hash # Replace with your values. saved_hash is the hashed server seed you saved BEFORE betting.server_seed = 'YOUR_REVEALED_SERVER_SEED'saved_hash = 'YOUR_SAVED_SERVER_SEED_HASH'client_seed = 'YOUR_CLIENT_SEED'nonce = 0picks = [] # your selected numbers, e.g. [3, 16, 27, 35] print('Hash check:', 'PASS' if verify_hash(server_seed, saved_hash) else 'FAIL')drawn, duel_window = compute_draw(server_seed, client_seed, nonce)hits = [n for n in picks if n in drawn]print('Drawn numbers:', ', '.join(map(str, sorted(drawn))), '(compare as a set)')print('Hits:', len(hits), f'({", ".join(map(str, hits))})' if hits else '')if duel_window: print("Note: a value here falls in the window where Duel's own Verify code rejects it; its draw may differ.")6.10Payouts and Stake Tiers
For a bet priced like the captured ones, take kenoConfig.json → data.multipliers[RISK][picks][hits], round it to 13 decimal places, and multiply by the stake. For a current bet, use the tier your stake falls in. In Duel's config (E14), data.scaling_edge[picks][RISK] lists the tiers; find the one whose min_bet and max_bet bracket your stake and read its multipliers, indexed by hits. The verifier on this site shows the captured base-tier multiplier.
6.11Evidence Screenshots5 records
| Evidence | Description |
|---|---|
| E02 | Fairness page overview: where the seed information is shown |
| E03 | Illustrative: Duel's verify page with Keno selected. Its Code panel is collapsed; the full source is E13 |
| E11 | Illustrative, recorded on Duel's Dice page: the rotation response echoes the client seed you submit and returns the active and next commitments |
| E12 | Duel's browser seed generator: 16 characters from a 63-character alphabet, rejection-sampled crypto.getRandomValues |
| E13 | Duel's Keno Verify-tab source, copied 25 September 2026 and run unmodified as a cross-check |
Only disclosed inputs are used, and identical inputs always give the same draw. Save the hashed seed before you bet, so the timing rests on your own record.
Reproducibility & Artifacts
Can anyone independently reproduce every finding in this audit?
This section covers the repository, the release tag, the commands and the reproduction gate. Every finding, statistic and pass/fail result can be reproduced by anyone with a computer. The repository is the credential, not this report.
Repository Details
- GitHub: ProvablyFair-org/duel-keno
- Release: v1.2.1 · Framework 1.1
- Original audit: 4fc06ec · June 2026
- Public Verifier: provablyfair.org/verify-bets/duel
Prerequisites
- Node.js 22.x (
.nvmrc) - npm
- Git
- GitHub: ProvablyFair-org/duel-keno
- Release: v1.2.1 · Framework 1.1
- Original audit: 4fc06ec · June 2026
- Public Verifier: provablyfair.org/verify-bets/duel
- Node.js 22.x (
.nvmrc) - npm
- Git
npm test at release v1.2.1 reproduces the committed results: 22 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, exit 0. Runs write to outputs/run/ and never overwrite the evidence of record.
Commands to Reproduce
npm test runs the 30 unit tests, then the 23 scored steps against the captured bets, then the reproduction gate. It scores the committed simulation and replays its sample windows; it doesn't rerun the full simulation. npm run test:full does.
The scored steps on their own. Results go to outputs/run/, never over the committed evidence.
Pass 1: 1,000,000 rounds for each of the 40 configurations on their pinned seed pairs. Pass 2: each of the 102 revealed casino seeds for 10,000 nonces on the configurations its epoch served. Writes to outputs/run/; recorded full regenerations took about 44–47 minutes.
Informational, not scored: recomputes the 2,672 tiers of Duel's 5 October 2026 config (E14) into outputs/run/ and compares them with the committed outputs/live-config-scaling.json.
Audit Reproducibility Pinning
- Release
v1.2.1(Framework 1.1)- Original audit
4fc06ec9b0a29f7e664732fef7295607a58b57c5(4 June 2026)- Node Version
- 22.x (
.nvmrc,package.jsonengines) - Dataset
- data/keno-master-5100bets.json (5,100 bets, 106 seed records)
- Dataset Hash (SHA-256)
- 841755fdfb268d7796017212f08a18bfea7615c30a4590dd29793b34c5e6bcf9
- Paytable Hash (SHA-256)
- efd3c645c4b3956199fde62dd65446c08e4605763d2d0f34c97a226bdbae4f91
- Capture
- 11 April 2026
- Audit ID
- PF-2026-DL03
Output Artifacts8 files of record
| File | Contents | Size |
|---|---|---|
| verification-results.json | All 23 step results, profile coverage, verdict | ~70KB |
| determinism-log.json | 5,100 verified, 0 mismatches, 0 skipped | 57B |
| chi-squared-results.json | Live hit counts against the hypergeometric model, by configuration | ~19KB |
| payout-coverage.json | The 190 cells reached live and the 70 not, with their RTP share | ~15KB |
| rtp-claim-table.json | RTP claim: 2,712 exact RTPs, each with its stated tier and outcome (PASS) | ~724KB |
| live-config-scaling.json | The 5 October 2026 tiers, thresholds and RTPs (informational) | ~735KB |
| simulation-results.json | Pass 1 (40M rounds) + Pass 2 (102 seeds × 10,000 nonces) | ~1.6MB |
| rtp-convergence.html | Self-contained RTP convergence chart | ~211KB |
Repository Structure
duel-keno/ (release v1.2.1) ├── src/ │ ├── rng.ts → HMAC-SHA256 backward Fisher–Yates draw, written from docs/ALGORITHM.md │ ├── exact.ts → Integer binomials and exact rational RTP │ ├── money.ts → Exact settlement on integer units │ ├── config.ts → Paytable lookup and hit probabilities │ ├── simulate.ts → Monte Carlo: 40M Pass 1 rounds + Pass 2 on casino seeds │ ├── sim-seeds.ts → The 40 pinned Pass 1 seed pairs │ ├── stats.ts → Chi-squared, lag-1, runs test │ ├── loader.ts → Dataset loader, capture plan, seed timeline │ ├── rtp-claim.ts → Framework rule RTP-CLAIM 1.2.0 │ ├── rtp-settings.ts → The tiered claim and the RTP claim table │ ├── live-config.ts → The 5 October 2026 stake tiers, recomputed (informational) │ ├── operator-verifier.ts → Runs Duel's Verify-tab code unmodified (cross-check) │ ├── site-verifier.ts, live-site-verifier.ts → Load the pinned ProvablyFair.org verifiers │ ├── artifact-pins.ts → SHA-256 pins for the artifacts of record │ ├── profile-map.ts → Step → Keno profile check (KENO-01 … KENO-32) │ └── domains.ts, diff.ts, types.ts, rtp-claim-switch.ts ├── tests/ │ ├── verify.ts → 23 scored steps + the reproduction gate │ ├── steps/ → commitment, determinism, payouts, dataset, simulation, │ │ bias, parity, artifacts, statistical, context │ ├── keno/ → Mocha unit tests (30, incl. the spec self-test) │ └── mutations.json → Mutation battery registry ├── docs/ALGORITHM.md, INTERFACE.md → The written specification and module interface ├── data/keno-master-5100bets.json → 5,100 live bets (4 phases, 106 seed records) ├── kenoConfig.json → The captured paytable (40 configurations) ├── evidence/ → Screenshots, Duel's Verify-tab code (E13), stake-tier config (E14), page read (E15) ├── verifier-parity/ → Pinned copies of both ProvablyFair.org verifiers and the operator runner ├── capture/ → Reference record of the capture script ├── outputs/ → Committed evidence of record (runs write to outputs/run/) ├── scripts/ → mutate.mjs, release-manifest.mjs, check-site-verifier.mjs ├── RELEASE-MANIFEST.json → Release identity, artifact hashes, verdict, signature ├── MANIFEST.md → Consolidated audit overview ├── README.md └── package.json, package-lock.json, .nvmrc (Node 22.x), LICENSE (MIT)
Step-to-Section Cross-Reference23 verification steps mapped
| Step | Test Name | Report Section |
|---|---|---|
| 1 | Seed Hash Integrity | S1, S5 |
| 2 | Next-Seed Promotion (Commitment Linkage) | S1 |
| 3 | Hash Consistency Within Epoch | S1, S5 |
| 4 | Nonce Audit (capture flag) | S1, S5 |
| 5 | Draw Recomputation (RNG + drand absent) | S1, S2, S3, S5 |
| 6 | Client Seed Influence | S1, S2, S5 |
| 7 | Payout Math | S3, S4 |
| 8 | Multiplier Table Provenance | S3, S4 |
| 9 | Phase C Bet-Size Invariance (Phase D at $10) | S3, S4 |
| 10 | Configuration Completeness & Payout-Cell Coverage | S3 |
| 11 | Captured Edge Fields (pinned scaling_edge empty) | S3, S4 |
| 12 | Consolation Payout Disclosure (LOW/MEDIUM picks=1 zero-hit) | S3, S4 |
| 13 | Population & Phase Labels | S3 |
| 14 | Dataset Hash | S7 |
| 15 | Epoch Size | S1 |
| 16 | Hit Symmetry (hypergeometric mode verification) | S4 |
| 17 | Probability Independence (Anti-Circularity) | S4 |
| 18 | Phase D — Client Seed Variation | S1 |
| 19 | Simulation Results — Pass 1 Integrity | S2, S4, S5 |
| 20 | Simulation Results — Pass 2 Cherry-Pick Test | S4, S5 |
| 21 | Artifact Integrity (pinned artifacts of record) | S7 |
| 22 | Draw Bias Bound (rejection ceiling, every range enumerated) | S2 |
| 23 | Player-Verifier Parity (docs-site + live-site) | S2, S3, S6 |
reproduce-audit.sh
npm test at release v1.2.1 reproduces the committed results: 22 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, exit 0. Runs write to outputs/run/ and never overwrite the evidence of record.
Reproduction Gate & Release5 sections
7.1Exit Codes
The exit code is the verdict:
| Code | Meaning |
|---|---|
0 | PROVABLY FAIR — Full Pass, and this run reproduces the committed artifacts. A capture flag is printed and recorded but exits 0 |
1 | At least one hard fail, a reproduction difference beyond tolerance, or an RTP claim table that differs |
2 | At least one operator-origin FLAG — PROVABLY FAIR — Conditional Pass |
5 | RTP FIGURE OVERSTATED: no draw check failed, but the RTP claim rule found rows beyond the ±0.1 pp band on the house side |
7.2The Reproduction Gate
npm run verify writes this run's results to outputs/run/ (gitignored) and compares them field by field with the committed results in outputs/, at 1e-14 absolute + 1e-12 relative. Two distinct integers never agree. A re-run can't replace the evidence it scores; refreshing the evidence takes PF_EMIT=1 and a re-pin in the same commit.
Committed artifacts NOT modified.Reproduction vs the committed artifacts on Node 22.22.0: REPRODUCED7.3SHA-256 Pinned Artifacts
The verifier checks the dataset and paytable hashes before any step runs. Step 21 checks the five committed artifacts against their SHA-256 pins, and the RTP claim table has its own pin; a missing or altered one fails. verification-results.json carries Step 21's own verdict, so it is compared field by field instead. The release manifest hashes all thirteen files below.
| File | SHA-256 |
|---|---|
| data/keno-master-5100bets.json | 841755fdfb268d7796017212f08a18bfea7615c30a4590dd29793b34c5e6bcf9 |
| kenoConfig.json | efd3c645c4b3956199fde62dd65446c08e4605763d2d0f34c97a226bdbae4f91 |
| outputs/chi-squared-results.json | 2af4ae85b381b8eebca9e7ab664b49f412a50f75e8646c2c205538d66a3e6e13 |
| outputs/determinism-log.json | 081193bc8e2965dd7f4bf1b82b2bd232ba2cedb5783f9cd1b96111218500604b |
| outputs/payout-coverage.json | e627bc8bc49ff0f8efb0a64a4516c9638c2af1de8f2e7842cd96ffcf0e5e8570 |
| outputs/rtp-convergence.html | ceb2f732a43da4439fa36af88c33f79acf177e50cb9309d06ceafaf98616e77f |
| outputs/simulation-results.json | c8543cce21bef6707099b0f29676abe2712fdb3ce0c85f46e3c9a014f12f0de7 |
| outputs/verification-results.json | 4a99d37c94dca70b6a60d64d2790ca9e3fa32d5c11c0fb3201a027284f38611f |
| outputs/rtp-claim-table.json | 01af5577a3032d467cd262fe4897705a6aa849f025b44f08283d35a1decceddb |
| evidence/keno-config-live-2026-10-05.json | 787f9bad764a1cf5a8db9b7d166582b072c197a7ffd8eda6019d6c3817478d84 |
| evidence/keno-config-live-2026-10-05.meta.json | 71a685bb12afab19a2acfb2177b4012be37840174a5e03c6ff2fcca4dbbf64da |
| outputs/live-config-scaling.json | bd9107846ff27cc402580b7292497e861541f8598892dd231b8f5ba940af7953 |
| evidence/keno-edge-claim-read-2026-10-05.md | ac45a8142bb18a4f7a9ccad86e46585e840d87dc93be451bba9e7a1a8206780e |
node scripts/release-manifest.mjs --check checks that all thirteen hashes match the files on disk.
7.4Mutation Battery & Runtime
Mutation battery: 53 / 53 mutations killed and all 23 scored steps have a killing mutation, no declared survivors (npm run mutate, 20 October 2026).
Runtime: npm test took 18.9 s on an Apple M2 Max (release manifest, 28 September 2026); a full simulation regeneration took about 44–47 minutes. Runtime varies by machine.
7.5Release History
| Release | What changed | Verdict |
|---|---|---|
v1.0.0 | The original audit | PROVABLY FAIR — Full Pass |
v1.1.0 | Draw-bias and player-verifier checks and a mutation battery added; re-certified under Framework 1.1 with the RTP claim rule switched on; Step 4 reported as a capture flag; dataset unchanged | Unchanged |
v1.2.0 | RNG code rebuilt from a written specification; Duel's Verify-tab code kept as a cross-check only | Unchanged |
v1.2.1 | Adds .gitattributes so a Windows clone stays byte-identical; no audit content changed | Unchanged |
Game Profile Coverage
Is every check in the Keno profile covered?
The Keno profile (version 1.0.2) lists 32 checks, KENO-01 to KENO-32. Each one is covered by a scored step, a package check, or marked n/a with a reason. Five are partial, where the package says so.
| Check | Covered by | Coverage | What it covers |
|---|---|---|---|
| KENO-01 | Steps 1, 5 | Full | Revealed seeds hash to their commitments; every bet-bearing epoch's seed revealed |
| KENO-02 | Step 2 | Full | Forward links recomputed from the raw hashes, plus the pre-capture anchor |
| KENO-03 | Step 3 | Full | Epochs keyed by the rotation timeline; one hash and one client seed per epoch; no commitment reused |
| KENO-04 | Step 4 | Full | Repeats, reorders and gaps fail unless they match a capture retry (2, capture flag) |
| KENO-05 | Steps 1, 5, 13, 15 | Full | Bets, seed records, phases and epoch sizes bound to the capture plan |
| KENO-06 | Steps 6, 9, 18 | Partial | Client seed influence and Phase D seeds. Partial: the capture's A–C seeds came from Math.random(), not a CSPRNG |
| KENO-07 | Step 5 | Full | Every bet recomputed to its served draw, compared as a set |
| KENO-08 | Step 22 | Full | Draw-bias bound exact (0) for every range 2–40; rejection census |
| KENO-09 | Package check | Full | RNG rebuilt from the written specification; Duel's Verify-tab code run unmodified as a cross-check |
| KENO-10 | Steps 5, 7, 8 | Full | Draw structure, legal pick sets, hits counted on the recomputed draw |
| KENO-11 | Step 7 | Full | Payouts exact on integer units, no tolerance |
| KENO-12 | Step 9 | Partial | Phase D stake invariance. Partial: 43 paying bets at $10, below the profile's 100 |
| KENO-13 | Step 8 | Full | Served multiplier equals the pinned paytable at 13 decimal places on every bet |
| KENO-14 | Step 12 | Full | Every out-of-pattern cell enumerated: only the two consolation cells; no cap declared |
| KENO-15 | Step 10 | Partial | All 40 configurations played; 190 of 260 cells reached. Partial: Phase A alone covers 32 |
| KENO-16 | — | n/a | No bet response carries a running balance |
| KENO-17 | Step 5 | Full | Picks, risk and stake are not draw inputs; recomputed across differing pick sets |
| KENO-18 | Steps 16, 17 | Full | Hypergeometric law exact in integers; mode check; negative controls |
| KENO-19 | Step 17 | Partial | Exact RTP per configuration and the RTP claim. Partial: 24 configurations differ from 999/1000 by at most 1.125×10⁻¹⁶, disclosed rather than flagged |
| KENO-20 | Step 19 | Full | 40M-round simulation, every statistic re-derived from the shipped rows |
| KENO-21 | Step 20 | Full | Pass 2 cherry-pick test on all 102 revealed seeds, with the served-return screen |
| KENO-22 | Package check | Full | Live hit counts and drawn-number uniformity (informational) |
| KENO-23 | Package check | Full | The package’s own S5 matrix in MANIFEST.md |
| KENO-24 | Step 23 | Full | Both ProvablyFair.org verifiers (pinned copies) run on every bet |
| KENO-25 | Package check | Full | Player verification steps in order, with the commitment encoding |
| KENO-26 | Step 14 | Full | Dataset and paytable pinned by SHA-256 |
| KENO-27 | Step 21 | Full | Pinned artifacts and value domains |
| KENO-28 | Package check | Full | Fresh-clone reproduction record |
| KENO-29 | Package check | Full | Mutation battery: every scored step has a killing mutation |
| KENO-30 | Package check | Full | Limitations register and load-bearing premises |
| KENO-31 | — | n/a | No stake scaling in the captured config (Step 11 checks the field); scaled tiers not certified |
| KENO-32 | Package check | Partial | Autopick. Partial: Duel offers it and the capture never used it |