Skip to main content
Audits
Duel.com/Executive Summary
DUEL.COM / AUDIT

Executive summary

Duel.com · Independent audit of 11 in-house games
Certified

All 11 games met the framework’s certification criteria.

PF-2026-DUEL
Certified June 8, 2026
Retested under Framework v1.1, October 2026

Duel.com certification

Certified

PF-2026-DUEL

11 in-house games met the certification criteria under Framework v1.1.

Certified by
ProvablyFair.org
Issued
June 8, 2026
Updated
October 2026
Next review
December 2026 · Unannounced
Audit period
March–May 2026 · Limbo added October 2026
Read the certification scope

PF-2026-DUEL · 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.

All 11 games met the certification criteriaFramework v1.1
11 / 11Games certified
61,175Live bets verified
266MSimulation rounds
160Integrity checks
Open source

Run these audits yourself

Open repositories

Every finding ships as code. Each game includes its verifier, captured bets and simulation harness.

Browse all 11 repositories

Independent 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:

Seed, Nonce & Determinism

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.

RNG & Entropy Model

The randomness is independently reimplemented and confirmed to derive from an input the operator can't control, then tested statistically for genuine randomness.

Verifier Parity

Every recomputable bet is replayed on the rebuild and must match the live result exactly, down to intermediate states.

RTP & Payout Logic

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.

Fairness Integrity Testing

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

Audited game logic99.2–100% RTPDerived from each game’s published mechanics at the base stake tier.

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.

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

OUTCOME GENERATIONDuel.comSeed InputsHMAC-SHA256 / drandDeterministic OutcomePayout AppliedLive Result RecordedINDEPENDENT VALIDATIONProvablyFair.orgLive Bets CapturedSeed & Determinism CheckSection 1RNG & Entropy ValidationSection 2Verifier ParitySection 3RTPSection 4IntegritySection 5Certified

ProvablyFair.org captures Duel's live outcomes and re-derives every one independently.

OUTCOME GENERATIONDuel.comINDEPENDENT VALIDATIONProvablyFair.orgSeed InputsHMAC-SHA256 / drandDeterministic OutcomePayout AppliedLive Result RecordedLive Bets CapturedSeed & DeterminismCheckSection 1RNG & EntropyValidationSection 2Verifier ParitySection 3RTPSection 4IntegritySection 5✓ Certified
Recorded outcomes are re-derived independently. Checks 1–5 correspond to the sections in each game’s audit.

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.

01

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.

02

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.

Read the complete audit framework ↗

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 · Limbo
8 games
HMAC-SHA256
Construction 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.

52,500 bets reproduced

Server Seed + drand Beacon

Crash · Castle Roulette
2 games
HMAC-SHA256 + drand
Construction 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.

2,450 rounds reproduced

Seed Pair → PCG32 Expansion

Groomer's Van (5×6 cluster-pays slot)
1 game
HMAC-SHA256 → PCG32
Construction 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.

6,205 spins · byte-equal

Each architecture was rebuilt and verified independently against its own captured live bets.

03

Results

Exact live-bet reproduction, independently derived RTP and large-scale simulation.

100%Live ↔ verifier parity
61,155 / 61,155 recomputable bets matchedIncluding intermediate card order, reel positions and cascade states.
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.

Published game specificationIndependent mathematical proof266M-round corroboration
GameIndependent mathematical method
Dice

Closed-form: win_chance × multiplier = 0.999 for all targets at the base stake tier, verified algebraically.

Dice
Plinko

Binomial B(rows, 0.5) against the payout table across all 27 risk/row configurations.

Plinko
Mines

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.

Mines
Keno

Hypergeometric P(hits) against payout multipliers across all 40 configurations.

Keno
Beef

Survival × paid multiplier = 0.992 at all 61 difficulty and cash-out settings, confirmed exactly by counting all 2²⁰ death-point sets.

Beef
Blackjack

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.

Blackjack
Video Poker

Exhaustive enumeration of C(52,5) = 2,598,960 five-card hands, cross-validated against the published 9/6 Jacks or Better baseline.

Video Poker
Crash

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

Crash
Castle Roulette

By construction: every color tier has count × multiplier = 48, so P × multiplier = 1 on all six, a 100% baseline RTP before any settlement edge.

Castle Roulette
Groomer's Van

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.

Groomer's Van
Limbo

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.

Limbo

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.

View the 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.

04

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.

160Integrity Checks
156Pass
4Findings
0Fairness Failures

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.

Game / countInput validation findingEvidence
Video Poker1 finding

Malformed payloads receive an HTTP 200 response.

View probes
Groomer's Van2 findings

Malformed payloads receive an HTTP 200 response, including game-specific request probes.

View probes
Crash1 finding

Auto-cashout values above the theoretical maximum crash point are accepted.

View probes

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

05

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.

06

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.

CertifiedJune 8, 2026Next scheduled reviewDecember 2026 · Unannounced

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.