Executive summary
Duel.com · Independent audit of 11 in-house gamesAll 11 games met the framework’s certification criteria.
Certified June 8, 2026
Retested under Framework v1.1, October 2026
ProvablyFair.org conducted an independent audit of the 11 provably fair games Duel.com operates in-house: ten between March and May 2026, with certification granted in June 2026, and Limbo, added in October 2026. The reports were updated to Framework v1.1 in October 2026. All 11 games met the framework's certification criteria.
Run these audits yourself
Every finding ships as code. Each game includes its verifier, captured bets and simulation harness.
Browse all 11 repositoriesnpm testReproduction guide ↗How to runIndependent rebuild, real-bet verification
These conclusions are not assertions. Each game is independently rebuilt from its published specification — not from Duel’s source code. An executable test suite then runs every live result against that rebuild.
Five areas. Every game must pass.
Every area must pass
Certification required a pass in every area, for every game; a failure in any single area would have prevented it. Each game is verified across five areas:
The commit-reveal chain is checked end to end — every revealed server seed matches its commitment, and every outcome recomputes exactly from its revealed inputs, in a sequence that can't be altered or replayed.
The randomness is independently reimplemented and confirmed to derive from an input the operator can't control, then tested statistically for genuine randomness.
Every recomputable bet is replayed on the rebuild and must match the live result exactly, down to intermediate states.
The RTP is derived from first principles — never from the operator's RTP figure — confirmed by large-scale two-pass simulation, and tested for cherry-picked seeds.
Each game is probed with adversarial and edge-case inputs to confirm it holds up under non-standard conditions.
One divergent step fails the run
Coverage scales with the game, from 18 scored steps to 38, and the suite fails the run if a single step diverges. The suite, datasets, and verification code are published open-source, re-runnable and inspectable by anyone.
How the advertised 100% RTP works
Duel advertises these games at 100% RTP.
This audit measures the return produced by each game’s logic at the base stake tier, the part anyone can reproduce from seeds, which comes to between 99.2% and 100% depending on the game, exactly as the published mechanics define.
Duel attributes the remainder to an instant rakeback credited at the account level; for Blackjack, Duel describes a rakeback of about 0.44% that leaves a 0.1% net edge, not 100%.
That rakeback sits outside the cryptographic layer, so this audit does not certify it (the Limbo audit records it on sampled bets, for information); the 99.2–100% is game-logic RTP and does not include any rebate.
What certification establishes
What this certification establishes is that each game’s logic pays exactly what its rules define, and that figure is mathematically correct and independently reproducible.
RTP scope and calculation
Duel advertises these games at 100% RTP. This audit measures the return produced by each game's logic at the base stake tier, the part anyone can reproduce from seeds, which comes to between 99.2% and 100% depending on the game, exactly as the published mechanics define. Duel attributes the remainder to an instant rakeback credited at the account level; for Blackjack, Duel describes a rakeback of about 0.44% that leaves a 0.1% net edge, not 100%.
That rakeback sits outside the cryptographic layer, so this audit does not certify it (the Limbo audit records it on sampled bets, for information); the 99.2–100% is game-logic RTP and does not include any rebate. What this certification establishes is that each game's logic pays exactly what its rules define, and that figure is mathematically correct and independently reproducible.
How the audit follows a live outcome
ProvablyFair.org captures Duel's live outcomes and re-derives every one independently.
Provable fairness requires that any third party can take an operator's published inputs and arrive at the same outcome the player saw. This audit tests exactly that — independently, for every game and every captured bet.
Scope of certification
What the certification covers, and where its boundaries sit.
This certification covers the cryptographic and statistical correctness of game outcomes in Duel's in-house provably fair games. It does not extend to other aspects of the platform. Both boundaries are stated below.
Third-party and licensed titles on Duel.com are outside the scope of this audit.Audited
- Provably fair RNG logic and entropy architecture
- Deterministic reproducibility of every audited bet
- RTP mathematical correctness from first principles
- Commit-reveal chain integrity across seed rotations
- Round, player, and seed-session isolation
- Payout integrity within the audited game logic
Outside this certification
Outside this certification
- Operator solvency, treasury, or wallet custody
- Regulatory licensing in any jurisdiction
- Infrastructure or server-side security posture
- Cross-account outcome consistency — not assessed in this audit
- Max-win cap enforcement at payout time — platform-level, not game logic
- Stake-scaled house edge above the base stake tier — explained in the game audits
- KYC, AML, responsible gambling controls
- Rakeback and promotional programs — operator-side, outside the audited game logic
What this means
This certification concerns whether Duel's in-house games produce the outcomes they are specified to produce — whether the randomness is genuine, the odds match the stated figures, and a result cannot be altered after a bet is placed. It is not an assessment of the casino's finances, licensing, or security infrastructure. Those are separate matters this audit does not measure.
Third-party and licensed titles are outside this audit. It assesses game outcomes, not the casino’s finances, licensing or security infrastructure.
What was tested, and how
Each audit answers five questions, applied independently to every game in scope.
01Can the casino change your outcome after you bet?
We verify that each result is fully determined by inputs the casino can't change after you bet, and locked into a sequence it can't alter or replay.
02Is the randomness genuinely random, or could it be rigged?
We re-implement the exact randomness algorithm and prove the outputs are unbiased and driven only by the disclosed inputs — nothing hidden, and nothing the operator can steer.
03Does the live game actually follow its own rules?
We rebuild the game and recompute every captured bet — outcome, payout, and intermediate steps, not just win or loss. All 61,155 recomputable bets must match; one fails the game.
04Is the house edge what the casino claims?
We prove the RTP from first principles — never the casino's own RTP figure — then confirm it across millions of simulated rounds and test whether favourable seeds were cherry-picked.
05Does the implementation maintain fairness under non-standard conditions?
We run a suite of adversarial integrity tests — nonce and seed handling, replay and isolation, payout enforcement — to confirm fairness holds under pressure.
An independent implementation
We rebuilt each game from its published specification in an independent implementation. Re-running an operator’s own code only establishes that the operator is internally consistent; rebuilding from the stated specification tests whether the live game matches what is publicly claimed.
Independent capture and review
Independent capture and review
Live bets were captured through anonymous accounts, every game’s audit was independently reviewed before finalisation, and every dataset, result, and line of verification code is published open-source. The complete framework, including per-section pass criteria, is documented on the methodology page.
Entropy architecture
Duel’s 11 games do not share one randomness construction. They split across three cryptographic architectures, because three game structures need three different ways of supplying unpredictable input.
Server Seed + Client Seed
Dice · Plinko · Mines · Keno · Beef · Blackjack · Video Poker · LimboHMAC-SHA256Construction and evidence
Why this construction
Eight of the nine single-player games feed a server seed and a player-supplied client seed straight into HMAC-SHA256 — the appropriate construction wherever one player faces the house, since the player contributes an input the operator cannot predict.
Construction. Server commits SHA-256(serverSeed) before client seed is supplied. Outcome = HMAC-SHA256(serverSeed, clientSeed:nonce[:cursor]), with rejection sampling wherever a value is reduced to a range for unbiased draws (Plinko's left/right is u mod 2, unbiased without it); Limbo maps its 32-bit value directly, with no reduction step.
Verified. 52,500 live bets reproduced · 1,065 commit-reveal cycles intact · client seed browser-generated and player-customisable.
What the checks proved
For the client-seed games, the audit confirmed the client seed is genuinely consumed — bets reproduce under auditor-supplied seeds and diverge under a tampered one.
Server Seed + drand Beacon
Crash · Castle RouletteHMAC-SHA256 + drandConstruction and evidence
Why this construction
The live-multiplayer games, Crash and Castle Roulette, cannot use a client seed: every player in a round shares one outcome, so no single player's seed can drive it. They bind a drand public beacon instead — external entropy no party can forge or withhold.
Construction. Live multiplayer rounds replace the client seed with a drand quicknet beacon round (publishes every 3 seconds, signature-verifiable). The server commits to each round's seed by its SHA-256 hash, and the outcome also depends on a beacon published after the bet.
Verified. 2,450 rounds reproduced from (serverSeed, drandRandomness) · bet timestamp preceded beacon publication on every captured round · every beacon value matches the public drand record for its round.
What the checks proved
For the drand games, it confirmed the beacon value genuinely enters the outcome computation — not merely that it is present — that every bet was recorded before its beacon round published, and that each beacon value matches the public drand record for its round.
Seed Pair → PCG32 Expansion
Groomer's Van (5×6 cluster-pays slot)HMAC-SHA256 → PCG32Construction and evidence
Why this construction
Groomer's Van, a cluster-pays slot, uses the same seed pair but consumes far more randomness per spin than one HMAC output provides, so an HMAC-SHA256 output seeds a PCG32 stream that expands it to the length the game needs.
Construction. The first 4 bytes of the HMAC-SHA256 output (the outcome index) seed PCG32 through SplitMix64; every cascade and free spin draws from its own stream derived from that index.
Verified. Byte-equal on 6,205 spins · 4,323 cascade rounds · 315,840 grid cells reproduced.
What the checks proved
For Groomer's Van, it confirmed that its PCG32 streams reproduce every recomputable spin and cascade from the seed pair.
Each architecture was rebuilt and verified independently against its own captured live bets.
Results
Exact live-bet reproduction, independently derived RTP and large-scale simulation.
What exact reproduction establishes
Every recomputable live bet matched
Across all 11 games, the independent implementation reproduced every one of the 61,155 recomputable live bets exactly, with no conditional divergence, rounding drift, or fallback path.
Intermediate states matched too
Parity was checked at the natural granularity of each game, not only the final win or loss: 33,194 Blackjack cards in dealing order across 6,000 hands, the full deck and final hand of all 5,400 Video Poker hands, and 315,840 Groomer's Van grid cells across 6,205 spins and 4,323 cascades.
No hidden inputs surfaced
Because every recomputable bet reproduces exactly from its disclosed inputs, the reconstruction surfaced no hidden entropy inputs, fallback paths, or conditional RNG branches in the audited implementations.
RTP validation
Derived independently, then simulated
RTP was established independently for each game — by closed-form derivation, exhaustive enumeration, or exact convolution, depending on the game — and corroborated by Monte Carlo totalling 266M rounds across the suite. Anti-circularity was enforced: every derivation and simulation operates from the published game specification, not from operator-supplied RTP figures or simulation output.
Closed-form: win_chance × multiplier = 0.999 for all targets at the base stake tier, verified algebraically.
Binomial B(rows, 0.5) against the payout table across all 27 risk/row configurations.
Survival counted over all 2²⁵ tile subsets — no binomial formula in the path — times Duel’s multiplier C(25,k)/C(25−m,k) × (1 − edge): exactly 1 − edge on all 300 (mines, reveals) cells, 99.9% at Duel’s 0.1% base edge.
Hypergeometric P(hits) against payout multipliers across all 40 configurations.
Survival × paid multiplier = 0.992 at all 61 difficulty and cash-out settings, confirmed exactly by counting all 2²⁰ death-point sets.
Independent recursive infinite-deck EV solver for Duel's rule set (S17, DAS, no surrender, no re-split), equal to an exact-rational oracle within 1e-12; run under the rules of two dated Wizard of Odds pages (which allow re-splits), the same engine reproduces their published figures.
Exhaustive enumeration of C(52,5) = 2,598,960 five-card hands, cross-validated against the published 9/6 Jacks or Better baseline.
Exact count of the uint32 values that reach each target among all 2³² outcomes, RTP(x) = x × count(x) / 2³², for every 0.01 target from 1.01× to 9,999.99×; every target from 10,000× up is scored at Duel's stated 9,999.999× cash-out cap. All 9,999,900 targets to 100,000× fall between 99.899768% and 99.900000%.
By construction: every color tier has count × multiplier = 48, so P × multiplier = 1 on all six, a 100% baseline RTP before any settlement edge.
Enumerated RTP by full 2³² enumeration — all 4.29 billion per-spin outcomes, run on both CPU and GPU, which agree to 6 decimal places — with the bonus session by exact convolution.
Exact count of the winning draws among all 2³² outcomes, RTP(T) = T × W(T) / 2³², for every legal target: all 9,999,900 from 1.01× to 100,000× fall between 99.897673% and 99.900000% at the base stake tier.
Every game converged within tolerance
Empirical RTP converged on the independently derived theoretical value within statistical tolerance for every game.
Explore the per-game results
The per-game breakdown — RNG model, live bet count, simulation volume, simulated RTP, and proven RTP — is presented in the Dashboard game validation matrix.
What this means
We recreated each game ourselves and checked it against real bets placed on the live site. Every result matched — so the live game isn't doing anything different from what we audited.
Findings
A fixed matrix of adversarial probes, with every finding disclosed.
The audit applied 160 fairness integrity checks across the 11 games — a fixed matrix of adversarial probes including replay attempts, parameter injection, parallel-request races, malformed payloads, and seed and nonce tampering, with game-specific extensions for surfaces such as Blackjack's hit actions and Groomer's Van's bonus-buy endpoint.
The checks group into five integrity categories
- Nonce integrity — monotonic, server-controlled, no gaps or duplicates.
- Seed commitment lifecycle — commit-reveal chain intact across rotations; revealed seeds match commitments.
- Outcome determinism & replay resistance — identical inputs → identical outcomes; bets cannot be replayed for duplicate payout.
- Round & player isolation — no cross-player or cross-round state leakage.
- Payout & parameter enforcement — payouts match published table; server cannot silently override bet parameters.
Four findings were recorded across Video Poker, Groomer’s Van and Crash. In each case, the API accepted malformed or out-of-bounds requests that stricter validation would reject.
Malformed payloads receive an HTTP 200 response, including game-specific request probes.
View probesAuto-cashout values above the theoretical maximum crash point are accepted.
View probesAll four were disclosed to Duel.com. Reproducible probes are published in Section 5 of each affected game audit.
No fairness failure was recorded
The cryptographic core, RNG, RTP derivation, and payout logic operated correctly in every case. No finding affects outcome determinism, RTP, or payout integrity, and no fairness failure was recorded.
What this means
The audit found four minor flags, all in how Duel's API handles malformed requests rather than in the games themselves. None affects the odds or the fairness of any bet — every result is still decided by the cryptographic process the audit verified. All four were reported to Duel.
What this audit establishes for players
For the 11 in-house games covered, this audit establishes what a player can rely on.
- A game's outcome is fixed by inputs the operator cannot change once a bet is placed.
- The randomness comes from an input the operator can't control — a seed the player provides, or a public randomness beacon — so the outcome is not generated from the operator's input alone.
- The house edge a player is shown is the figure independently derived from the game's published rules, not an estimate supplied by the operator.
- Every captured outcome was reproduced, bet for bet, by an independent implementation — every audited result is provably identical to the live game that produced it.
- Any single result can be recomputed by anyone from its public inputs. A player does not have to trust the operator, this audit, or ProvablyFair.org — only the math.
Across the 11 games, the audit ran a scored verification suite per game and 160 integrity tests in total — tens of thousands of live bets reproduced, and 266 million simulated rounds.
Fairness and the chance of winning
Certification confirms these games are provably fair and operate as specified. It does not change what they are: a provably fair game is one that behaves exactly as its published rules state — not one a player is assured of winning. This audit verifies the games are what they claim to be; it does not eliminate variance, and it does not guarantee a profitable session.
Independence and reproduction
An independently reviewed audit that anyone can inspect and re-run.
This audit was conducted independently. Findings are binding and were not negotiated with the operator; the audit outcome does not depend on the result. The complete framework and every per-game audit are published open-source, so the audit can be examined and re-run by any third party rather than taken on assertion.
Residual risks and assumptions
Certification reflects the integrity of the audited implementation as deployed during the review period. Three assumptions sit beneath that result:
Code-to-deployment parity. The production binary is assumed to match the audited implementation. Each per-game repository pins the exact commit the audit was performed against.
drand availability. Crash and Castle Roulette assume the drand quicknet beacon remains operational and signature-verifiable.
Operator-published parameters. Reel weights, payout tables, and rule sets are taken as published. Silent changes would invalidate the RTP and integrity guarantees.
This certification reflects the 11 in-house games as audited at the commit hashes recorded in each per-game repository. Material changes to a game's RNG construction, payout tables, or logic require revalidation; pinned commit hashes make any such change verifiable against the audited baseline. Certification is maintained through periodic spot checks and a full annual re-audit. Next scheduled review: December 2026, unannounced.
Each game has its own audit page carrying the complete methodology, datasets, simulation logs, and verifier code for that game. See the sidebar for individual reports, or the Dashboard for the cross-game validation matrix.
Inspect the evidence. Run the audit yourself.
Independent implementations, pinned commits, datasets and simulation artifacts.