Skip to main content
Audits
Duel.com/Keno
Duel: Keno Audit

Keno

Certified · Active

Independent verification, backed by open-source code.

PF-2026-DL03Audited April 2026 · Updated October 2026Apr 2026 · Updated Oct 2026Framework 1.1Release v1.2.1Original audit 4fc06ec, June 2026, Jun 2026
AUDIT RESULTPassedPROVABLY FAIR — Full Pass22 / 23 steps passed
PROVABLY FAIR — Full Pass
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
22 / 23Verification steps passed

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.

DUEL KENO$0.01 · High risk · 10 picks
HitPickedDrawn
Bet #34337513Nonce 0 · Phase C
50 real bets · Phase CBet 1 of 50
✓ Exact match
0.0000×

The casino result, reproduced.

Casino outcome
0 / 10 hits
Our reproduction
0 / 10 hits
Recorded payout
$0.0000
Open source

Run this audit yourself

Open GitHub ↗

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.

npm test
Needs git and Node.js 22View reproduction commands ↓
Keno Audit Overview

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.

Results at a glance

Audit Verdict

CheckResultEvidence
Overall StatusPassPROVABLY 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 RTPPass99.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 ParityPass5,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 SystemPass102 / 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 AuditCapture flag100 / 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 SeedPassA 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 AnalysisPassOur 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 LogicPass2,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 EdgeInfoEvery 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-CircularityPassP(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 IntegrityPass15 standard fairness integrity tests — 14 pass, 1 N/A (single-step game)
DeterminismPassEvery draw recomputes from (serverSeed, clientSeed, nonce); no pick, risk or stake input (Step 5)
ReproducibilityPassnpm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results
Overall StatusPass
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 RTPPass
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 ParityPass
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 SystemPass
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 AuditCapture 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 SeedPass
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 AnalysisPass
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 LogicPass
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 EdgeInfo
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-CircularityPass
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 IntegrityPass
15 standard fairness integrity tests — 14 pass, 1 N/A (single-step game)
DeterminismPass
Every draw recomputes from (serverSeed, clientSeed, nonce); no pick, risk or stake input (Step 5)
ReproducibilityPass
npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results
Audit scope & reference

What 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
2 columns
AreaDescription
Commit-Reveal SystemSHA-256 server seed hashing, the forward commitment chain, reveal on rotation
Client Seed OriginBrowser-generated default, player-customisable; the capture's own seeds disclosed
Seed HandlingClient seed control, nonce lifecycle, seed pair rotation
RNG AnalysisHMAC-SHA256 backward Fisher–Yates over 40 numbers, written from the specification; rejection sampling, bias bound
Payout LogicExact settlement, 13-decimal multipliers, paytable provenance, consolation cells, stake invariance (Phase D)
Live ParityOur recomputation, Duel's Verify-tab code (cross-check) and both ProvablyFair.org verifiers against every live bet
RTP ValidationAnti-circularity (hypergeometric), exact rational RTP, RTP claim rule, 40M-round simulation, cherry-pick test (Pass 2)
Fairness IntegrityStandard integrity matrix — 15 tests across commit-reveal, determinism, payout, isolation, and parameter enforcement
Game Profile CoverageAll 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.

Draw outcomes are determined cryptographically before the animation plays. The visual draw is cosmetic — the result is fixed at the moment the bet is placed.
Win Conditions

The win condition in Keno depends on how many of your picks match the 10 drawn numbers.

3 columns
OutcomeConditionExample (HIGH picks=10)
Jackpot (all hits)All picks match drawn numbers10/10 hits → 1200× — ~1 in 847 million chance
Win (partial hits)Several picks match drawn6/10 hits → 13.1×
LossToo few picks match0–3/10 hits → 0×
Most configurations pay 0× on zero hits. Two exceptions: LOW picks=1 pays 0.71× and MEDIUM picks=1 pays 0.41× on zero hits — a consolation payout design within the 99.9% RTP constraint.
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
3 columns
ParameterValueNotes
Grid Size40 (numbers 1–40)Fixed; all draws from this pool
Numbers Drawn10 per roundFixed; drawn via backward Fisher-Yates
Player Picks1–10Player selects; determines hit probability
Risk LevelsClassic, Low, Medium, HighAffects multiplier table, not drawn numbers
House Edge0.1% at the base tierIn 35 of 40 configurations, rises in 0.01% steps above a threshold, to 1.0% at most
Theoretical RTP99.9% (base tier)Derived for all 40 configurations from hypergeometric probabilities
Configurations4010 pick counts × 4 risk levels
RNG AlgorithmHMAC-SHA256Backward Fisher–Yates with rejection sampling; key = hex-decoded server seed
Seed Formats

Every Keno bet uses three cryptographic inputs to generate the draw result.

4 columns
Seed TypeFormatExamplePurpose
Server Seed64-char hex (32 bytes)94eee14e882d4332…Casino-provided randomness
Client SeedAlphanumeric stringdAn1wtkuDAXxQOKPPlayer-contributed entropy
NonceInteger from 07One per bet within an epoch
The server seed is hex-decoded to 32 raw bytes before use as the HMAC key. Passing the hex string as UTF-8 gives completely different results. All 5,100 captured bets recompute with the decoded key.
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]
5 columns
PicksRiskMax Multiplier (all hits)Zero-Hit MultiplierRTP
1Classic3.996×0×99.9%
1Low1.866×0.71×99.9%
10Classic200×0×99.9%
10High1200×0×99.9%
All 40 configurations return 99.9% at the base tier. The stake never affects the draw, but in 35 of the 40 configurations, above a threshold, Duel's config scales the multipliers down by the tier's edge, up to 1.0% (4.5). Every captured bet was priced at the base tier.
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

2 columns
TestDescription
Server seed commit exists before playSHA-256 hash shown to player before betting
Server seed reveal matches commitSHA-256(hexDecode(revealed)) = committed hash
Client seed controlPlayer can set/change client seed via rotation UI
Nonce increments correctlyStarts at 0, +1 per bet, resets at epoch boundary
Full determinismSame inputs → same result

2. Randomness & Entropy Model

2 columns
TestDescription
RNG depends only on seeds + nonceNo external inputs (drand absent from Keno)
No mixed entropy sourcesNo timestamps, Math.random, etc.
Unbiased mappingRejection sampling: the accepted values are a whole multiple of every range 2–40, so bias is exactly 0
No state leakageRNG isolated per round — each shuffle step uses its own cursor in the HMAC message

3. Verifier ↔︎ Live Parity

2 columns
TestDescription
Live outcomes match verifier5,100 / 5,100 draws recomputed with 0 SET mismatches
Multi-phase verificationPhases A (32 configs), B (picks=1), C (picks=10), D (stake equivalence)
Bet-size invarianceThe stake is not an input to the draw; $10 bets follow the same rules as $0.01

4. Game Logic & RTP Validation

2 columns
TestDescription
Anti-circularity proofHypergeometric P(hits) × committed multiplier = 99.9% — independent probabilities, committed table
House edge audit0.1% at the base tier: effective_edge 0.1 on every captured bet; higher tiers explained from the config (4.5)
Payout rules correctnessWin amount equals stake × the 13-decimal multiplier exactly (integer units, no tolerance)
Simulated RTP convergence40M rounds average 99.970%, consistent with 99.9%
Cherry-pick detectionTest 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

2 columns
TestDescription
Player can reproduce results offlineUsing seeds + nonce + backward Fisher-Yates
Verifier logic matches live logicOur RNG (written from the spec), Duel's Verify-tab code and both ProvablyFair.org verifiers agree on all 5,100 bets
Verifier publicly accessibleProvablyFair.org verifier — no login required
No reliance on private APIsFully client-side verification
23 scored stepsCommit-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

High-Level Flow — illustrated flow
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-Reveal Model — illustrated flow

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
nonce-lifecycle
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:

determinism
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
2 columns
TermDefinition
Framework 1.1The 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 flagA 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 ruleRTP-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 tierThe 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
2 columns
TermDefinition
Provably FairA cryptographic system that allows players to mathematically verify that game outcomes were not altered. Relies on commit-reveal schemes and deterministic algorithms.
Commit-Reveal ProtocolA 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.
DeterminismThe 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 OriginThe 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
2 columns
TermDefinition
Server SeedA 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 SeedA random value controlled by the player, generated by the browser. Players can change it at any time via the seed rotation UI.
NonceA 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 SeedSHA-256(hexDecode(serverSeed)) — the commitment hash shown before betting. After rotation, players verify the revealed seed produces this hash.
CursorIndex 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.
EpochA 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
2 columns
TermDefinition
HMAC-SHA256Hash-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-256Secure Hash Algorithm 256-bit. Used for server seed commitment: SHA-256(hexDecode(serverSeed)) = serverSeedHashed.
Hex DecodingConverting 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 ShuffleA 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
2 columns
TermDefinition
VerifierA 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.
ParityDegree of matching between verifier and live game results. 100% parity = every draw SET matches. This audit: 5,100/5,100 exact match.
Anti-CircularityProof 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 SamplingRemoves 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
2 columns
TermDefinition
Drawn NumbersThe 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 CountPlayer-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 LevelPlayer-selected parameter (Classic, Low, Medium, High) that determines the multiplier table. Higher risk = more value at rare full-hit outcomes.
Hypergeometric DistributionThe 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 PayoutTwo 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.
01

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.

Commit-Reveal Consistency

102 / 102revealed seeds match

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
102 / 102revealed seeds match
  • 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
HMAC-SHA256 Pipeline — Seed inputs through backward Fisher-Yates to drawn numbers — illustrated flow
CheckResultEvidence
Seed hash integrityPass102 / 102 revealed seeds hash to their commitments; the 4 seeds never revealed carry no bets (Step 1)
Commitment linkagePassAll 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 epochPassEvery bet carries its epoch's committed hash and client seed: 102 bet-bearing epochs, 0 orphan bets, 106 distinct commitments (Step 3)
Nonce sequencingCapture flag100 / 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 outputPass5,100 / 5,100 drawn sets recomputed from (serverSeed, clientSeed, nonce) (Step 5)
Client seed participationPassA 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 originPassDuel'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
102 / 102 revealed seeds hash to their commitments; the 4 seeds never revealed carry no bets (Step 1)
Commitment linkagePass
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 epochPass
Every bet carries its epoch's committed hash and client seed: 102 bet-bearing epochs, 0 orphan bets, 106 distinct commitments (Step 3)
Nonce sequencingCapture 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 outputPass
5,100 / 5,100 drawn sets recomputed from (serverSeed, clientSeed, nonce) (Step 5)
Client seed participationPass
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 originPass
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
✓  Commit-reveal consistent

All 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.

Server Seed Commitment — illustrated flow
src/rng.ts · verifyHash · Verified
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();}
Result: 102 / 102 revealed seeds hash to their commitments. 0 mismatches.

Real Example from Live Data:

keno-master-5100bets.json · bet and reveal
// 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:

verify-seed.js · Verified
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.

tests/steps/commitment.ts · Step 2: Commitment Linkage · Verified
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}`);}
Result: 105 / 105 links match, plus the pre-capture anchor. The capture script's own 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.

tests/steps/commitment.ts · Step 3: Hash Consistency Within Epoch · Verified
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}`);  }}
Result: 102 bet-bearing epochs, 4 end-of-phase records, 0 orphan bets, 0 disagreements; all 106 commitments distinct.
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.

  • 05c2Ex3iqjnhrWPk
  • 0aPrHGFQSzkmvZqv
  • 2FyZzGbkRqrxBjW6
  • 34hzj6BD4gCPaNAM
  • 4fUHsJsnDQXEejT6
Result: 102 distinct client seeds across the capture (A 60, B 20, C 20, D 2). All 100 Phase D bets recompute under the two auditor seeds, so the server uses the seed the player sets.
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.

Nonce Incrementation — illustrated flow
tests/steps/commitment.ts · Step 4: Nonce Audit · Verified
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++;  }
Capture flag: 100 / 102 epochs complete, no repeats, 0 out of order. Draws at the missed nonces, reconstructed from the revealed seeds: [15, 8, 4, 6, 30, 17, 35, 40, 31, 25] and [15, 12, 35, 38, 23, 2, 27, 24, 5, 9]. Disclosed, verdict-neutral.
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.

Deterministic Mapping — illustrated flow
src/rng.ts · computeDraw · Verified
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);}
Result: 5,100 / 5,100 drawn sets recompute. Duel's own Verify-tab code, run unmodified as a cross-check, gives the same shuffle order on all 5,100. Outcomes derive only from (serverSeed, clientSeed, nonce); no drand or other external input.

Real Bet Verified:

keno-master-5100bets.json · Game #34309702 · 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]): 94eee14e882d43325f7948ef9569552f4506feeeb70a2ca35023916b4f9f0fe9

Verification:

verify-draw.js · Verified
// 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).

tests/steps/determinism.ts · Step 6: Client Seed Influence · Verified
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`);  }}
Result: 5,100 / 5,100 draws change under a wrong client seed, and 5,100 / 5,100 under an empty one, across all 102 epochs.
Technical Evidence & Verification5 sections
1.8Evidence Coverage Summary6 checks
3 columns
Verification AreaCoverageResult
Seed hash integrity (Step 1)102 / 102 revealed seeds; 3 phase-start records repeat the one before; 4 unrevealed, none with betsPass
Commitment linkage (Step 2)105 / 105 links + the pre-capture anchorPass
Hash consistency (Step 3)102 bet-bearing epochs, 0 orphan bets, 106 distinct commitmentsPass
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,100Pass
Client seed influence (Step 6)5,100 / 5,100 (wrong seed) and 5,100 / 5,100 (empty seed)Pass
1.9Code References7 source files
2 columns
FilePurpose
tests/verify.ts23 scored steps (Steps 1–6 cover S1) and the reproduction gate
tests/steps/commitment.tsSteps 1–4: commit-reveal and nonce checks
tests/steps/determinism.tsSteps 5–6: draw recomputation and client seed influence
src/rng.tsHMAC-SHA256 backward Fisher–Yates draw, written from docs/ALGORITHM.md
docs/ALGORITHM.mdThe written specification the draw code was built from
src/loader.tsDataset loading, the capture plan and the seed timeline
capture/capture-auto.reference.jsReference record of the capture script
1.10Datasets UsedSource artifacts
Primary: data/keno-master-5100bets.json
2 columns
PropertyValue
SourceLive Keno bets on Duel.com, 11 April 2026
Total Records5,100 bets across 102 epochs (106 seed records)
SHA-256841755fdfb268d7796017212f08a18bfea7615c30a4590dd29793b34c5e6bcf9

Fields used: serverSeed, serverSeedHashed, nextServerSeedHash, clientSeed, nonce, difficulty, selected_positions, drawn_numbers, multiplier, amount_won

1.11Verified Invariants8 invariants
2 columns
InvariantResult
SHA-256(hexDecode(serverSeed)) = serverSeedHashed for all 102 revealed seedsPass
Forward commitment chain consistent over all 105 links, plus the pre-capture anchorPass
serverSeedHashed and client seed constant within each of the 102 bet-bearing epochsPass
No repeated or out-of-order nonce in any epochPass
Nonce gaps only where our capture script retried a request (2)Capture flag
Same inputs produce the same drawn set for all 5,100 betsPass
A wrong or empty client seed changes the drawn set on 5,100 / 5,100 betsPass
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:

reproduce-s1.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verify
Expected 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 Influence
02

RNG & 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.

Cryptographic Randomness Verification

5,100 / 5,100draws reproduced

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
5,100 / 5,100draws reproduced
  • 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
RNG Pipeline — HMAC-SHA256 → uint32 → rejection sampling → Fisher-Yates swap → drawn SET — illustrated flow
CheckResultEvidence
RNG derived only from disclosed inputsPassHMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:cursor); the draw takes (key, clientSeed, nonce) only (Step 5)
Written from the specificationPasssrc/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-checkPassDuel's Verify-tab code, run unmodified: same shuffle order on 5,100 / 5,100 (Step 23)
Modulo biasPassAll 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 encodingPassServer seed hex-decoded to 32 bytes; only the decoded key reproduces the known draws (unit test)
Serial independencePass40M simulated rounds: 0 / 40 configurations fail the lag-1 and runs checks at α/40 (Step 19)
Client seed influencePassA 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
Duel's Verify-tab code, run unmodified: same shuffle order on 5,100 / 5,100 (Step 23)
Modulo biasPass
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 encodingPass
Server seed hex-decoded to 32 bytes; only the decoded key reproduces the known draws (unit test)
Serial independencePass
40M simulated rounds: 0 / 40 configurations fail the lag-1 and runs checks at α/40 (Step 19)
Client seed influencePass
A wrong and an empty client seed each change all 5,100 draws (Step 6)
✓  Unbiased, from disclosed inputs only

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.

2 columns
ComponentDetail
Hash functionHMAC-SHA256
KeyhexDecode(serverSeed): 32 bytes
MessageclientSeed:nonce:s, s = 0 to 38
ExtractionEight 4-byte big-endian values per HMAC
Rejectionvalue < floor(2^32 / range) × range
Reductionvalue % range → swap index j ∈ [0, range)
ShuffleBackward Fisher–Yates: step s fixes index i = 39 − s
Outputa[0..9]: the 10 drawn numbers, compared as a set
src/rng.ts · computeDrawFromBuffer (shuffle) · Verified
// §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);
Result: Our implementation reproduces all 5,100 live drawn sets. It was written from 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:

Entropy Sources — illustrated flow
3 columns
SourceControlled ByPurpose
Server SeedCasinoBase randomness (committed via SHA-256 hash before betting)
Client SeedPlayerPlayer-contributed input
NonceSystemOne per bet; rises by 1 within each epoch
CursorSystemOne per shuffle step, 0 to 38
No mixed entropy sources found. The same inputs always give the same draw: 5,100 / 5,100.

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)
Result: Step 22 enumerates all 39 ranges over every 32-bit value: bias exactly 0. 0 of 198,900 captured shuffle steps rejected a value.

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.

RNG Isolation — illustrated flow
Result: No state carries over between shuffle steps, bets or epochs. Each HMAC call is keyed and messaged on its own.

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.

2 columns
MetricValue
Average simulated RTP99.970%
Average theoretical RTP99.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
src/simulate.ts · Pass 1 seed pairs · Verified
// 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,);
Result: 40M rounds. No configuration fails any check, and the hit distribution is consistent with the hypergeometric model.

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.

src/stats.ts · lag1Autocorrelation · Verified
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;}
Result: 0 / 40 configurations fail serial independence, and none flags even at α = 0.01.
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]
7 columns
icursorrangeHMAC[:8]uint32jswap
39040b8feba713,103,701,61717pos[39]↔︎pos[17]
381395a417f901,514,241,93612pos[38]↔︎pos[12]
37238e435da0a3,828,734,47414pos[37]↔︎pos[14]
3633734334094875,774,10010pos[36]↔︎pos[10]
354367ea8251d2,124,948,76521pos[35]↔︎pos[21]
Parity: Bet 34309702: the drawn set matches the backward Fisher–Yates recomputation. Hits: 3 (1, 5, 36). Multiplier (MEDIUM/picks=8, 3 hits): 2.01×. Payout: 0.01 × 2.01 = 0.0201.
Live GameSET = {1,5,8,16,20,26,29,35,36,37}
VerifierSET = {1,5,8,16,20,26,29,35,36,37}
Technical Evidence & Verification5 sections
2.8Evidence Coverage Summary6 checks
3 columns
Verification AreaCoverageResult
Draw recomputation (Step 5)5,100 / 5,100 betsPass
Duel's Verify-tab code, cross-check (Step 23)5,100 / 5,100, same shuffle orderPass
Key encoding (hex vs UTF-8)Unit test: only the decoded key reproduces the known drawsPass
Modulo bias (Step 22)All 39 ranges enumerated; 0 of 198,900 steps rejected a valuePass
No drand or other outside input (Step 5)5,100 / 5,100 reproduced from seeds and nonce alonePass
Simulation (Step 19)0 / 40 configs fail at α/40Pass
2.9Code References8 source files
2 columns
FilePurpose
src/rng.tsHMAC-SHA256 backward Fisher–Yates draw (computeDraw, computeDrawFromBuffer)
docs/ALGORITHM.mdThe written specification src/rng.ts was built from
tests/keno/RngSpecTests.tsThe specification's 79 vector and property checks
src/operator-verifier.tsRuns Duel's Verify-tab code unmodified (cross-check)
src/simulate.tsMonte Carlo simulation (40M rounds Pass 1, Pass 2 on casino seeds)
src/stats.tsChi-squared, lag-1 autocorrelation, Wald–Wolfowitz runs test
tests/steps/bias.tsStep 22: every shuffle range enumerated
tests/steps/simulation.tsSteps 19–20: simulation results re-derived and replayed
2.10Verified Invariants8 invariants
2 columns
InvariantResult
Our draw matches the live game for all 5,100 betsPass
Key is hex-decoded (not UTF-8); the wrong encoding gives wrong drawsPass
Every range 2–40: accepted values a whole multiple of the range (bias 0)Pass
No outside input needed to compute a drawPass
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 α/40Pass
Simulated RTP per config consistent with 99.9% theoreticalPass
A wrong client seed changes the drawn set on 5,100 / 5,100 betsPass
2.11Datasets UsedSource artifacts
Simulation: outputs/simulation-results.json, 40M rounds across 40 configurations
Primary dataset: data/keno-master-5100bets.json: 5,100 live bets for draw recomputation
Simulation output: outputs/simulation-results.json: Pass 1 (40M rounds, per-config checks) and Pass 2 (102 casino seeds × 10,000 nonces)
Determinism log: outputs/determinism-log.json: 5,100 verified, 0 mismatches, 0 skipped
2.12Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier:

reproduce-s2.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verify
Expected 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)
03

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.

Live ↔︎ Verifier Parity

5,100 / 5,100bets matched

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
5,100 / 5,100bets matched
  • 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
Parity Verification Flow — seeds → recompute → compare → exact match — illustrated flow
5,100Live Bets Tested
100%Parity Rate
$0.01 & $10Bet Sizes Tested
0Mismatches
CheckResultEvidence
Draw recomputationPass5,100 / 5,100: the drawn set matches for every bet (Step 5)
Payout correctnessPassAll 5,100: amount_won = stake × the cell at 13 decimal places, exact on integer units, no tolerance (Step 7)
Multiplier table integrityPassEvery served multiplier equals the pinned kenoConfig.json cell; 40 / 40 configurations served (Step 8)
Player verifiers & Duel's codePassThis 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 independencePassThe draw takes no stake input; the 100 $10 bets recompute and settle by the same rules (Steps 5, 9)
Config completenessPassAll 40 configurations played live, at least 73 bets each; 190 of 260 payout cells reached (Step 10)
Multi-phase coveragePassA: 32 configurations (picks 2–9) · B: picks 1 · C: picks 10 · D: $10 stake (Step 13)
Draw recomputationPass
5,100 / 5,100: the drawn set matches for every bet (Step 5)
Payout correctnessPass
All 5,100: amount_won = stake × the cell at 13 decimal places, exact on integer units, no tolerance (Step 7)
Multiplier table integrityPass
Every served multiplier equals the pinned kenoConfig.json cell; 40 / 40 configurations served (Step 8)
Player verifiers & Duel's codePass
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 independencePass
The draw takes no stake input; the 100 $10 bets recompute and settle by the same rules (Steps 5, 9)
Config completenessPass
All 40 configurations played live, at least 73 bets each; 190 of 260 payout cells reached (Step 10)
Multi-phase coveragePass
A: 32 configurations (picks 2–9) · B: picks 1 · C: picks 10 · D: $10 stake (Step 13)
✓  Live game and verifier aligned

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.

Why Parity Matters — illustrated flow
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.

5 columns
PhaseBetsConfigBet AmountPurpose
A — Configuration coverage3,00032 configs (picks 2–9)$0.01Mid-range pick counts at all 4 risk levels
B — Picks 11,0004 configs (picks 1)$0.01Smallest selection; the two consolation payouts
C — Picks 101,0004 configs (picks 10)$0.01Largest selection; highest per-bet variance
D — Stake equivalence1001 config (MEDIUM, 10 picks)$10.00Same rules at a higher stake; two auditor-set client seeds
Total: 5,100 bets across 102 epochs. Total wagered: $1,050.00 ($30.00 Phase A + $10.00 Phase B + $10.00 Phase C + $1,000.00 Phase D).
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.

Draw Recomputation (Step 5) — illustrated flow
tests/steps/determinism.ts · Step 5: Draw Recomputation · Verified
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++;  }}
Result: 5,100 / 5,100 bets recomputed, 0 skipped, 0 set 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.

Payout Math (Step 7) — illustrated flow
tests/steps/payouts.ts · Step 7: Payout Math · Verified
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++; }}
Result: 5,100 / 5,100 exact: 2,209 paying bets and 2,891 zero-paying bets. 0 errors.
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.

2 columns
MetricCount
Bets checked5,100
Served at the cell's full precision4,662
Served rounded to 13 decimal places438
Mismatches0
tests/steps/payouts.ts · Step 8: Multiplier Table Provenance · Verified
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;
Result: Every served multiplier matches 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.

3 columns
ConfigZero-Hit MultiplierVerified
LOW picks=10.71×✅
MEDIUM picks=10.41×✅
All 38 other configs0×✅
Result: LOW/1 pick pays 0.71× and MEDIUM/1 pick pays 0.41× on zero hits. Every other configuration pays 0× on zero hits.
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.

Result: Phase D: 100 / 100 draws and payouts reproduce at $10; 43 of the 100 paid. The stake is not an input to the draw.
Variance context: Phase D returned 90.388% over its 100 bets. MEDIUM with 10 picks has high per-bet variance, so 100 bets say little about RTP; the theoretical 99.9% is derived in S4.
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]
3 columns
StepProcessOutput
1Backward Fisher–Yates: 39 HMAC-SHA256 calls, cursor 0–38Shuffled array
2a[0..9] → drawn set{4, 16, 19, 22, 30, 32, 33, 36, 37, 39}
3Count hits: selected ∩ drawn4 hits (16, 19, 32, 39)
4Multiplier lookup: LOW/10 picks, 4 hits1.31×
5Payout: 0.01 × 1.310.0131 ✅
HMAC-SHA256 recomputation · Verified
// 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 ✅
Parity: Bet 34333136: drawn set, hit count, multiplier and payout all match between the live game and our verifier.
Live GameSET = {4,16,19,22,30,32,33,36,37,39}, payout = 0.0131
VerifierSET = {4,16,19,22,30,32,33,36,37,39}, payout = 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.

Result: 5,100 / 5,100 on all three. Agreement with published code does not show which code Duel's server runs today.
Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary7 checks
3 columns
Verification AreaCoverageResult
Draw recomputation (Step 5)5,100 / 5,100 bets: full drawn setPass
Payout math (Step 7)5,100 / 5,100, exact on integer unitsPass
Multiplier provenance (Step 8)5,100 / 5,100; all 40 configurationsPass
Consolation payouts (Step 12)The 2 declared cells, and no other out-of-pattern cell in 260Pass
Phase D at $10 (Step 9)100 / 100 draws and payoutsPass
Config completeness (Step 10)40 / 40 configs, at least 73 bets each; 190 / 260 cells reachedPass
Player verifiers and Duel's code (Step 23)5,100 / 5,100 on eachPass
3.11Code References6 source files
2 columns
FilePurpose
tests/steps/determinism.tsStep 5: draw recomputation
tests/steps/payouts.tsSteps 7–12: payout math, multiplier provenance, Phase D, coverage, edge fields, consolation cells
tests/steps/dataset.tsSteps 13–18: population, dataset hash, epoch size, hit model, anti-circularity, Phase D seeds
tests/steps/parity.tsStep 23: player verifiers and Duel's Verify-tab code
src/money.tsExact settlement on integer units
src/config.tsPaytable lookup and hit probabilities
3.12Datasets UsedSource artifacts
Primary dataset: data/keno-master-5100bets.json: 5,100 live bets across 102 epochs
Game config: kenoConfig.json: the 40 multiplier tables as captured, scaling_edge empty
Verification output: outputs/verification-results.json: Steps 5, 7–12 and 23
3.13Verified Invariants8 invariants
2 columns
InvariantResult
Recomputed drawn set matches the live drawn_numbers for all 5,100 betsPass
amount_won = stake × the cell at 13 decimal places, exact, for all 5,100 betsPass
Every served multiplier matches kenoConfig.json for all 40 configurationsPass
Consolation payouts: LOW/1 pick (0.71×), MEDIUM/1 pick (0.41×), no othersPass
Phase D ($10) draws and payouts follow the same rules as $0.01Pass
No inputs beyond (serverSeed, clientSeed, nonce)Pass
All 40 risk/picks configurations present in live dataPass
Both ProvablyFair.org verifiers and Duel's code agree on all 5,100 betsPass
3.14Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier:

reproduce-s3.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verify
Expected 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)
04

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.

Return to Player Verification

99.9%theoretical RTP · base tier

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
99.9%theoretical RTP · base tier
  • 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
INDEPENDENT DERIVATION
Σ P(hits = k) × multiplier(k)= 0.999
Hypergeometric probabilities · Pinned payout table · All 40 configurations · Base stake tier

RTP claim (RTP-CLAIM 1.2.0): all 2,712 stake-tier rows on their stated figure, PASS.

99.9%Theoretical RTP · base tier, all 40 configs
99.970%Simulated (40M rounds)
0.1%Base-tier edge · RTP claim PASS
40/40Configs at 99.9%
CheckResultEvidence
Anti-circularityPassP(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 RTPPass99.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)PassClaim: 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 fieldsPassPinned config scaling_edge = []; effective_edge 0.1 on all 5,100 bets, at $0.01 and $10 (Step 11)
Payout exactnessPass2,209 paying and 2,891 zero-paying bets exact; served multiplier = pinned table on 5,100 / 5,100 (Steps 7, 8)
Simulation (Pass 1)Pass40M rounds, 1M per configuration; average 99.970%; 0 / 40 fail at α/40 (Step 19)
Cherry-pick test (Pass 2)PassTest 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 payoutsPassLOW and MEDIUM with 1 pick pay 0.71× and 0.41× on zero hits: partial returns of the stake (Step 12)
Stake tiersInfo2,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
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 RTPPass
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 fieldsPass
Pinned config scaling_edge = []; effective_edge 0.1 on all 5,100 bets, at $0.01 and $10 (Step 11)
Payout exactnessPass
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 payoutsPass
LOW and MEDIUM with 1 pick pay 0.71× and 0.41× on zero hits: partial returns of the stake (Step 12)
Stake tiersInfo
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
✓  Theoretical RTP 99.9% at the base tier, claim holds

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:

Anti-Circularity Proof (Step 17) — illustrated flow
3 columns
ComponentFormulaSource
Hit probabilityP(hits=k) = C(picks,k) × C(40−picks, 10−k) / C(40,10)Hypergeometric distribution: counting, not casino data
MultiplierkenoConfig.multipliers[risk][picks][k]Casino-supplied, from the pinned kenoConfig.json
RTPΣ P(k) × multiplier(k), k = 0 to picksIndependent 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
6 columns
PicksRiskP(0 hits)Multiplier(0)Σ P×MRTP
1Classic0.750000×0.9990099.9%
1Low0.750000.71×0.9990099.9%
5Classic0.216570×0.9990099.9%
10High0.035440×0.9990099.9%
Result: All 40 configurations: RTP = 99.9000%. In exact rational arithmetic on the table literals, 16 equal 999/1000 exactly and the other 24 differ by at most 1.125×10⁻¹⁶ (HIGH, 10 picks). On the 13-decimal multipliers actually paid, the largest difference is 7.21×10⁻¹⁵ (LOW, 10 picks). No printed figure changes.

Anti-Circularity Verification:

tests/steps/dataset.ts · Step 17 · Verified
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.

Result: 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.
Stake tiers: Duel's 5 October 2026 config adds tiers above 0.1%. They are explained in 4.5 from the config, and not certified.
Variance note: Keno is a high-variance game: HIGH with 10 picks pays 1,200× on 10 hits, with probability 1 in 847,660,528 (about 1.18 × 10⁻⁹). Small samples stray far from 99.9%; the derivation in 4.1 is the RTP evidence.
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.

4 columns
ConfigTheoretical RTPSimulated RTPDeviation
CLASSIC/p199.900%100.059%+0.159%
CLASSIC/p299.900%99.991%+0.091%
CLASSIC/p399.900%99.860%−0.040%
CLASSIC/p499.900%99.958%+0.058%
CLASSIC/p599.900%100.028%+0.128%
CLASSIC/p699.900%99.870%−0.030%
CLASSIC/p799.900%99.778%−0.122%
CLASSIC/p899.900%99.614%−0.286%
CLASSIC/p999.900%100.242%+0.342%
CLASSIC/p1099.900%99.931%+0.031%
LOW/p199.900%99.912%+0.012%
LOW/p299.900%99.741%−0.159%
LOW/p399.900%99.817%−0.083%
LOW/p499.900%99.439%−0.461%
LOW/p599.900%99.759%−0.141%
LOW/p699.900%100.714%+0.814%
LOW/p799.900%99.499%−0.401%
LOW/p899.900%99.726%−0.174%
LOW/p999.900%99.958%+0.058%
LOW/p1099.900%99.936%+0.036%
MEDIUM/p199.900%99.908%+0.008%
MEDIUM/p299.900%99.745%−0.155%
MEDIUM/p399.900%99.638%−0.262%
MEDIUM/p499.900%99.489%−0.411%
MEDIUM/p599.900%101.340%+1.440%
MEDIUM/p699.900%99.029%−0.871%
MEDIUM/p799.900%99.751%−0.149%
MEDIUM/p899.900%100.278%+0.378%
MEDIUM/p999.900%99.840%−0.060%
MEDIUM/p1099.900%100.030%+0.130%
HIGH/p199.900%100.014%+0.114%
HIGH/p299.900%99.931%+0.031%
HIGH/p399.900%99.178%−0.722%
HIGH/p499.900%98.846%−1.054%
HIGH/p599.900%101.786%+1.886%
HIGH/p699.900%101.685%+1.785%
HIGH/p799.900%99.991%+0.091%
HIGH/p899.900%100.440%+0.540%
HIGH/p999.900%100.290%+0.390%
HIGH/p1099.900%99.774%−0.126%
Result: Mean simulated RTP 99.970%. All 40 configurations pass the hit-distribution and serial checks.
Variance note: With 1M rounds per configuration, rare top payouts drive most of the spread. MEDIUM and HIGH with 5 picks pay 395× and 460× on 5 hits, which is why they sit at +1.440% and +1.886%; HIGH with 4 picks (−1.054%) is the largest shortfall. The hit counts themselves fit the hypergeometric model in every configuration (Step 19).
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.

4 columns
RowsSettingsExact RTPBeyond the band
Audited April table (0.1% tier)4099.900000%0
5 October 2026 config, 0.1% tier4099.900000%0
5 October 2026 config, scaled tiers2,63299.000000% – 99.890000%0
Verifier output, as run at v1.2.1 (rtp-claim lines; the 91-tier list shortened) · Verified
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 pin
Result: PASS. All 2,712 rows sit on their stated figure: each exact RTP differs from 1 minus its stated edge by less than 3.31 × 10⁻⁹. The per-setting table is outputs/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.

4 columns
Bet range (CLASSIC, 1 pick)House edgeRTP1-hit multiplier
$0 – $8,3440.1%99.9%3.996×
$15,874 – $16,7110.2%99.8%3.992×
$41,102 – $41,9460.5%99.5%3.980×
$83,604 – $84,4591.0%99.0%3.960×
4 columns
ConfigTiersBase-tier ceilingEdge range
LOW, 1 pick91$99,546.070.1% – 1.0%
CLASSIC, 1 pick91$8,344.460.1% – 1.0%
HIGH, 6 picks91$90.200.1% – 1.0%
HIGH, 10 picks8$1,549.740.1% – 0.17%
CLASSIC, 10 picks3$12,882.750.1% – 0.12%
LOW / MEDIUM, 10 picks1$2,502.090.1% (no scaling)
Finding: A disclosed tier structure, consistent with Duel's stated figures at every tier. It raises the game-engine edge on large stakes, up to 1.0%, above the certified 0.1%. Stake selects the tier; it never affects the draw.
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.

Simulation Pass 1 — Pinned Seeds (Step 19) — illustrated flow

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.

src/simulate.ts · Pass 1 core loop · Verified
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);  }} 
Result: 40M rounds. Average simulated RTP 99.970%. 0 / 40 hit-distribution, grid-uniformity or serial failures. The hit distribution is consistent with the hypergeometric model.

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.

2 columns
TestResult
Seeds tested102
Seed × config combinations1,666
Test A: full-range fails (p < 0.01)13 / 1,666 — binomial tail p 0.848
Test B: early-only flags57 / 1,666 — binomial tail p 0.9992
Served-return screenz = +1.49; bootstrap lower-tail p 0.919 (B = 10,000)
Detection power80% for a per-bet return shortfall of 0.234×
tests/steps/simulation.ts · Step 20: Pass 2 re-scored from the rows · Verified
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++;}
Result: Pass 2 finds no sign of seed pre-selection under its declared thresholds.
Why is this included? Duel generates the default client seed in your browser, and players can set their own, which makes pre-selecting server seeds against a player hard. Pass 2 adds an empirical check on the seeds Duel actually used.
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.

3 columns
MetricPhase C ($0.01)Phase D ($10)
Bets1,000100
Config4 configs (picks=10)1 config (MEDIUM picks=10)
Draws recomputed1,000/1,000100/100
Multiplier tablekenoConfig.json (base tier)kenoConfig.json (base tier)
RNG pathHMAC-SHA256 Fisher-YatesHMAC-SHA256 Fisher-Yates
Result: Same draw code and same table at $0.01 and $10. Stake selects the edge tier (4.5), not the draw.
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.

4 columns
ConfigP(0 hits)Zero-Hit MultiplierWeighted Contribution
LOW picks=10.7500000.71×0.532500
MEDIUM picks=10.7500000.41×0.307500
All 38 othersvaries0×0.000000
Result: Consolation payouts confirmed and consistent with 99.9% RTP on both configurations.
4.10Informational Items (Not Scored)

Reported for transparency, not scored. They show the return observed during the capture.

3 columns
ItemValueContext
Phase A observed return118.478%3,000 bets at $0.01 (picks 2–9)
Phase B observed return105.378%1,000 bets at $0.01 (picks 1)
Phase C observed return95.821%1,000 bets at $0.01 (picks 10)
Phase D observed return90.388%100 bets at $10 (MEDIUM, 10 picks)
Overall observed return91.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

3 columns
StepProcessOutput
1Backward Fisher–Yates: 39 HMAC callsdrawn set = {2, 3, 4, 13, 18, 21, 23, 26, 31, 32} ✅
2Count hits: selected ∩ drawn2 hits (3, 4)
3Multiplier: CLASSIC/5 picks, 2 hits1.4×
4RTP check: P(2 hits) × 1.4P = 0.27766, contribution = 0.38872
5Payout: 0.01 × 1.40.014 ✅
RTP derivation for this bet's config · Verified
// 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%) ✅
Parity: Bet 34309818: drawn set, hit count, multiplier and payout all match. RTP for CLASSIC with 5 picks = 99.900%, from independent hypergeometric probabilities.
Live Game2 hits, payout = 0.014
Verifier2 hits, payout = 0.014
Technical Evidence & Verification5 sections
4.12Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Anti-circularity (Step 17)40 / 40 configs; exact rational check; 2 negative controlsPass
RTP claim (Step 17)2,712 rows, 0 beyond ±0.1 ppPass
Captured edge fields (Step 11)scaling_edge = []; effective_edge 0.1 on 5,100 / 5,100Pass
Stake tiers (5 October 2026 config)2,672 tiers, 0.1%–1.0%; explained from the configInfo — see 4.5
Consolation payouts (Step 12)The 2 declared cells, no othersPass
Simulation Pass 1 (Step 19)40M rounds; 0 / 40 fail at α/40Pass
Simulation Pass 2 (Step 20)1,666 combinations; Test A 13, Test B 57; served-return z = +1.49Pass
Bet-size invariance (Step 9)100 / 100 Phase D at $10Pass
4.13Code References8 source files
2 columns
FilePurpose
tests/steps/dataset.tsStep 17: anti-circularity, exact RTP and the RTP claim
src/exact.tsInteger binomials and exact rational RTP
src/rtp-claim.tsFramework rule RTP-CLAIM 1.2.0
src/rtp-settings.tsThe tiered claim and the RTP claim table
src/live-config.tsThe 5 October 2026 tiers, recomputed (informational)
tests/steps/payouts.tsSteps 9, 11, 12: bet-size invariance, edge fields, consolation cells
tests/steps/simulation.tsSteps 19–20: simulation re-derived and cherry-pick test
src/simulate.tsMonte Carlo simulation (40M rounds Pass 1, Pass 2)
4.14Datasets UsedSource artifacts
Simulation output: outputs/simulation-results.json: Pass 1 (40M rounds) and Pass 2 (102 seeds × 10,000 nonces)
Game config: kenoConfig.json: the 40 multiplier tables as captured, scaling_edge empty
RTP claim table: outputs/rtp-claim-table.json: 2,712 exact RTPs, each with its stated tier and outcome
Stake tiers: evidence/keno-config-live-2026-10-05.json (E14) and outputs/live-config-scaling.json
4.15Verified Invariants9 invariants
2 columns
InvariantResult
Σ 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 tierPass
Every captured bet priced at the 0.1% tier (effective_edge 0.1)Pass
Simulated RTP average 99.970% across 40M roundsPass
0 / 40 configs fail at Bonferroni α/40Pass
Pass 2 within its declared thresholds across 102 casino seedsPass
Phase D ($10) bets follow the same draw and table as $0.01Pass
Consolation payouts (LOW/MEDIUM, 1 pick) consistent with 99.9% RTPPass
4.16Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier:

reproduce-s4.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verify
Expected 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 Test
05

Fairness 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.

Fairness Integrity Testing

14pass1N/A

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
14pass1N/A
  • 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?
4 / 4Nonce Integrity
5 / 5Seed Commitment
1 / 1Outcome Determinism
2 / 2Player Isolation
2 / 2Payout Integrity

Category Coverage

Nonce Integrity4/4
Seed Commitment5/5
Outcome Determinism1/1
Player Isolation2/2
Payout Integrity2/2
CheckResultEvidence
Nonce integrityPassSequential, server-controlled, no duplicates across 102 epochs; 2 nonces missed on retried requests (capture script, not Duel)
Seed commitment integrityPassLocked at bet acceptance, unique per epoch — 102/102 verified
Outcome determinismPassIdentical inputs produce identical outcomes — 5,100/5,100 confirmed
Round & player isolationPassPer-user seeds, serial independence confirmed (0/40 fail in simulation)
Payout integrityPassParameter limits enforced (6/6 invalid selectedPositions rejected); injected payout fields ignored (0 honoured); server-computed multiplier consistent across all probes
Nonce integrityPass
Sequential, server-controlled, no duplicates across 102 epochs; 2 nonces missed on retried requests (capture script, not Duel)
Seed commitment integrityPass
Locked at bet acceptance, unique per epoch — 102/102 verified
Outcome determinismPass
Identical inputs produce identical outcomes — 5,100/5,100 confirmed
Round & player isolationPass
Per-user seeds, serial independence confirmed (0/40 fail in simulation)
Payout integrityPass
Parameter limits enforced (6/6 invalid selectedPositions rejected); injected payout fields ignored (0 honoured); server-computed multiplier consistent across all probes
✓  All Fairness Guarantees Verified

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.

3 columns
CategoryTestsWhat It Catches
Nonce Integrity4Sequence gaps, server-side nonce manipulation, session continuity
Seed Commitment5Mid-epoch seed changes, seed reuse, predictable seed generation
Outcome Determinism2Non-deterministic outputs, outcome replay
Player Isolation2Cross-round correlation, cross-user outcome dependence
Payout Integrity2Parameter 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.

3 columns
SeverityMeaningAction
PASSTest passed — no issue detectedNone
N/ATest not applicable to this game typeNone
FLAGAnomaly detected, documented for transparencyDisclosed
HARD FAILFairness guarantee cannot be confirmedCertification blocked until remediated
2 columns
ConditionConsequence
Nonce gap or duplicate within epochOutcome sequence integrity broken
Server seed changed mid-epochCommit-reveal guarantee broken
Draw recomputation mismatchUndisclosed inputs affecting outcomes
Client seed not used in HMACPlayer has no influence on outcomes
Hard fail criteria: Any single hard fail = NOT PROVABLY FAIR. The audit cannot proceed past a hard fail without operator remediation and re-verification.

15 tests · 14 pass · 1 N/A

Nonce Integrity4/4
FI-NONCE-003Pass

Submitting 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.

Seed Commitment5/5
FI-SEED-001Pass

Empty, 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-004Pass

No 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-005Pass

Server 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-002N/A

A 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-002Pass

One 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-001Pass

Game 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-002Pass

Multiplier 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
4 columns
Test IDCategoryVerification SourceStatus
FI-NONCE-001NonceS1, Step 4 (data-driven)Pass
FI-NONCE-002NonceS1, Step 4 (data-driven)Pass
FI-NONCE-003NonceAPI probePass
FI-NONCE-004NonceS1, Step 4 (data-driven)Pass
FI-SEED-001SeedAPI probePass
FI-SEED-002SeedS1, Steps 3 & 6 (data-driven)Pass
FI-SEED-003SeedS1, Step 1 (data-driven)Pass
FI-SEED-004SeedAPI probePass
FI-SEED-005SeedAPI probePass
FI-OUTCOME-001DeterminismS3, Step 5 (data-driven)Pass
FI-OUTCOME-002DeterminismStructural — single-step gameN/A
FI-ISO-001IsolationS2, Step 19 (simulation)Pass
FI-ISO-002IsolationStructural — seed uniquenessPass
FI-PAYOUT-001PayoutAPI probePass
FI-PAYOUT-002PayoutAPI probePass
Method breakdown: 8 tests verified via verification suite steps and structural analysis, 1 test N/A (single-step game), 6 tests verified via direct API probes against the running game. All 6 probes recorded request/response evidence in our private adversarial-testing archive. No game-state integrity tests required — Keno is a single-step auto-resolving game with no multi-step state.
5.4Additional Integrity Evidence (S1–S4)6 records
3 columns
PropertySourceFinding
102/102 seed hashes verifiedS1, Step 1Commit-reveal chain intact
106/106 next-seed promotionsS1, Step 2Seed rotation chain intact
5,100/5,100 exact parityS3, Step 5No post-RNG conditional logic
Anti-circularity provenS4, Step 170.1% house edge — independent probabilities, committed table
57 cherry-pick flags (≤80)S4, Step 20No seed pre-selection bias
100.0% client seed influenceS1, Step 6Player 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.

reproduce-s5-data.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-keno && git checkout v1.2.1npm cinpm run verify
Expected 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-001

API Probe Tests (completed):

fi-api-probes.sh
[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 honoured
API probes: All 6 API probe tests completed. Per-test evidence — requests, server responses, HTTP status codes, server-assigned nonces and seed hashes, drawn numbers, multipliers — is retained in our private adversarial-testing archive and summarised in the integrity test review document. The testing harness itself is kept private; per-test evidence is available to operators and regulators on request.
06

Player 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).

Independent Result Verification

4 Stepsto verify any bet

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
4 Stepsto verify any bet
  • 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
From Bet to Independent Verification — 4-step flow — illustrated flow
Server SeedRevealed after rotation
Client SeedPlayer-controlled input
NonceRecorded bet sequence
Your picks and risk levelto count hits and find the multiplier
  1. 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. 2

    Bet, Then Rotate

    Place your bets. When you're done, rotate the seed pair to reveal the server seed.

  3. 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. 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
6.1Step 1: Place a Keno Bet

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.

Illustrative: Duel.com Keno, with the 40-number grid and the pick and risk controls.

6.2Step 2: Open the Fairness Modal

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.

Illustrative: Provably Fair panel — active client seed, hashed server seed, nonce, new client seed, next pair commitment and the Rotate seed action.

6.3Step 3: Open Past Bet to Reveal Seed

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).

Per-bet Verify tab — client seed, revealed server seed and nonce for the round (account details masked).

6.4Step 4: Recompute & Confirm

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.

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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent (audit codebase)
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Checked by this auditDuel's Verify-tab code, run unmodified as a cross-check on 5,100 bets: 0 differSame code Step 23 runs on 5,100 bets: 0 differ
Trust modelRequires trusting the casinoOpen-source, version-controlled
Payout shownDrawn numbers onlyDrawn 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.

verify-keno.js · Standalone Node.js
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):

verify_keno.py · Standalone Python
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.

Example (from the config, not a recorded bet): a $9,000 CLASSIC 1-pick bet is in the 0.11% tier ($8,344.46–$9,180.13) and pays 3.9956× on a hit, $35,960.40.
6.11Evidence Screenshots5 records
2 columns
EvidenceDescription
E02Fairness page overview: where the seed information is shown
E03Illustrative: Duel's verify page with Keno selected. Its Code panel is collapsed; the full source is E13
E11Illustrative, recorded on Duel's Dice page: the rotation response echoes the client seed you submit and returns the active and next commitments
E12Duel's browser seed generator: 16 characters from a 63-character alphabet, rejection-sampled crypto.getRandomValues
E13Duel's Keno Verify-tab source, copied 25 September 2026 and run unmodified as a cross-check
From Bet to Independent Verification — 4-step flow — illustrated flow
How it works
  1. 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. 2

    Bet, Then Rotate

    Place your bets. When you're done, rotate the seed pair to reveal the server seed.

  3. 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. 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
6.1Step 1: Place a Keno Bet

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.

Illustrative: Duel.com Keno, with the 40-number grid and the pick and risk controls.

6.2Step 2: Open the Fairness Modal

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.

Illustrative: Provably Fair panel — active client seed, hashed server seed, nonce, new client seed, next pair commitment and the Rotate seed action.

6.3Step 3: Open Past Bet to Reveal Seed

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).

Per-bet Verify tab — client seed, revealed server seed and nonce for the round (account details masked).

6.4Step 4: Recompute & Confirm

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.

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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent (audit codebase)
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Checked by this auditDuel's Verify-tab code, run unmodified as a cross-check on 5,100 bets: 0 differSame code Step 23 runs on 5,100 bets: 0 differ
Trust modelRequires trusting the casinoOpen-source, version-controlled
Payout shownDrawn numbers onlyDrawn 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.

verify-keno.js · Standalone Node.js
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):

verify_keno.py · Standalone Python
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.

Example (from the config, not a recorded bet): a $9,000 CLASSIC 1-pick bet is in the 0.11% tier ($8,344.46–$9,180.13) and pays 3.9956× on a hit, $35,960.40.
6.11Evidence Screenshots5 records
2 columns
EvidenceDescription
E02Fairness page overview: where the seed information is shown
E03Illustrative: Duel's verify page with Keno selected. Its Code panel is collapsed; the full source is E13
E11Illustrative, recorded on Duel's Dice page: the rotation response echoes the client seed you submit and returns the active and next commitments
E12Duel's browser seed generator: 16 characters from a 63-character alphabet, rejection-sampled crypto.getRandomValues
E13Duel's Keno Verify-tab source, copied 25 September 2026 and run unmodified as a cross-check
✓  Any Player Can Reproduce Keno Results

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.

07

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.

Open-Source Audit Repository

v1.2.1release tag

Repository Details

Prerequisites

  • Node.js 22.x (.nvmrc)
  • npm
  • Git
v1.2.1release tag
github.com/ProvablyFair-org/duel-kenoRelease v1.2.1 · original audit 4fc06ec

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.

sh
git clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-kenogit checkout v1.2.1npm ci npm test
Expected output
Passed:     22/23Hard fails: 0Flags:      1 (0 verdict-affecting, 1 capture-origin / verdict-neutral) VERDICT: PROVABLY FAIR — Full Pass Committed artifacts NOT modified.Reproduction vs the committed artifacts on Node 22.22.0: REPRODUCED

Audit Reproducibility Pinning

Release
v1.2.1 (Framework 1.1)
Original audit
4fc06ec9b0a29f7e664732fef7295607a58b57c5 (4 June 2026)
Node Version
22.x (.nvmrc, package.json engines)
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
3 columns
FileContentsSize
verification-results.jsonAll 23 step results, profile coverage, verdict~70KB
determinism-log.json5,100 verified, 0 mismatches, 0 skipped57B
chi-squared-results.jsonLive hit counts against the hypergeometric model, by configuration~19KB
payout-coverage.jsonThe 190 cells reached live and the 70 not, with their RTP share~15KB
rtp-claim-table.jsonRTP claim: 2,712 exact RTPs, each with its stated tier and outcome (PASS)~724KB
live-config-scaling.jsonThe 5 October 2026 tiers, thresholds and RTPs (informational)~735KB
simulation-results.jsonPass 1 (40M rounds) + Pass 2 (102 seeds × 10,000 nonces)~1.6MB
rtp-convergence.htmlSelf-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
3 columns
StepTest NameReport Section
1Seed Hash IntegrityS1, S5
2Next-Seed Promotion (Commitment Linkage)S1
3Hash Consistency Within EpochS1, S5
4Nonce Audit (capture flag)S1, S5
5Draw Recomputation (RNG + drand absent)S1, S2, S3, S5
6Client Seed InfluenceS1, S2, S5
7Payout MathS3, S4
8Multiplier Table ProvenanceS3, S4
9Phase C Bet-Size Invariance (Phase D at $10)S3, S4
10Configuration Completeness & Payout-Cell CoverageS3
11Captured Edge Fields (pinned scaling_edge empty)S3, S4
12Consolation Payout Disclosure (LOW/MEDIUM picks=1 zero-hit)S3, S4
13Population & Phase LabelsS3
14Dataset HashS7
15Epoch SizeS1
16Hit Symmetry (hypergeometric mode verification)S4
17Probability Independence (Anti-Circularity)S4
18Phase D — Client Seed VariationS1
19Simulation Results — Pass 1 IntegrityS2, S4, S5
20Simulation Results — Pass 2 Cherry-Pick TestS4, S5
21Artifact Integrity (pinned artifacts of record)S7
22Draw Bias Bound (rejection ceiling, every range enumerated)S2
23Player-Verifier Parity (docs-site + live-site)S2, S3, S6
reproduce-audit.sh
reproduce-audit.sh
# Clone the releasegit clone https://github.com/ProvablyFair-org/duel-keno.gitcd duel-kenogit checkout v1.2.1npm ci   # Node 22.x, as pinned in .nvmrc # 30 unit tests, the 23 scored steps and the reproduction gatenpm test # Optional: also regenerate the 40M-round simulation (about 45 minutes)npm run test:fullnode scripts/release-manifest.mjs --check # This run's results (the committed evidence is never overwritten)cat outputs/run/verification-results.jsoncat outputs/run/diff.json
provablyfair.org/verify-bets/duel
This is an open-source audit. Every finding, dataset, and line of verification code is publicly accessible. Clone the repo at the release tag, run the tests, and check every claim yourself.
✓  Reproduced at v1.2.1

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:

2 columns
CodeMeaning
0PROVABLY FAIR — Full Pass, and this run reproduces the committed artifacts. A capture flag is printed and recorded but exits 0
1At least one hard fail, a reproduction difference beyond tolerance, or an RTP claim table that differs
2At least one operator-origin FLAG — PROVABLY FAIR — Conditional Pass
5RTP FIGURE OVERSTATED: no draw check failed, but the RTP claim rule found rows beyond the ±0.1 pp band on the house side
This run: exit 0 — PROVABLY FAIR — Full Pass, REPRODUCED.
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.

Verifier output, as run at v1.2.1 (Node 22.22.0) · Verified
Committed artifacts NOT modified.Reproduction vs the committed artifacts on Node 22.22.0: REPRODUCED
7.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.

2 columns
FileSHA-256
data/keno-master-5100bets.json841755fdfb268d7796017212f08a18bfea7615c30a4590dd29793b34c5e6bcf9
kenoConfig.jsonefd3c645c4b3956199fde62dd65446c08e4605763d2d0f34c97a226bdbae4f91
outputs/chi-squared-results.json2af4ae85b381b8eebca9e7ab664b49f412a50f75e8646c2c205538d66a3e6e13
outputs/determinism-log.json081193bc8e2965dd7f4bf1b82b2bd232ba2cedb5783f9cd1b96111218500604b
outputs/payout-coverage.jsone627bc8bc49ff0f8efb0a64a4516c9638c2af1de8f2e7842cd96ffcf0e5e8570
outputs/rtp-convergence.htmlceb2f732a43da4439fa36af88c33f79acf177e50cb9309d06ceafaf98616e77f
outputs/simulation-results.jsonc8543cce21bef6707099b0f29676abe2712fdb3ce0c85f46e3c9a014f12f0de7
outputs/verification-results.json4a99d37c94dca70b6a60d64d2790ca9e3fa32d5c11c0fb3201a027284f38611f
outputs/rtp-claim-table.json01af5577a3032d467cd262fe4897705a6aa849f025b44f08283d35a1decceddb
evidence/keno-config-live-2026-10-05.json787f9bad764a1cf5a8db9b7d166582b072c197a7ffd8eda6019d6c3817478d84
evidence/keno-config-live-2026-10-05.meta.json71a685bb12afab19a2acfb2177b4012be37840174a5e03c6ff2fcca4dbbf64da
outputs/live-config-scaling.jsonbd9107846ff27cc402580b7292497e861541f8598892dd231b8f5ba940af7953
evidence/keno-edge-claim-read-2026-10-05.mdac45a8142bb18a4f7a9ccad86e46585e840d87dc93be451bba9e7a1a8206780e

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
3 columns
ReleaseWhat changedVerdict
v1.0.0The original auditPROVABLY FAIR — Full Pass
v1.1.0Draw-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 unchangedUnchanged
v1.2.0RNG code rebuilt from a written specification; Duel's Verify-tab code kept as a cross-check onlyUnchanged
v1.2.1Adds .gitattributes so a Windows clone stays byte-identical; no audit content changedUnchanged
Framework 1.1

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.

32Profile checks
22By scored steps
8By package checks
2 n/a · 5 partialMarked as such
4 columns
CheckCovered byCoverageWhat it covers
KENO-01Steps 1, 5FullRevealed seeds hash to their commitments; every bet-bearing epoch's seed revealed
KENO-02Step 2FullForward links recomputed from the raw hashes, plus the pre-capture anchor
KENO-03Step 3FullEpochs keyed by the rotation timeline; one hash and one client seed per epoch; no commitment reused
KENO-04Step 4FullRepeats, reorders and gaps fail unless they match a capture retry (2, capture flag)
KENO-05Steps 1, 5, 13, 15FullBets, seed records, phases and epoch sizes bound to the capture plan
KENO-06Steps 6, 9, 18PartialClient seed influence and Phase D seeds. Partial: the capture's A–C seeds came from Math.random(), not a CSPRNG
KENO-07Step 5FullEvery bet recomputed to its served draw, compared as a set
KENO-08Step 22FullDraw-bias bound exact (0) for every range 2–40; rejection census
KENO-09Package checkFullRNG rebuilt from the written specification; Duel's Verify-tab code run unmodified as a cross-check
KENO-10Steps 5, 7, 8FullDraw structure, legal pick sets, hits counted on the recomputed draw
KENO-11Step 7FullPayouts exact on integer units, no tolerance
KENO-12Step 9PartialPhase D stake invariance. Partial: 43 paying bets at $10, below the profile's 100
KENO-13Step 8FullServed multiplier equals the pinned paytable at 13 decimal places on every bet
KENO-14Step 12FullEvery out-of-pattern cell enumerated: only the two consolation cells; no cap declared
KENO-15Step 10PartialAll 40 configurations played; 190 of 260 cells reached. Partial: Phase A alone covers 32
KENO-16—n/aNo bet response carries a running balance
KENO-17Step 5FullPicks, risk and stake are not draw inputs; recomputed across differing pick sets
KENO-18Steps 16, 17FullHypergeometric law exact in integers; mode check; negative controls
KENO-19Step 17PartialExact 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-20Step 19Full40M-round simulation, every statistic re-derived from the shipped rows
KENO-21Step 20FullPass 2 cherry-pick test on all 102 revealed seeds, with the served-return screen
KENO-22Package checkFullLive hit counts and drawn-number uniformity (informational)
KENO-23Package checkFullThe package’s own S5 matrix in MANIFEST.md
KENO-24Step 23FullBoth ProvablyFair.org verifiers (pinned copies) run on every bet
KENO-25Package checkFullPlayer verification steps in order, with the commitment encoding
KENO-26Step 14FullDataset and paytable pinned by SHA-256
KENO-27Step 21FullPinned artifacts and value domains
KENO-28Package checkFullFresh-clone reproduction record
KENO-29Package checkFullMutation battery: every scored step has a killing mutation
KENO-30Package checkFullLimitations register and load-bearing premises
KENO-31—n/aNo stake scaling in the captured config (Step 11 checks the field); scaled tiers not certified
KENO-32Package checkPartialAutopick. Partial: Duel offers it and the capture never used it
Partial coverage: KENO-06, KENO-12, KENO-15 and KENO-32 are partial because the capture (11 April 2026) predates the September 2026 standard; KENO-19 because the rule discloses differences inside its band rather than flagging them. KENO-16 is n/a: no response carries a balance field. KENO-31 is n/a: the captured config has no stake scaling.