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

Mines

Certified · Active

Independent verification, backed by open-source code.

PF-2026-DL04Audited April 2026 · Updated October 2026Apr 2026 · Updated Oct 2026Framework 1.1Release v1.2.2Original audit 6927bec, 4 June 2026, 4 Jun 2026
AUDIT RESULTPassedPROVABLY FAIR — Full Pass25 / 26 steps passed
PROVABLY FAIR — Full Pass
Live Bets Verified
7,050
Parity Rate
100%
Simulated RoundsSimulated RTP 99.904%
24M
Simulated RTP 99.904%
Proven RTP · base tier
99.9%
Base stake tier · 0.1% edge
25 / 26Verification steps passed

Verification pipeline

Real bets. Independently reproduced.

Placed anonymously at Duel.com. We rebuilt the game logic from scratch and matched all 7,050 recorded outcomes.

DUEL MINES$0.01 · 3 mines · 25 tiles · Cash out at 5
Safe revealMine
Bet #25753723Nonce 0 · Phase E1
50 real bets · Phase E1Bet 1 of 50
✓ Exact match
2.0155×

The casino result, reproduced.

Casino outcome
5 safe reveals · Cashed out
Our reproduction
5 safe reveals · Cashed out
Recorded payout
$0.0202
Open source

Run this audit yourself

Open GitHub ↗

The repo is the credential. Every scored step ships as code. Check out v1.2.2 and run npm test: nothing to install, 32 unit tests, 26 scored steps, 7,050 live bets re-verified, compared field by field with the committed results.

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

Duel.com Mines is provably fair: Full Pass under Framework 1.1. We placed 7,050 real bets across 151 seed records in April 2026 and reproduced every mine layout from its server seed, client seed and nonce, with our own implementation of the algorithm, written from our spec rather than Duel’s code. 25 of 26 scored steps pass; the one flag is a gap in our own capture, not a Duel issue. The theoretical RTP is 99.9% at Duel’s 0.1% base edge, and Duel’s stated edge matches the game’s real return on all 300 (mines, reveals) cells.

Results at a glance

Audit Verdict

CheckResultEvidence
Overall StatusPassPROVABLY FAIR — Full Pass · 25 of 26 scored steps pass · 1 capture flag · 0 hard fails · Framework 1.1, release v1.2.2
RTP VerifiedPassProven RTP 99.9% at Duel’s 0.1% base edge; the six full-board cash-outs, which start at 0.14–0.21%, return 99.79–99.86% · RTP claim rule: PASS, 0 of 300 cells beyond ±0.1 pp of the edge Duel’s game settings state · 99.904% simulated over 24M rounds
Live ↔︎ Verifier ParityPass100% — 7,050 / 7,050 mine layouts reproduced, 0 mismatches
Commit-Reveal SystemPass149 / 149 seed reveals hash to their commitments; 133 / 133 + 16 / 16 rotation links match. Consistency checks: the timing rests on our capture’s records
Nonce AuditCapture flagOne Phase E nonce has no captured round: limited by our capture script, not a Duel issue. 0 operator-side gaps, 0 reused nonces
Client SeedPassGenerated in the player’s browser and echoed, not assigned, by the server; a wrong client seed changes 646 / 650 sampled layouts, the 4 collisions within the combinatorial bound
RNG AnalysisPassOur RNG, written from the spec, reproduces every layout; Duel’s own verify code, run unmodified as a cross-check, agrees on 7,050 / 7,050; all 24 draw ranges exactly uniform in both
Payout LogicPass0 payout errors on all 7,050 rounds; 7,107 served multipliers match C(25,k)/C(25−m,k) (× 999/1000 when settled) to 1e-12 relative
Anti-CircularityPassSurvival counted over all 2^25 tile subsets; formula × counted probability = 1 − edge exactly on all 300 cells, with no casino-supplied probability
Fairness IntegrityPass16 fairness integrity tests — all 16 pass (includes one Mines-specific multi-step state test)
DeterminismPassSame inputs, same mine set: 7,050 / 7,050, including all 1,173 multi-reveal steps
Overall StatusPass
PROVABLY FAIR — Full Pass · 25 of 26 scored steps pass · 1 capture flag · 0 hard fails · Framework 1.1, release v1.2.2
RTP VerifiedPass
Proven RTP 99.9% at Duel’s 0.1% base edge; the six full-board cash-outs, which start at 0.14–0.21%, return 99.79–99.86% · RTP claim rule: PASS, 0 of 300 cells beyond ±0.1 pp of the edge Duel’s game settings state · 99.904% simulated over 24M rounds
Live ↔︎ Verifier ParityPass
100% — 7,050 / 7,050 mine layouts reproduced, 0 mismatches
Commit-Reveal SystemPass
149 / 149 seed reveals hash to their commitments; 133 / 133 + 16 / 16 rotation links match. Consistency checks: the timing rests on our capture’s records
Nonce AuditCapture flag
One Phase E nonce has no captured round: limited by our capture script, not a Duel issue. 0 operator-side gaps, 0 reused nonces
Client SeedPass
Generated in the player’s browser and echoed, not assigned, by the server; a wrong client seed changes 646 / 650 sampled layouts, the 4 collisions within the combinatorial bound
RNG AnalysisPass
Our RNG, written from the spec, reproduces every layout; Duel’s own verify code, run unmodified as a cross-check, agrees on 7,050 / 7,050; all 24 draw ranges exactly uniform in both
Payout LogicPass
0 payout errors on all 7,050 rounds; 7,107 served multipliers match C(25,k)/C(25−m,k) (× 999/1000 when settled) to 1e-12 relative
Anti-CircularityPass
Survival counted over all 2^25 tile subsets; formula × counted probability = 1 − edge exactly on all 300 cells, with no casino-supplied probability
Fairness IntegrityPass
16 fairness integrity tests — all 16 pass (includes one Mines-specific multi-step state test)
DeterminismPass
Same inputs, same mine set: 7,050 / 7,050, including all 1,173 multi-reveal steps
Audit scope & reference

What Was Audited

✓ Audited

  • Mine layouts reproduce from server seed, client seed, nonce and mine count: 7,050 / 7,050 live rounds
  • Every revealed server seed hashes to its commitment, and each rotation’s next-seed hash matches the epoch that follows (a consistency check)
  • Nonces start at 0 and are never reused; one Phase E nonce went unrecorded by our capture script
  • The client seed is generated in the browser, can be changed by the player, and changes the layout
  • Our RNG, written from the spec, matches every live layout; Duel’s own verify code agrees as a cross-check
  • The win condition holds on every captured round, and multipliers and payouts match the formula to 1e-12 relative, including multi-reveal cash-outs up to 5 reveals
  • Theoretical RTP from first principles on all 300 (mines, reveals) cells: exactly 1 − edge, 99.9% at the 0.1% base edge
  • Duel’s stated edge holds on all 300 cells within ±0.1 pp (RTP claim rule)
  • The mine set is fixed at round start and does not depend on which tiles are opened, or in what order
  • 24M simulated rounds and the cherry-pick tests find no sign of bias or seed selection

What Audit Excludes

  • Scaling house edge above the base stake tier (up to 1.0%) — explained from the config in S4.7
  • Max win
  • Rakeback, Zero Edge and promotions — 99.9% is the proven RTP; these are operator-side
  • 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 commitments of the hex-decoded server seed, rotation links, reveal on rotation (consistency); commitment timing from the capture’s records
Nonce AuditDeclared base 0, planned epoch sizes, no reuse; capture-origin gaps declared and flagged
Client SeedBrowser origin, server echo, influence on the layout, empty-seed control
RNG AnalysisSpec-built HMAC-SHA256 backward Fisher-Yates, draw-bias bound for all 24 ranges, rejection census
Live ParityAll 7,050 rounds recomputed; ProvablyFair.org verifiers and Duel’s verify code run on the same rounds
Payout LogicMultipliers and payouts against the exact formula to 1e-12 relative, depths 1–5, win condition from our recomputed layout, $10 vs $0.01
RTP ValidationTheoretical RTP from counted survival, RTP claim rule against Duel’s game settings, stake tiers from the config, 24M-round simulation, cherry-pick tests
Fairness IntegrityStandard integrity matrix — 16 tests across commit-reveal, determinism, payout, isolation, and parameter enforcement
What Audit Guarantees
  • At the base stake tier, outcomes reproduce from the recorded inputs: 7,050 / 7,050
  • Every revealed server seed is the one behind its published hash
  • Our RNG, written from the spec, and Duel’s own verify code return the served mine set on every captured round
  • In our RNG and in Duel’s published code, every draw range is exactly uniform: each swap index is equally likely
  • Payouts equal stake × the formula multiplier on every captured round, to 1e-12 relative
  • Theoretical RTP is exactly 1 − edge on every (mines, reveals) cell, without casino-supplied probabilities: 99.9% at the 0.1% base edge
  • Duel’s stated edge matches the game’s real return on all 300 cells (RTP claim rule PASS)
  • The mine set is fixed at round start and independent of which tile the player opens
  • All 16 fairness integrity tests passed at audit time, including the Mines-specific multi-step state integrity test

References

Mines — Game Rules7 sections▶

Mines is a grid-based reveal game: choose how many mines hide on a 5×5 board, then flip tiles one at a time. Every safe reveal grows the payout; hit a mine and the round ends.

Game Rules

Mines is played on a 5×5 board of 25 tiles. Before each round the player chooses a mine count between 1 and 24. The mines are placed server-side by a backward Fisher-Yates shuffle driven by HMAC-SHA256. The player then reveals tiles one at a time: each safe reveal grows the multiplier; hitting a mine ends the round and loses the stake. The player may cash out after any safe reveal. More mines means a higher reward per safe reveal and a higher chance of hitting one.

How to Play

1. Choose mine count — Select between 1 and 24 mines. More mines means higher reward per safe reveal but a higher chance of hitting a mine.
2. Enter bet amount — Choose how much to wager.
3. Reveal tiles — Click tiles one at a time. Each safe reveal grows the running multiplier.
4. Cash out or continue — After any safe reveal, choose to cash out at the current multiplier or push on for more.
5. Outcome — If you hit a mine, the round ends and the bet is lost. If you cash out, payout = bet × multiplier at the current reveal count.

Mine positions are determined cryptographically the moment the bet is placed. The visible tiles are cosmetic — the mine set is fixed before you click anything.
Win Conditions

The win condition in Mines depends on whether the revealed tile is in the mine set.

3 columns
OutcomeConditionExample (mines=3, k=5)
Safe revealRevealed tile is not in mine setMultiplier grows; player may cash out or continue
Cash outPlayer stops after k safe revealsk=5 → stake × 2.0155× (2.0175× before the edge)
LossRevealed tile is in mine setRound ends, bet is lost
Because every hit of a mine ends the round, the payout structure has no zero-hit consolation — either you cash out with a multiplier, or you lose the bet.
Risk vs Reward

The core mechanic of Mines is the tradeoff between mine count and safe-reveal risk.

  • Mine count controls risk per reveal — more mines means fewer safe tiles, faster multiplier growth and a higher chance the next reveal ends the round
  • Reveal count controls the total multiplier — each further safe reveal multiplies the running payout by (25 − k) / (25 − m − k)
  • RTP is set by the edge, not the mine count — at the same edge every mine count and reveal depth has the same theoretical RTP: 99.9% at Duel’s 0.1% base edge
Parameters
3 columns
ParameterValueNotes
Grid Size25 tiles (5×5)Fixed; tiles numbered 0–24
Mine Count1–24Player-selected; sets the risk and the multiplier curve
Payout Cells300Every (mines, reveals) pair, reveals 1 to 25 − mines
House Edge0.1% base tierDuel’s settings raise it in 0.01% steps up to 1.0% above $25,000 potential profit (from the config, not tested)
Theoretical RTP99.9%At the 0.1% base edge; the six full-board cash-outs (10–15 mines) start at 0.14–0.21% and return 99.79–99.86%
Max Profit$250,000 per roundDuel’s setting; outside our testing
RNG AlgorithmHMAC-SHA256Backward Fisher-Yates with exact rejection sampling; key = hex-decoded server seed
Seed Formats

Every Mines bet uses three cryptographic inputs to generate the mine layout.

4 columns
Seed TypeFormatExamplePurpose
Server Seed64-char hex (32 bytes)01b20487103f970a…Casino-provided randomness
Client SeedText string (by default 16 letters, digits or _; you can set your own)NxcarOV28bkerHJkPlayer-contributed entropy
NonceInteger ≥ 06Per-round counter within the active seed pair
The server seed is committed as serverSeedHashed (SHA-256 of the raw hex bytes) before play and revealed only on seed rotation. The HMAC key is the hex-decoded bytes of the server seed, not its UTF-8 text.
Multiplier & Payout

The payout multiplier after k safe reveals with m mines is the combinatorial ratio times the edge factor, 0.999 at Duel’s base tier.

multiplier(k, m) = C(25, k) / C(25−m, k) × (1 − edge)    edge = 0.001 at the base tier
4 columns
Reveals (k)Mines (m)Raw multiplierWith 0.1% edge
111.0417×1.0406×
131.1364×1.1352×
151.2500×1.2488×
352.0175×2.0155×
532.0175×2.0155×
1035.0549×5.0499×
API field quirk — Duel’s API returns multiplier as the raw ratio C(25,k)/C(25−m,k) without the edge, and no_house_edge_multiplier as the payout multiplier with the edge applied. A win credits amount × no_house_edge_multiplier. The field labelled no_house_edge_multiplier is the one that includes the house edge; we verify against it throughout.
Why Provably Fair Matters▶

Traditional online casinos ask you to trust them. Provably fair cryptography replaces that trust with independently verifiable proof. Every bet you place can be reconstructed from three public inputs — the server seed, your client seed, and the nonce — and the result you see should match the result anyone else can compute from those inputs.

  • No silent seed swap — the server seed is committed (SHA-256 hashed) and shown before you play. Save that hash: a seed revealed later either matches it or it does not.
  • Your seed matters — the client seed comes from your browser, not the casino. Changing it changes the outcome for the same server seed and nonce, which shows your input is part of the computation.
  • Verifiable by anyone — once the server seed is revealed on rotation, anyone with the seed pair and nonce can recompute the result with a few lines of code.
  • Mathematically bounded — the multiplier formula fixes the payout. We prove from first principles that win chance × payout multiplier is exactly 1 − edge for every configuration: 99.9% at Duel’s 0.1% base edge.
High-Level Overview7 sections▶

This section walks through how a Mines bet moves through the system end-to-end — from the server seed commitment, through the bet and reveal flow, to the post-rotation verification step that closes the loop.

Checklist Reference

Commit-Reveal

2 columns
CheckWhat it shows
SHA-256 of the revealed seed matches its commitmentThe revealed seed is the one behind that hash
Each epoch’s hash equals the previous rotation’s next-seed hashThe seed records form one consistent chain
Commitment recorded before the epoch’s first betTiming, from our capture’s timestamps

Seed System

2 columns
CheckWhat it shows
Nonces start at 0 and are never reusedNo nonce served twice; gaps are declared and flagged
Single client seed per epochThe client seed is not swapped mid-epoch
Client seed echoed, not assignedThe seed you set is the seed used

RNG & Parity

2 columns
CheckWhat it shows
Mine positions recompute from seeds + nonceThe outcome is deterministic and verifiable
Our spec-built RNG and Duel’s code agree on every roundNo hidden inputs to the RNG
Mine set invariant across the reveal sequenceThe layout is fixed at round start

Payout & RTP

2 columns
CheckWhat it shows
Multiplier matches C(25,k)/C(25−m,k) × 0.999Payouts follow the fair-odds formula, less the 0.1% edge
amount_won = amount × no_house_edge_multiplierPayout arithmetic holds to 1e-12 relative
Counted survival × multiplier = 1 − edge on all 300 cellsRTP is 99.9% at the base edge by construction, not observation

Integrity

2 columns
CheckWhat it shows
Wrong client seed produces different minesThe client seed genuinely influences the outcome
Bet size does not influence the outcome$10 and $0.01 bets follow the same formula
Cherry-pick tests on 130 casino seedsNo sign of seed selection
High-Level Flow

A Mines round runs through five stages — from the casino committing to a server seed before you play, through the bet and reveals, to the post-rotation verification that anyone can run.

1. Commit — Server generates server seed, publishes SHA-256 hash as serverSeedHashed. Player sees only the hash.
2. Seed pair activated — Client seed is browser-generated (or player-set). Nonce starts at 0. Next server seed is pre-committed.
3. Bet — Player selects mine count and bet amount. Platform computes mine positions via HMAC-SHA256 backward Fisher-Yates using the active seed pair + nonce.
4. Reveals — Player reveals tiles one at a time. Multiplier grows per safe reveal. Player may cash out at any point.
5. Rotate — On client-seed change or manual rotation, the active server seed is revealed. The next-committed seed becomes active.
6. Verify — Anyone with serverSeed, clientSeed, nonce, and mine count can recompute the exact mine set.

High-Level Flow — illustrated flow
Provably Fair Model

Mines is a commit-reveal provably fair game. The casino commits to a server seed by publishing its SHA-256 hash before any bet is placed. When the seed is rotated, the casino reveals it. Anyone can then check two things: that the revealed seed hashes to the commitment, and that every bet in that epoch recomputes from the seed pair and nonce. One trust remains: the casino chooses each server seed before committing to it, and no public randomness beacon is mixed in. Our cherry-pick tests look for signs of that choice and find none.

Commit-Reveal Model

Mines uses a four-phase commit-reveal cycle. Each phase has a single, well-defined purpose, and every phase produces artefacts that can be verified after the fact.

Commit-Reveal Model — illustrated flow

Commit phase
Server generates a 32-byte server seed, computes SHA-256(hex_bytes(serverSeed)) and shows it as serverSeedHashed. The seed stays secret. The hash of the next seed is shown too.

Bet phase
Bets use the active seed pair. Each layout is a backward Fisher-Yates shuffle of the 25 tiles, draw i keyed by HMAC-SHA256(key = hex_bytes(serverSeed), message = clientSeed:nonce:i). The nonce increments per bet.

Reveal phase
The player rotates the seed pair. The retired server seed appears in the transaction detail of every bet played under it, and the pre-committed next hash becomes the active serverSeedHashed.

Verify phase
Anyone with the seed pair and nonce reruns HMAC-SHA256 + Fisher-Yates and compares the mine set with the live result. A hash match shows the revealed seed is the one behind the hash; the hash you saved before betting shows it was fixed in advance.

Player-Controlled Client Seed

The client seed is the player's lever into the RNG. It is generated in the browser (not the server) and can be replaced at any time, which forces a seed rotation.

  • Browser-generated — the default client seed is drawn in your browser with crypto.getRandomValues
  • Player-editable — you can set any value; changing the client seed rotates the seed pair and reveals the active server seed
  • Materially influences the outcome — a wrong client seed changes the layout on 646 of 650 sampled bets; the 4 collisions are what 25 possible layouts at 1 and 24 mines predict
  • Echoed, not assigned — the server returns the client seed you submit; each epoch’s server-seed hash was shown before the rotation that set its client seed (by our capture’s records)
Nonce Lifecycle

The nonce is a per-round counter within the active seed pair. It starts at 0, increments by 1 per bet, and resets only on seed rotation. The nonce is reused across all reveals in a single round — the mine set is computed once, at bet time, and is unchanged by subsequent reveals.

  • Starts at 0 on every new seed pair
  • Increments by one per round and is never reused within an epoch
  • Resets on rotation — every rotation starts a fresh sequence at 0
  • Shared across reveals — every reveal in a round uses the same nonce; the mine set is fixed when the round starts
nonce lifecycle · Illustrative
// Per seed pair, nonce sequence://   bet 1 → nonce=0//   bet 2 → nonce=1//   bet 3 → nonce=2//   ...// On client seed change://   serverSeed revealed, new pair activated, nonce resets to 0
Determinism Guarantee

Given serverSeed, clientSeed, nonce, and mineCount, the mine set is fully determined — there is no randomness, no hidden input, and no dependence on bet amount, timestamp, or any other variable. The pipeline is:

mines pipeline (docs/ALGORITHM.md §2) · Canonical
// Inputs: serverSeed (hex), clientSeed (string), nonce (int), mineCount (1–24) key = hexDecode(serverSeed)           // 32 bytes, NOT the UTF-8 texta   = [0, 1, ..., 24] for i from 0 to 23:                   // draw i, cursor = i    r      = 25 - i                   // 25, 24, ..., 2    LIMIT  = floor(2^32 / r) * r    digest = HMAC-SHA256(key, clientSeed + ":" + nonce + ":" + i)    for each 4-byte chunk of digest, first to last:        v = the chunk as an unsigned 32-bit big-endian integer        if v < LIMIT: j = v mod r; stop    swap a[r - 1], a[j] mines = a[0..mineCount-1] sorted
Technical Glossary7 categories▶

Terms and definitions used throughout this audit report, grouped by category.

Core Concepts
2 columns
TermDefinition
Provably FairA system where every game outcome can be independently verified from public cryptographic inputs, without trusting the operator.
Commit-RevealA two-phase protocol: a party publishes a hash of a secret before play (commit), then reveals the secret afterward (reveal). A match shows the revealed secret is the one behind the hash; a copy of the hash saved in advance shows it was fixed before play.
DeterminismA property where the same inputs always produce the same output. Mines is deterministic: (serverSeed, clientSeed, nonce, mineCount) uniquely determines the mine set.
EpochThe set of bets placed under a single active seed pair, from activation to rotation. Also called a seed pair lifecycle.
Framework 1.1The ProvablyFair.org audit framework this report is certified under: scored steps with Pass, capture flag, operator flag or hard fail; the RTP claim rule; game-profile coverage; the standard S5 fairness-integrity matrix.
Capture flagA flag caused by our own capture, not by the operator — here, one Phase E nonce with no captured round. Disclosed on every run, neutral to the verdict.
Seed System
2 columns
TermDefinition
Server SeedA 32-byte random value generated by the casino. Represented as a 64-character hex string. Used as the HMAC key (hex-decoded).
Server Seed HashedSHA-256(hex_bytes(serverSeed)). The commitment published before play.
Client SeedA player-controlled string, generated in the browser by default. Part of the HMAC message.
NonceA per-round counter within the active seed pair. Starts at 0, increments per bet, shared across all reveals in a single round, resets on seed rotation.
CursorThe draw index in the HMAC message, 0–23: draw i reads its own digest of clientSeed:nonce:i. The spec leaves open what happens if all eight chunks of a digest are rejected (it never happened).
Seed PairThe combination of one server seed and one client seed. A seed pair defines an epoch.
Next Server Seed HashA pre-commitment to the server seed that will become active after the current one is rotated. Locks the future chain in advance.
Cryptographic Functions
2 columns
TermDefinition
SHA-256A 256-bit cryptographic hash function. Used here for server seed commitment: SHA-256(hex_bytes(serverSeed)) = serverSeedHashed.
HMAC-SHA256Hash-based message authentication code built on SHA-256. Takes a key and a message, returns a 256-bit (64-hex-char) digest. Used here for mine position generation.
HMAC-SHA256 Backward Fisher-YatesThe full RNG pipeline: HMAC-SHA256 produces the 4-byte random chunks; backward Fisher-Yates uses those chunks to shuffle the 25-tile grid. Mines-specific implementation.
Rejection SamplingBias-free sampling: a 4-byte chunk v is accepted only if v < floor(2^32 / r) · r, then j = v mod r. The accepted window is a whole number of ranges, so every index in r is exactly equally likely.
Verification Terms
2 columns
TermDefinition
ParityAgreement between the live game's reported outcome and an independent recomputation from the same inputs. 100% parity means zero mismatches.
RecomputationRunning the audit's standalone RNG implementation on captured seed triples and comparing the output to the live API response.
Anti-Circularity ProofDeriving RTP from first principles, with no casino-supplied probability: survival is counted over all 2^25 tile subsets, and the formula × the counted probability equals 1 − edge exactly on every cell.
Cherry-Pick Detection (Pass 2)Statistical tests over every revealed casino seed (10,000 nonces each) that look for seeds chosen to be unfavourable, including the return of the configurations each epoch actually served (Test C).
RTP Claim RuleRTP-CLAIM 1.2.0: every setting is held to the RTP the casino publishes for it, within ±0.1 pp. A house-side miss is the verdict RTP FIGURE OVERSTATED (exit 5), never a fairness fail.
Base Stake TierThe lowest stake tier of each cell in Duel’s settings, from a $0 stake: the 0.1% edge, up to $25,000 potential profit at the current tile, on 294 of 300 cells; 0.14–0.21% on the six full-board cash-outs. Every guarantee on this page applies there.
Game Mechanics
2 columns
TermDefinition
Mine CountThe number of mines placed on the 25-tile grid for a given round. Player-selected, range 1–24.
RevealThe act of clicking a tile. A safe reveal grows the multiplier; a mine reveal ends the round.
Multiplier ChainThe running multipliers as a player reveals tiles: after k safe reveals, C(25,k) / C(25−m,k), paid × (1 − edge) at cash-out.
Cash-OutStopping after k safe reveals and collecting amount × mₖ. Only available after at least one safe reveal.
Mine Set InvarianceThe property that the mine set is fixed at round start and does not change based on which tiles the player reveals, or in what order.
Combinatorial IdentityP(survive k) × payoutMult(k, m) = (C(25−m, k) / C(25, k)) × (C(25, k) / C(25−m, k) × (1 − edge)) = 1 − edge for all valid k, m: 0.999 at the base edge.
Scaling EdgeDuel’s per-bet edge, tiered by potential profit at the current tile: 0.1% up to $25,000, rising in 0.01% steps to 1.0% at Duel’s $250,000 maximum profit. Read from Duel’s settings; not tested.
Audit Terms
2 columns
TermDefinition
Fairness Integrity (FI) MatrixOur standard test matrix, covering nonce integrity, seed commitment, outcome determinism, player isolation and payout integrity, with a Mines-specific game-state test. For Mines: 16 tests, 7 of them live API probes whose evidence is kept in our private archive. Documented in S5.
Chi-Squared TestA goodness-of-fit test comparing observed distributions (e.g., mine positions, win counts) to theoretical expectations. Used with Bonferroni correction where multiple configurations are tested.
Bonferroni CorrectionA multiple-comparison adjustment: when testing N hypotheses at significance α, the per-test threshold is α/N. Prevents false positives from mass testing.
Point-in-Time AuditAn audit verdict that applies to the code and configuration in force at the audit date. Subsequent changes are outside scope unless re-certified.
Game ProfileThe framework’s per-game check list (Mines profile 1.0.2, checks MINES-01 to MINES-30). Each check is covered by a scored step, a package check, or marked n/a with a reason.
Data Formats
2 columns
TermDefinition
mines-master-6500bets.jsonPrimary capture dataset. 6,500 auto-bet rounds across Phases A–D, each opening tile 0. SHA-256 pinned in S1 and S7.
mines-phaseE-550bets.jsonMulti-reveal and cash-out dataset. 550 rounds across 5 sub-phases (E1–E5), up to 5 reveals and varied reveal positions. SHA-256 pinned in S1 and S7.
verification-results.jsonOutput of the 26-step verification suite: per-step status, detail, profile checks and informational items.
simulation-results.jsonOutput of the 24-configuration × 1M-round simulation. Contains Pass 1 (fresh seeds, RTP + chi²) and Pass 2 (casino seeds, cherry-pick detection).
rtp-claim-table.jsonAll 300 (mines, cash-out) cells against the edge Duel’s game settings state for them, under the RTP claim rule.
01

Seed, Nonce & Determinism

Can the casino change your outcome after you bet?

Every Mines round is generated from three inputs: server seed, client seed and nonce. Duel shows a SHA-256 hash of the server seed before you bet and reveals the seed when you rotate. Every revealed seed in the capture hashes to its commitment, and every rotation links to the next. Those are consistency checks; when each hash was shown rests on our capture’s records, which put every commitment before its epoch’s first bet. Save the hash yourself and the timing is yours to check.

Commit-Reveal Consistency

149 / 149seed reveals matched

What we verified

  • Every seed reveal hashes to its commitment: 149 / 149 across both datasets
  • Each epoch’s hash equals the next-seed hash shown at the rotation before it: 133 / 133 primary and 16 / 16 Phase E links
  • Our capture recorded every commitment before its epoch’s first bet: 142 / 142 bet-bearing epochs
  • Nonces start at 0 in every epoch and are never reused; one Phase E nonce went unrecorded by our capture script
  • The client seed is generated in your browser and echoed, not assigned, by the server
  • A wrong client seed changes the layout on 646 / 650 sampled bets; the 4 collisions are what 25 possible layouts predict
  • Same inputs, same mine set: 7,050 / 7,050

What this means for you

  • If you save the hash before you bet, a swapped seed cannot match it
  • Your client seed is a real input: change it and the mines move
  • Each bet gets its own nonce, so no two bets in an epoch share inputs
  • Any bet can be rechecked from its disclosed inputs, months later
  • Duel still picks each server seed before committing to it; our tests find no sign of selection (S4)
149 / 149seed reveals matched
  • Every seed reveal hashes to its commitment: 149 / 149 across both datasets
  • Each epoch’s hash equals the next-seed hash shown at the rotation before it: 133 / 133 primary and 16 / 16 Phase E links
  • Our capture recorded every commitment before its epoch’s first bet: 142 / 142 bet-bearing epochs
  • Nonces start at 0 in every epoch and are never reused; one Phase E nonce went unrecorded by our capture script
  • The client seed is generated in your browser and echoed, not assigned, by the server
  • A wrong client seed changes the layout on 646 / 650 sampled bets; the 4 collisions are what 25 possible layouts predict
  • Same inputs, same mine set: 7,050 / 7,050
HMAC-SHA256 Pipeline — Seed inputs through backward Fisher-Yates to mine positions — illustrated flow
CheckResultEvidence
Seed hash integrityPass149 / 149 seed reveals hash to their commitment (SHA-256 of the hex-decoded bytes); 0 mismatches
Commitment linkagePass133 / 133 primary and 16 / 16 Phase E rotation links recomputed from the raw hashes; both pre-capture anchors verified
Commitment timingInfoOur capture recorded each commitment before its epoch’s first bet in 142 / 142 epochs. Reported from the capture’s timestamps, not scored
Hash consistency within epochPassEvery bet under each of the 130 bet-bearing rotation records carries that record’s hash and client seed; 0 orphan bets
Nonce auditCapture flagOne Phase E nonce has no captured round: limited by our capture script, not a Duel issue. 130 primary epochs run 0–49; 0 operator-side gaps, 0 reused nonces
Client seed originPassDrawn in the browser with crypto.getRandomValues; the ten Phase D seeds come back in our capture’s own form
Client seed influencePass646 / 650 layouts change under a wrong client seed; 4 collisions within the combinatorial bound (expected 5.97, bound 18.95); empty-seed control 56 / 6,500 (bound 98.08)
Deterministic outputPassSame (server seed, client seed, nonce, mine count) → same mine set: 7,050 / 7,050
Seed hash integrityPass
149 / 149 seed reveals hash to their commitment (SHA-256 of the hex-decoded bytes); 0 mismatches
Commitment linkagePass
133 / 133 primary and 16 / 16 Phase E rotation links recomputed from the raw hashes; both pre-capture anchors verified
Commitment timingInfo
Our capture recorded each commitment before its epoch’s first bet in 142 / 142 epochs. Reported from the capture’s timestamps, not scored
Hash consistency within epochPass
Every bet under each of the 130 bet-bearing rotation records carries that record’s hash and client seed; 0 orphan bets
Nonce auditCapture flag
One Phase E nonce has no captured round: limited by our capture script, not a Duel issue. 130 primary epochs run 0–49; 0 operator-side gaps, 0 reused nonces
Client seed originPass
Drawn in the browser with crypto.getRandomValues; the ten Phase D seeds come back in our capture’s own form
Client seed influencePass
646 / 650 layouts change under a wrong client seed; 4 collisions within the combinatorial bound (expected 5.97, bound 18.95); empty-seed control 56 / 6,500 (bound 98.08)
Deterministic outputPass
Same (server seed, client seed, nonce, mine count) → same mine set: 7,050 / 7,050
✓  Commit-reveal consistent

All 149 seed reveals hash to their commitments and every rotation link matches; our capture’s records put each commitment before its epoch’s first bet. Nonces start at 0 and never repeat. The one Phase E nonce with no captured round is a gap in our capture, not a Duel issue. The client seed is a genuine input.

How It Works — Seed, Nonce & Determinism8 sections
1.1Server Seed Commitment

Before any bet in an epoch, Duel shows the SHA-256 hash of the active server seed. The seed is a 64-character hex string (32 bytes), and the commitment is SHA-256(hexDecode(serverSeed)) — the hash of the bytes, not of the text. When you rotate, the seed is revealed and anyone can hash it. A match shows the revealed seed is the one behind the hash.

Server Seed Commitment — illustrated flow
src/rng.ts · verifyHash · Verified
export function verifyHash(serverSeed: string, serverSeedHashed: string): boolean {  if (typeof serverSeedHashed !== "string" || !/^[0-9a-fA-F]{64}$/.test(serverSeedHashed)) return false;  let key: Buffer;  try {    key = decodeServerSeed(serverSeed);  } catch {    return false;  }  const commitment = createHash("sha256").update(key).digest("hex");  return commitment === serverSeedHashed.toLowerCase();}
Result: 149 / 149 seed reveals match their commitments: primary 130 plus the 3 reveals that open Phases B, C and D; Phase E 12 + 4. 0 unrevealed, 0 mismatches.

Real Example from Live Data:

mines-master-6500bets.json · bet seed block
// Seed block recorded with the bet (round 25075415){  "serverSeedHashed": "2d3a2c76d354a0a859d84b9fe8183e8f48cf6e973e0264947af3f95c1505e72b",  "clientSeed": "NxcarOV28bkerHJk",  "nonce": 6} // After the rotation, the transaction detail revealed://   serverSeed = "01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3"

Verification:

verify-seed.js · Verified
const crypto = require('crypto'); const serverSeed = "01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3"; const hashedServerSeed = crypto  .createHash("sha256")  .update(Buffer.from(serverSeed, 'hex'))  .digest("hex"); console.log(hashedServerSeed);// Output: 2d3a2c76d354a0a859d84b9fe8183e8f48cf6e973e0264947af3f95c1505e72b ✅
1.2Commitment Linkage (Next-Seed Promotion)

Every rotation shows the hash of the seed it will activate next. Step 2 recomputes each link from the raw fields: the nextServerSeedHash of one rotation record must equal the serverSeedHashed of the next, and each capture’s first epoch must equal the hash standing as "next" before capture began. The capture script’s own match flags are cross-checked, never trusted. This is a consistency check: it shows the seed records form one chain.

tests/steps/commitment.ts · Step 2 · 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 — the chain does not link epoch ${i} to epoch ${i + 1}`);}
Result: 133 / 133 primary and 16 / 16 Phase E links match, both pre-capture anchors verified, and the capture script’s own match flags agree with the recomputation on all 151 records.
1.3Commitment Timing

When each hash was shown rests on our capture’s records. The capture stored each epoch’s active hash from the rotation response that opened it, and that rotation record is timestamped before the epoch’s first bet: 130 / 130 primary and 12 / 12 Phase E epochs. The same hash had already been recorded as "next" at the rotation before. It is reported from the capture’s records, not scored.

A player does not need our records: save the hash before your first bet on a seed, and the revealed seed either matches your copy or it does not (S6).

Why it matters: A seed and hash made after settlement would also pass the hash and link checks. What fixes the order is a copy of the hash saved before the bets — ours, from the capture, or yours.
1.4Hash Consistency Within Epoch

Step 3 groups bets by the capture timeline — a bet belongs to the last rotation record before it — and requires every bet in the window to carry that record’s committed hash and client seed. A bet’s hash and client seed are the capture’s copies of its rotation response, so this binds the capture’s records to each other; that each layout came from the epoch’s seed is Step 5’s recomputation.

tests/steps/commitment.ts · Step 3 · 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: 130 bet-bearing rotation records, every bet carrying its record’s hash and client seed; the 4 records without bets are end-of-phase rotations; 0 orphan bets.
1.5Client Seed Origin & Control

Duel’s default client seed is drawn in your browser with crypto.getRandomValues and submitted with the rotation request. The server echoes it and does not assign it: the ten Phase D seeds come back in our capture’s own form, each decoding to the capture’s clock 0.416–0.463 s before its rotation. You can rotate to any client seed at any time, and changing it changes the layout. Our capture used its own generators — Math.random() for Phases A–C, a timestamp for Phase D — and every layout still recomputes.

  • EveJlkDtA24dfvBr
  • NxcarOV28bkerHJk
  • datWCpUusET02jWw
  • QfpCgsRdMX8w1CZb
  • DZINIfo9nv2pxGzu
Result: 142 distinct client seeds across the 142 bet-bearing epochs. By the capture’s records, each epoch’s server-seed hash was shown before the rotation that set its client seed. Evidence: client-seed-origin.png, mines-master-6500bets.json, mines-phaseE-550bets.json
1.6Nonce Audit

The nonce starts at 0 on every new seed pair and increments by one per round; every reveal in a round shares it. Our capture rotated after every 50 bets — its own interval, not a Duel rule. Step 4 holds every bet-bearing epoch in both datasets to a declared base of 0, its planned size and no reuse. A gap has an origin: one in our register of declared capture gaps is a capture flag; any other gap is a hard fail.

Nonce Audit — illustrated flow
tests/steps/commitment.ts · Step 4 · Verified
for (const missedNonce of missing) {  const reg = declared.find(g => g.nonce === missedNonce);  if (reg) {    captureOriginGaps++;    registerHits.add(reg.idx);    captureGaps.push(`${tag} nonce ${missedNonce} (${reg.dl})`);  } else {    operatorGaps++;    hardFailures.push(`${tag}: nonce ${missedNonce} missing and NOT a declared capture retry — operator-side gap`);  }  // …const s4Status = hardFailures.length > 0 ? 'FAIL' : captureOriginGaps > 0 ? 'FLAG' : 'PASS';
Capture flag: 130 primary epochs run 0–49 with no gap and no reuse, and 12 Phase E epochs match their planned sizes. One nonce — 12, in the Phase E epoch under server-seed hash d6ff34bb… — has no captured round. The capture clock jumps 30 s across it and the reveal pattern due there was served 7 times instead of 8, so the evidence points to a capture request that failed after the round was placed. Limited by our capture script, not a Duel issue. 0 operator-side gaps, 0 reused nonces; the revealed seed yields a well-formed layout at nonce 12, and what Duel served there is not known.
1.7Deterministic Mapping

Given the server seed, client seed, nonce and mine count, the mine set is fully determined. The 32 hex-decoded bytes of the server seed are the HMAC key. Draw i (0–23) reads its own digest of clientSeed:nonce:i, takes the first 4-byte chunk below floor(2^32 / r) · r for r = 25 − i, and swaps tile r − 1 with tile v mod r. The first mineCount tiles, sorted, are the mines.

Deterministic Mapping — illustrated flow
src/rng.ts · computeMinePositions · Verified
export function computeMinePositions(  serverSeed: string,  clientSeed: string,  nonce: number,  mineCount: number,  gridSize: number = GRID_SIZE,): number[] {  return computeMinePositionsFromBuffer(decodeServerSeed(serverSeed), clientSeed, nonce, mineCount, gridSize);}
Result: All 7,050 rounds recompute to the served mines_positions. Zero set mismatches. No external entropy enters the layout.

Real Bet Verified:

mines-master-6500bets.json · Round #25075415 · Verified
// Source: data/mines-master-6500bets.json// Round ID: 25075415 (Phase A, mines=3, nonce=6) {  "serverSeed": "01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3",  "serverSeedHashed": "2d3a2c76d354a0a859d84b9fe8183e8f48cf6e973e0264947af3f95c1505e72b",  "clientSeed": "NxcarOV28bkerHJk",  "nonce": 6,  "mines_count": 3,  "revealed_positions": [0],  "mines_positions": [5, 16, 21],  "multiplier": "1.136363636363636364",  "no_house_edge_multiplier": "1.135227272727272728",  "amount_won": "0.011352272727272727"}

Verification:

verify-mines.js · Verified
// computeMinePositions("01b20487…", "NxcarOV28bkerHJk", 6, 3) // 24 draws, i = 0 … 23, r = 25 − i//   digest_i = HMAC-SHA256(hexDecode(serverSeed), "NxcarOV28bkerHJk:6:" + i)//   first chunk v < floor(2^32 / r) · r  →  j = v mod r; swap tiles[r − 1] ↔ tiles[j] // Mine set: {5, 16, 21} ✅// Tile 0 opened (not a mine) → win ✅// Multiplier (mines=3, k=1): 25 / (25−3) = 25/22 = 1.1364× ✅// Payout multiplier: 25/22 × 0.999 = 1.135227× ✅// Payout: 0.01 × 1.135227 = 0.011352 ✅
1.8Client Seed Influence

Step 6 recomputes 5 bets from each of the 130 revealed epochs with a wrong client seed. With m mines there are only C(25, m) layouts, so two seeds must sometimes agree however good the RNG is: at 1 and 24 mines there are just 25. The collision count is held to its combinatorial expectation plus 5σ + 1; an RNG that ignored the client seed would collide on all 650. An empty-seed control repeats the test on all 6,500 primary bets.

tests/steps/determinism.ts · Step 6 · Verified
const WRONG_CLIENT = 'wrong-client-seed-test';const SAMPLE_PER_EPOCH = 5;/** Distinct mine layouts available: C(25, m). */const layouts = (m: number): number => {  let r = 1;  for (let i = 0; i < m; i++) r = r * (25 - i) / (i + 1);  return Math.round(r);}; let tested = 0;let changed = 0;let collisions = 0;let expectedCollisions = 0;let collisionVariance = 0;const collisionsByMineCount: Record<number, number> = {}; const byEpoch = new Map<string, typeof bets>();for (const b of bets) {  const arr = byEpoch.get(b.seed.serverSeedHashed) ?? [];  arr.push(b);  byEpoch.set(b.seed.serverSeedHashed, arr);}for (const [hash, epochBets] of byEpoch) {  const ss = seedMap.get(hash);  if (!ss) continue;  for (const b of epochBets.slice(0, SAMPLE_PER_EPOCH)) {    tested++;    const m = b.request.mines_count;    const p = 1 / layouts(m);    expectedCollisions += p;    collisionVariance  += p * (1 - p);    const correct = computeMinePositions(ss, b.seed.clientSeed, b.seed.nonce, m);    const wrong   = computeMinePositions(ss, WRONG_CLIENT, b.seed.nonce, m);    if (correct.join(',') !== wrong.join(',')) changed++;    else {      collisions++;      collisionsByMineCount[m] = (collisionsByMineCount[m] ?? 0) + 1;    }  }}// 5 sigma plus a one-count buffer, the framework's bound for a statistic this sparse.const collisionBound = expectedCollisions + 5 * Math.sqrt(collisionVariance) + 1;
Result: 646 / 650 layouts change. The 4 collisions fall at 1 mine (1) and 24 mines (3): expected 5.97, bound 18.95. Empty client seed: 56 / 6,500 unchanged, expected 59.33, bound 98.08.
Technical Evidence & Verification5 sections
1.9Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Seed hash integrity (Step 1)149 / 149 seed reveals across both datasetsPass
Commitment linkage (Step 2)133 / 133 primary + 16 / 16 Phase E links, both anchorsPass
Hash consistency (Step 3)130 / 130 bet-bearing rotation records, 0 orphansPass
Nonce audit (Step 4)142 epochs; 1 declared capture gap (Phase E), 0 operator-side gaps, 0 reuseCapture flag
Mine position recomputation (Step 5)6,500 / 6,500 primaryPass
Client seed influence (Step 6)646 / 650 changed; empty-seed control 56 / 6,500Pass
Epoch size (Step 15)130 × 50 primary; every Phase E record on planPass
Phase D client seed variation (Step 17)500 / 500 recomputed under 10 player-set seedsPass
1.10Code References6 source files
2 columns
FilePurpose
tests/verify.ts26-step verification suite (Steps 1–6 and 15, 17 cover S1)
tests/steps/commitment.tsSteps 1–4: seed hashes, rotation links, epoch consistency, nonce audit
tests/steps/determinism.tsSteps 5–6: mine position recomputation, client seed influence
src/rng.tsSpec-built HMAC-SHA256 backward Fisher-Yates (computeMinePositions, verifyHash)
src/loader.tsDataset pins, the capture plan in code, the declared capture gap
capture/mines-capture.reference.jsReference record of the capture script (Phases A–D)
1.11Datasets UsedSource artifacts
Primary: data/mines-master-6500bets.json · Phase E: data/mines-phaseE-550bets.json
2 columns
PropertyValue
SourceLive Mines rounds on Duel.com, captured 16–21 April 2026
Total Records7,050 bets across 142 bet-bearing epochs (151 seed records)
Primary SHA-256331f74ff98b88d06242d57e806186548612f13c4269eb754ebb571d8a6fc9b20
Phase E SHA-256def563907949db10d584256a13b33102dfa46d33509424f642f803d74cd1b17b

Fields used: serverSeed, serverSeedHashed, nextServerSeedHash, clientSeed, nonce, mines_count, mines_positions, revealed_positions

1.12Verified Invariants9 invariants
2 columns
InvariantResult
SHA-256(hexDecode(serverSeed)) = serverSeedHashed for every seed reveal (149 / 149)Pass
Each epoch’s hash = the previous rotation’s nextServerSeedHash (133 / 133 + 16 / 16)Pass
Every bet carries its rotation record’s hash and client seedPass
Nonces start at the declared base 0 in all 142 epochsPass
No nonce served twice in any epochPass
Every gap is a declared capture gap (1, Phase E)Capture flag
Same inputs → same mine set for all 7,050 betsPass
Wrong client seed changes the set on 646 / 650, within the combinatorial boundPass
Client seed generated in the browser and echoed by the serverPass
1.13Reproduction InstructionsRun locally

Clone the release and run the suite. Nothing needs installing:

reproduce-s1.sh · 5 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm test# Steps 1–6: 5 PASS, Step 4 FLAG:capture
S1-related steps, as printed:

[PASS] Step 1 — Seed Hash Integrity
[PASS] Step 2 — Next-Seed Promotion (Commitment Linkage)
[PASS] Step 3 — Hash Consistency Within Epoch
[FLAG:capture] Step 4 — Nonce Audit
[PASS] Step 5 — Mine Position Recomputation
[PASS] Step 6 — Client Seed Influence
02

RNG & Entropy Model

Is the randomness genuinely random, or could it be rigged?

Our RNG, src/rng.ts, was written from our own specification (docs/ALGORITHM.md) by an implementer who never opened Duel’s code. It reproduces every one of the 7,050 captured layouts. Duel’s own Verify-tab code is run unmodified as a cross-check only, and agrees on all 7,050. In both, every draw range is exactly uniform. 24M simulated rounds find no sign of positional bias or serial dependence.

Cryptographic Randomness Verification

24 / 24draw ranges uniform in our RNG

What we verified

  • Mine layouts use only the server seed, client seed, nonce and mine count — no timestamps, no server state, no beacon
  • Our RNG is written from the spec; Duel’s code serves only as a cross-check
  • In our RNG, every draw range 2–25 is exactly uniform: the accepted window is a whole number of ranges
  • 156,000 recomputed draws: 0 chunks rejected (1.9 × 10⁻⁴ expected)
  • 24M simulated rounds find no sign of positional bias or serial dependence (0 / 24 configurations)
  • A wrong client seed changes the layout on 646 / 650 sampled bets

What this means for you

  • The shuffle that places the mines is exactly uniform, in Duel’s published code and in ours
  • All 25 tiles are equally likely to hold a mine
  • No hidden input can move the mines
  • Past rounds do not affect future ones
  • You can recompute any layout from seeds you can check
24 / 24draw ranges uniform in our RNG
  • Mine layouts use only the server seed, client seed, nonce and mine count — no timestamps, no server state, no beacon
  • Our RNG is written from the spec; Duel’s code serves only as a cross-check
  • In our RNG, every draw range 2–25 is exactly uniform: the accepted window is a whole number of ranges
  • 156,000 recomputed draws: 0 chunks rejected (1.9 × 10⁻⁴ expected)
  • 24M simulated rounds find no sign of positional bias or serial dependence (0 / 24 configurations)
  • A wrong client seed changes the layout on 646 / 650 sampled bets
RNG Pipeline — HMAC-SHA256 → uint32 → rejection sampling → Fisher-Yates swap → mine SET — illustrated flow
CheckResultEvidence
RNG written from the specPasssrc/rng.ts rebuilt from docs/ALGORITHM.md by an implementer who never opened Duel’s code; 7,050 / 7,050 live layouts reproduced
Duel verify code (cross-check)PassDuel’s Verify-tab code, run unmodified on all 7,050 rounds, returns the served mine set and ours on every one
Disclosed inputs onlyPassHMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i); no beacon field in either dataset; every layout reproduces from the four inputs
Draw biasPassAll 24 ranges 2–25 in our RNG: the accepted window is a whole number of ranges (range 25: 4,294,967,275 = 25 × 171,798,691); bias 0, inside the 2⁻³² ceiling
Rejection censusPass156,000 draws over 6,500 recomputed rounds: 0 rejected chunks, 0 cursor advances
Key encodingPassServer seed hex-decoded to 32 bytes; the UTF-8 key gives different layouts on all 7 test vectors
Simulation uniformity & serial independencePass24M rounds: mine positions 0 / 24, serial 0 / 24 at Bonferroni α/24 = 0.000417
RNG written from the specPass
src/rng.ts rebuilt from docs/ALGORITHM.md by an implementer who never opened Duel’s code; 7,050 / 7,050 live layouts reproduced
Duel verify code (cross-check)Pass
Duel’s Verify-tab code, run unmodified on all 7,050 rounds, returns the served mine set and ours on every one
Disclosed inputs onlyPass
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i); no beacon field in either dataset; every layout reproduces from the four inputs
Draw biasPass
All 24 ranges 2–25 in our RNG: the accepted window is a whole number of ranges (range 25: 4,294,967,275 = 25 × 171,798,691); bias 0, inside the 2⁻³² ceiling
Rejection censusPass
156,000 draws over 6,500 recomputed rounds: 0 rejected chunks, 0 cursor advances
Key encodingPass
Server seed hex-decoded to 32 bytes; the UTF-8 key gives different layouts on all 7 test vectors
Simulation uniformity & serial independencePass
24M rounds: mine positions 0 / 24, serial 0 / 24 at Bonferroni α/24 = 0.000417
✓  Uniform and reproducible

Our spec-built RNG reproduces every captured layout and Duel’s own code agrees on all 7,050. In both, every draw range is exactly uniform. 24M simulated rounds find no sign of positional bias or serial dependence.

How It Works — RNG & Entropy Model8 sections
2.1RNG Function Implementation

Each layout is a backward Fisher-Yates shuffle of tiles [0 … 24]. For draw i from 0 to 23, r = 25 − i; the draw reads its own digest HMAC-SHA256(key = hexDecode(serverSeed), message = clientSeed:nonce:i) as eight big-endian 32-bit chunks and takes the first one below floor(2^32 / r) · r. Then j = v mod r and tiles r − 1 and j swap. The first mineCount tiles, sorted, are the mines.

2 columns
ComponentDetail
Hash functionHMAC-SHA256
KeyBuffer.from(serverSeed, 'hex') — 32 bytes
MessageclientSeed:nonce:i, draw index i = 0 … 23
Extractioneight 4-byte big-endian chunks per digest → uint32
Rejectionv < floor(2^32 / r) · r — exact window per range
Reductionv mod r → swap index j ∈ [0, r)
ShuffleBackward Fisher-Yates: r = 25 down to 2, swap tiles[r − 1] ↔ tiles[j]
Outputtiles[0..mineCount−1] (sorted) → mine set
src/rng.ts · maxFairFor, drawFromChunk, drawIndexFromDigest, shuffleTilesFromBuffer · Verified
export function maxFairFor(range: number): number {  if (!Number.isInteger(range) || range < 1 || range > TWO_POW_32) {    throw new RangeError(`range must be an integer in 1..2^32, got ${range}`);  }  return Math.floor(TWO_POW_32 / range) * range;} export function drawFromChunk(value: number, range: number): number | null {  if (!Number.isInteger(value) || value < 0 || value > MAX_UINT32) {    throw new RangeError(`chunk value must be an integer in 0..${MAX_UINT32}, got ${value}`);  }  const limit = maxFairFor(range);  return value < limit ? value % range : null;} function drawIndexFromDigest(digest: Buffer, range: number, census: DrawCensus | undefined): number {  for (let off = 0; off + CHUNK_BYTES <= digest.length; off += CHUNK_BYTES) {    const value = digest.readUInt32BE(off);    if (census) census.chunksRead += 1;    const picked = drawFromChunk(value, range);    if (picked !== null) return picked;    if (census) census.rejectedChunks += 1;  }  throw new Error(    `all ${digest.length / CHUNK_BYTES} chunks of the digest were rejected for range ${range}; ` +      "ALGORITHM.md O1 leaves this case unspecified",  );} export function shuffleTilesFromBuffer(  keyBuffer: Buffer,  clientSeed: string,  nonce: number,  gridSize: number = GRID_SIZE,  census?: DrawCensus,): number[] {  checkKey(keyBuffer);  checkNonce(nonce);  checkGridSize(gridSize);  if (typeof clientSeed !== "string") throw new TypeError("clientSeed must be a string");   const tiles: number[] = [];  for (let t = 0; t < gridSize; t += 1) tiles.push(t);   for (let i = 0; i < gridSize - 1; i += 1) {    const range = gridSize - i; // gridSize, gridSize-1, ..., 2    const digest = digestForDraw(keyBuffer, clientSeed, nonce, i); // cursor = draw index (§2 step 1)    const j = drawIndexFromDigest(digest, range, census); // 0 <= j < range (§2 step 2)    const last = range - 1;    const held = tiles[last] as number;    tiles[last] = tiles[j] as number;    tiles[j] = held;    if (census) census.draws += 1;  }  return tiles;}
Result: Matches all 7,050 live rounds with zero set mismatches. The spec’s own vectors and properties run as a unit test (tests/mines/RngSpecTests.ts, 115 checks).
2.2Code Origin & Cross-Check

The RNG is our own implementation, written from a specification built from Duel’s public pages, the standard provably-fair construction and the 7,050 live rounds. Duel publishes its Mines algorithm on its Verify tab; that file (copied 25 September 2026, SHA-256 88f5268b…) is run unmodified by Step 5 on all 7,050 captured rounds as a second check, never as the source. Its generateMinesPositions returns the served mine set, and ours, on every round.

The two differ only on inputs no captured round reaches. For ranges 2, 4, 8 and 16 Duel’s code rejects the top r chunk values where ours accepts every value; both are exactly uniform. If all eight chunks of a digest were rejected, Duel’s code would move to the next cursor while ours stops with an error; that never happened, and its probability is below 10⁻⁶⁰.

Result: Three-way agreement on all 7,050 rounds: the live layouts, our spec-built RNG and Duel’s published code. Our code does not show that Duel’s live Verify button, or its server, runs exactly that file.
2.3Entropy Sources

All randomness comes from HMAC-SHA256 over cleanly separated inputs:

Entropy Sources — illustrated flow
3 columns
SourceControlled ByPurpose
Server SeedCasinoBase randomness, committed by SHA-256 hash before betting
Client SeedPlayerPlayer-contributed entropy
NonceSystemUniqueness per bet, from 0 within each epoch
Draw indexSystemPer-step separation, 0 to 23, one per shuffle step
No mixed entropy sources detected. The same inputs always give the same layout: 7,050 / 7,050.

How we know: all 7,050 bets recompute from the declared inputs alone; any hidden source would break recomputation.

Not present: no beacon field in either dataset, no timestamps, no Math.random(), no server-side state. Only HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i).

2.4Modulo Bias Analysis

Each swap index is v mod r with r from 25 down to 2. Plain v mod r would lean towards low indices whenever 2^32 is not a multiple of r. Rejection sampling removes that: only chunks below floor(2^32 / r) · r are used, a window that is a whole number of ranges. Step 5 measures the window from the function the shuffle calls, for all 24 ranges.

For r = 25 (draw i = 0):
  LIMIT = floor(2^32 / 25) · 25
        = 171,798,691 · 25
        = 4,294,967,275

  Rejected values: 4,294,967,275 … 4,294,967,295 = 21 values
  Rejection rate: 21 / 2^32 ≈ 4.89 × 10⁻⁹ per chunk

For r = 2, 4, 8, 16: LIMIT = 2^32, nothing is rejected.

Every accepted window is exact → each index 0 … r−1 has the same number of values (bias 0)
Result: All 24 windows exact, bias 0. Over the 6,500 recomputed rounds: 156,000 draws, 156,000 chunks read, 0 rejected (1.91 × 10⁻⁴ expected).

Without the guard, plain v mod r would lean by up to 5.82 × 10⁻⁹ relative (2.19 × 10⁻¹⁰ absolute, already under 2⁻³²), which is why exactness, not the ceiling, is the binding assertion. Rejecting all eight chunks of one digest has probability below 10⁻⁶⁰ for every range.

2.5RNG Isolation

Each shuffle step uses its own draw index in the HMAC message (clientSeed:nonce:i), and each bet its own nonce. HMAC-SHA256 is a pseudorandom function, so one step’s output says nothing about another’s. There is no shared state between steps, bets or epochs.

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

Evidence: shuffleTilesFromBuffer in 2.1 is a pure function — no module state, no external calls, no memory between bets. It takes (key, clientSeed, nonce, gridSize) and returns the shuffled tiles.

2.6Monte Carlo Simulation (24M Rounds)

Pass 1 simulated 1,000,000 rounds for each of the 24 mine counts, 24,000,000 in all, through our spec-built RNG on auditor-generated seeds pinned in src/sim-plan.ts. Every statistic is re-derived from the integer census the artifact carries, and the first 10,000 rounds of every configuration are replayed on each run.

2 columns
MetricValue
Mean simulated RTP99.9041%
Theoretical RTP (base edge)99.9000%
Mine-position test (Bonferroni α/24)0 / 24 configurations flag
Serial independence (lag-1 + runs)0 / 24 configurations flag
Checkpoint replay (first 10,000 rounds × 24)0 mismatches
src/sim-plan.ts · simulation plan · Verified
/** Pass 1 mine counts: every configuration the game offers, 1-24. */export const SIM_CONFIGS: number[] = Array.from({ length: 24 }, (_, i) => i + 1);/** The profile floor (MINES-20): at least 1,000,000 rounds per mine count. */export const SIM_ROUNDS_PER_CONFIG = 1_000_000;/** Pass 2: nonces per revealed casino seed (profile floor 10,000). */export const SIM_NONCES_PER_SEED = 10_000;/** Pass 2 early window = the captured epoch, nonces 0..49. */export const SIM_EPOCH_LENGTH = 50;/** Pass 2 Tests A/B: a representative 3-mine board (~88% win chance). Test C uses the served configs. */export const SIM_PASS2_MINE_COUNT = 3;
Result: 24M rounds. The simulation finds no sign of positional bias or serial dependence, and its mean RTP of 99.904% is consistent with the theoretical 99.9%.

Mine positions are tested against the uniform lattice with the without-replacement correction; serial independence by lag-1 autocorrelation and a runs test on the win/loss sequence, both at the Bonferroni-corrected α/24. Smallest position p-value 0.0144 (m=19); smallest runs p-value 0.0196 (m=6).

2.7Serial Independence

Serial independence means one round’s result says nothing about the next. Pass 1 applies two tests to each configuration (1,000,000 rounds each):

Lag-1 autocorrelation: Correlation between consecutive win/loss outcomes; a configuration flags at |z| > 3.5.

Runs test: Counts runs of wins and losses against the number independent rounds produce; a configuration flags at p < α/24.

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 / 24 configurations flag on either test. Consecutive outcomes show no sign of dependence.
2.8Worked Example — Full RNG Trace

Real bet from the dataset — Round ID 25075415, 3 mines, nonce 6. Verified from mines-master-6500bets.json:

serverSeed  = 01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3
clientSeed  = NxcarOV28bkerHJk
nonce       = 6
mines_count = 3
revealed    = [0]
7 columns
irmessagefirst chunkuint32jswap
025NxcarOV28bkerHJk:6:0ff89d9594,287,224,1533tiles[24] ↔ tiles[3]
124NxcarOV28bkerHJk:6:1ee24d5d23,995,391,44210tiles[23] ↔ tiles[10]
223NxcarOV28bkerHJk:6:293470e022,470,907,3946tiles[22] ↔ tiles[6]
322NxcarOV28bkerHJk:6:3c883330b3,364,041,48311tiles[21] ↔ tiles[11]
421NxcarOV28bkerHJk:6:49e8e49262,660,124,9669tiles[20] ↔ tiles[9]
Parity verified: Round #25075415 — the mine set matches the recomputation exactly. Tile 0 was opened (not a mine) → win. Multiplier (mines=3, k=1): 25 / 22 = 1.1364×; payout 0.01 × 25/22 × 0.999 = 0.011352.
Live GameSET = {5, 16, 21}
VerifierSET = {5, 16, 21}
Technical Evidence & Verification5 sections
2.9Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Spec-built RNG vs live layouts (Steps 5, 21)7,050 / 7,050Pass
Duel verify code, unmodified (Step 5)7,050 / 7,050Pass
Draw-bias bound (Step 5)24 / 24 ranges exact, bias 0Pass
Rejection census (Step 5)156,000 draws, 0 rejectedPass
Key encoding (unit test)UTF-8 key differs on 7 / 7 vectorsPass
Simulation positions (Step 18)0 / 24 at α/24Pass
Serial independence (Step 18)0 / 24 at α/24Pass
Live-sample fit (Step 26)24 groups, first-drawn mine p = 0.938; 0 flagsPass
2.10Code References7 source files
2 columns
FilePurpose
src/rng.tsSpec-built HMAC-SHA256 backward Fisher-Yates
docs/ALGORITHM.mdThe written specification src/rng.ts is built from
src/bias.tsDraw-bias bound, measured from drawFromChunk
src/operator-verifier.tsRuns Duel’s Verify-tab code unmodified (the cross-check)
src/simulate.tsMonte Carlo simulation, Pass 1 and Pass 2
src/sim-plan.tsSimulation plan and pinned seeds
tests/mines/RngSpecTests.tsThe spec’s vectors and properties against src/rng.ts
2.11Verified Invariants8 invariants
2 columns
InvariantResult
Spec-built RNG matches the live game for all 7,050 roundsPass
Duel’s published code matches the live game and ours for all 7,050 roundsPass
Key is hex-decoded (not UTF-8)Pass
Every draw range 2–25 has an exact acceptance window in our RNGPass
No external entropy needed to reproduce a layoutPass
No sign of positional bias in simulation (0 / 24 configurations flag)Pass
No sign of serial dependence in simulation (0 / 24 configurations flag)Pass
Client seed change produces a different mine set (646 / 650)Pass
2.12Datasets UsedSource artifacts
Simulation: outputs/simulation-results.json — 24M Pass 1 rounds and 130 casino seeds × 10,000 nonces in Pass 2
Primary dataset: data/mines-master-6500bets.json — 6,500 live bets for layout recomputation (Step 5)
Phase E dataset: data/mines-phaseE-550bets.json — 550 multi-reveal bets (Steps 20–23)
Operator code: evidence/verify-tab/duel-verify-tab-mines-2026-09-25.js — Duel’s Verify-tab code, copied verbatim, run unmodified
Determinism log: outputs/determinism-log.json — 6,500 verified, 0 mismatches, 0 skipped
2.13Reproduction InstructionsRun locally

Clone the release and run the suite:

reproduce-s2.sh · 5 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm test# Steps 5, 18, 26 cover S2
S2-related steps, as printed:

[PASS] Step 5 — Mine Position Recomputation
[PASS] Step 18 — Simulation Results — Pass 1 Integrity
[PASS] Step 26 — Live-Sample Fit (win rate & mine positions)
03

Verifier Parity

Does the live game actually follow its own rules?

Every recorded bet is recomputed — all 7,050 rounds, wins and losses, from the revealed seed of their epoch. Each mine set, multiplier and payout matches the live game. The ProvablyFair.org verifiers players use, on this site and at www.provablyfair.org/verify-bets, are pinned by hash and run on the same 7,050 rounds, as is Duel’s own verify code.

Live ↔︎ Verifier Parity

7,050 / 7,050bets matched

What we verified

  • Every captured round recomputed from its revealed seed — the full mine set, not just the payout
  • Every win credits stake × the served multiplier to 1e-12 relative; every loss credits exactly 0
  • All 7,107 served multipliers match the exact rational C(25,k)/C(25−m,k), × 999/1000 when settled, to 1e-12 relative
  • Outcome derived from our recomputed layout: every bust ends on exactly the opened mine
  • $10 bets are served the identical multiplier strings as $0.01 bets
  • Both ProvablyFair.org verifiers and Duel’s verify code return the same layout on all 7,050 rounds

What this means for you

  • The game in production matched Duel’s published code on every captured round
  • Any bet you play can be recomputed by anyone
  • Bet size does not change the mines or the formula
  • The verifier you use returns what the game served
7,050 / 7,050bets matched
  • Every captured round recomputed from its revealed seed — the full mine set, not just the payout
  • Every win credits stake × the served multiplier to 1e-12 relative; every loss credits exactly 0
  • All 7,107 served multipliers match the exact rational C(25,k)/C(25−m,k), × 999/1000 when settled, to 1e-12 relative
  • Outcome derived from our recomputed layout: every bust ends on exactly the opened mine
  • $10 bets are served the identical multiplier strings as $0.01 bets
  • Both ProvablyFair.org verifiers and Duel’s verify code return the same layout on all 7,050 rounds
Parity Verification Flow — seeds → recompute → compare → exact match — illustrated flow
7,050Live Bets Tested
100%Parity Rate
$0.01 & $10Bet Sizes Tested
0Mismatches
CheckResultEvidence
Mine-set recomputationPass7,050 / 7,050 (6,500 primary in Step 5, 550 Phase E in Step 21); 0 mismatches
Payout correctnessPassEvery round: 6,500 primary and 417 Phase E rounds (Step 7), 133 cash-outs at k > 1 (Step 23); relative 1e-12; 0 errors
Multiplier formulaPass2,834 depth-1 wins (Step 8), 1,173 reveal steps (Step 20), 133 cash-outs (Step 23) match the exact rationals to 1e-12 relative; worst deviation 9.2 × 10⁻¹⁵
Win conditionPass7,050 rounds, outcome derived from our recomputed layout; all 4,083 busts end on exactly the opened mine
Bet-size invariancePass200 $10 bets recomputed; their 105 wins were served the identical multiplier strings as $0.01 wins
ProvablyFair.org verifier parityPassThis site’s verifier and the live www.provablyfair.org/verify-bets bundle, pinned by SHA-256, each return the served layout on 7,050 / 7,050
Duel verify code (cross-check)PassDuel’s Verify-tab code, unmodified: the served mine set and ours on 7,050 / 7,050
Multi-reveal parityPassAll 1,173 Phase E reveal steps: is_mine matches our layout and revealed_positions is the exact prefix, including 11 out-of-order rounds
Mine-set recomputationPass
7,050 / 7,050 (6,500 primary in Step 5, 550 Phase E in Step 21); 0 mismatches
Payout correctnessPass
Every round: 6,500 primary and 417 Phase E rounds (Step 7), 133 cash-outs at k > 1 (Step 23); relative 1e-12; 0 errors
Multiplier formulaPass
2,834 depth-1 wins (Step 8), 1,173 reveal steps (Step 20), 133 cash-outs (Step 23) match the exact rationals to 1e-12 relative; worst deviation 9.2 × 10⁻¹⁵
Win conditionPass
7,050 rounds, outcome derived from our recomputed layout; all 4,083 busts end on exactly the opened mine
Bet-size invariancePass
200 $10 bets recomputed; their 105 wins were served the identical multiplier strings as $0.01 wins
ProvablyFair.org verifier parityPass
This site’s verifier and the live www.provablyfair.org/verify-bets bundle, pinned by SHA-256, each return the served layout on 7,050 / 7,050
Duel verify code (cross-check)Pass
Duel’s Verify-tab code, unmodified: the served mine set and ours on 7,050 / 7,050
Multi-reveal parityPass
All 1,173 Phase E reveal steps: is_mine matches our layout and revealed_positions is the exact prefix, including 11 out-of-order rounds
✓  Live game and verifiers aligned

All 7,050 captured rounds recompute to the served mine set. Multipliers and payouts match the formula to 1e-12 relative, and the win condition holds on every round. Both ProvablyFair.org verifiers and Duel’s own verify code return the same layouts.

How It Works — Verifier Parity9 sections
3.1Why Parity Matters

If a verifier returns a different result from the live game, verification means nothing. A single mismatch would point to a bug in the verifier, a change in the live game, or a hidden input. Parity has to be total: take the revealed seeds, run the verifier, get the layout you played.

Why Parity Matters — illustrated flow
3.2Five-Phase Collection Design

The capture ran in five phases, each aimed at one property. Together they cover every mine count, the high-variance edge, bet size, player-set client seeds and multi-reveal cash-outs.

5 columns
PhaseBetsConfigBet AmountPurpose
A — Configuration coverage4,80024 configs (mines 1–24, 200 each)$0.01Every mine count
B — High-mine edge case1,000mines = 24$0.01Maximum variance: one safe tile in 25
C — Stake equivalence200mines = 12$10.00Bet amount is not an RNG input
D — Client seed variation500mines 1–24$0.0110 player-set client seeds
E — Multi-reveal & cash-out550mines 2, 3, 4, 5, 8, 12, 15; up to 5 reveals$0.01Reveal chains, cash-outs, reveal-position independence
Total: 7,050 bets across 142 bet-bearing epochs (151 seed records). Wagered: $2,063.00 in Phases A–D, plus $5.50 in Phase E.
3.3Mine Position Recomputation (Step 5)

Every bet is recomputed from the revealed seed of its epoch with computeMinePositionsFromBuffer and compared with the served mines_positions as a set. A bet with no revealed seed would fail the step, not be skipped; the count is bound to the capture plan.

Mine Position Recomputation (Step 5) — illustrated flow
tests/steps/determinism.ts · Step 5 · Verified
for (const b of bets) {  const ss = seedMap.get(b.seed.serverSeedHashed);  if (!ss) { skipped++; continue; }  const key      = Buffer.from(ss, 'hex');  const computed = computeMinePositionsFromBuffer(key, b.seed.clientSeed, b.seed.nonce, b.request.mines_count, GRID_SIZE, census);  if (!sameLayout(computed, b.response.mines_positions)) mismatches++;}
Result: 6,500 / 6,500 primary bets, 0 skipped, 0 mismatches. The 550 Phase E bets recompute in Step 21: 550 / 550.
3.4Player Verifiers & Duel’s Code

Step 5 also runs the verifiers a player would use, byte for byte, on all 7,050 captured rounds, and fails on any hash mismatch or any layout that differs from ours.

4 columns
VerifierWhat runsPinnedResult
This site’s verifierVerifyBets games/mines/derive.js + lib/hmac-sha256.js, vendoredSHA-256 2321b23c…, bc30bfe9…Pass 7,050 / 7,050
www.provablyfair.org/verify-betsThe deployed bundle (3 chunks), with the page’s own Verify call4 / 4 SHA-256 pinsPass 7,050 / 7,050
Duel’s Verify-tab codeCopied verbatim 25 Sept 2026, run unmodified (cross-check)SHA-256 88f5268b…Pass 7,050 / 7,050
Result: Every verifier returns the served mine set on every round. scripts/check-site-verifier.mjs checks a site checkout, or the live page with --live, against the pinned copies.
3.5Payout Math (Step 7)

Every win must credit amount × no_house_edge_multiplier and every loss exactly "0". The tolerance is 1e-12 relative, with a floor of 1e-12 absolute on payouts under $1: far below a cent at both stakes. Duel’s API carries two multiplier fields: multiplier is the raw ratio C(25,k)/C(25−m,k); no_house_edge_multiplier, despite its name, includes the edge and is the one the payout uses.

Payout Math (Step 7) — illustrated flow
tests/steps/payouts.ts · Step 7 · Verified
const checkWin = (b: MinesGame, tag: string) => {  const amt  = parseFloat(b.request.amount);  const nhe  = parseFloat(b.response.no_house_edge_multiplier ?? 'NaN');  const won  = parseFloat(b.response.amount_won);  if (!Number.isFinite(won) || !Number.isFinite(nhe) || Math.abs(amt * nhe - won) > moneyTol(amt * nhe)) {    payoutErrors++;    payoutFailures.push(`${tag} round ${b.response.round_id}: amount_won ${b.response.amount_won} != ${b.request.amount} × ${b.response.no_house_edge_multiplier}`);  }};const checkLoss = (b: MinesGame, tag: string) => {  if (b.response.amount_won !== '0') {    payoutErrors++;    payoutFailures.push(`${tag} round ${b.response.round_id}: a loss credited ${b.response.amount_won}`);  }};
Result: 6,500 primary bets (2,795 wins, 3,705 losses) and 417 Phase E rounds (39 depth-1 wins, 378 losses): 0 errors. The 133 Phase E cash-outs at k > 1 are scored by Step 23: 0 errors.
3.6Multiplier Formula Verification (Step 8)

Mines has no lookup table: the multiplier is the exact rational C(25,k)/C(25−m,k), × 999/1000 at the base edge. The served 18-decimal strings are parsed exactly and compared at 1e-12 relative. Step 8 takes every win settled at one reveal; Step 20 every reveal step and Step 23 every cash-out at k > 1.

3 columns
PopulationCheckedWorst deviation
Primary wins at k = 1 (Step 8)2,7956.4 × 10⁻¹⁹
Phase E wins at k = 1 (Step 8)396.0 × 10⁻¹⁹
Phase E reveal steps, k = 1–5 (Step 20)1,1739.2 × 10⁻¹⁵
Phase E cash-outs at k > 1 (Step 23)1335.9 × 10⁻¹⁵
src/exact.ts + tests/steps/payouts.ts · Step 8 · Verified
export function exactMultiplier(m: number, k: number, withEdge: boolean): Rational {  const num = binomialBig(GRID, k) * (withEdge ? EDGE_NUM : 1n);  const den = binomialBig(GRID - m, k) * (withEdge ? EDGE_DEN : 1n);  if (den === 0n) throw new Error(`multiplier undefined at m=${m}, k=${k} (k exceeds the ${GRID - m} safe tiles)`);  return { num, den };}  // …const checkK1 = (b: MinesGame) => {  const m = b.request.mines_count;  if (!track(s8Dev, relativeDeviation(b.response.multiplier, exactMultiplier(m, 1, false)), `round ${b.response.round_id} multiplier`)) multErrors++;  if (!track(s8Dev, relativeDeviation(b.response.no_house_edge_multiplier, exactMultiplier(m, 1, true)), `round ${b.response.round_id} no_house_edge_multiplier`)) multErrors++;};
Result: Every served multiplier matches the formula; 0 mismatches. At k > 1 Duel computes the product in double precision, which is the 9.2 × 10⁻¹⁵ shown; the bound is over 100× wider.
3.7Win Condition Verification (Step 9)

The outcome is derived from the layout we recompute, never from the served mines_positions: a round wins exactly when no opened tile is a mine. Every bust must end on exactly the last opened tile, the opened count must equal the recorded depth, and a Phase E round is cashed out exactly when it wins.

3 columns
ScopeCoverageVerified
Primary dataset (Phases A–D)6,500 bets, tile 0 opened6,500 / 6,500
Phase E rounds550 rounds, up to 5 reveals550 / 550
Busts ending on the opened mine4,083 losses4,083 / 4,083
Reveal-position independence (Step 22)50 bets, tiles {3, 7, 11, 17, 23}50 / 50
Result: Win condition verified on all 7,050 rounds. No off-by-one, no position-specific logic.
3.8Phase C — Bet-Size Equivalence (Step 10)

Phase C placed 200 bets at $10 on 12 mines. Step 10 recomputes every layout itself, scores every $10 win against the exact multiplier and the payout, both to 1e-12 relative, and requires the served multiplier strings to be identical to those served on the $0.01 12-mine wins of Phase A. At least 100 elevated-stake wins are required; there were 105.

Result: 200 / 200 layouts recompute at $10; 105 wins, identical multiplier strings to $0.01, 0 errors. Bet amount is not an input to the RNG.
Variance context: At 12 mines the first reveal wins 52% of the time and pays 25/13 × 0.999 = 1.921×. On 200 bets the observed return is not a meaningful measure; the 99.9% theoretical RTP is proven in S4.
3.9Worked Example — Full Parity Verification

Real bet from Phase E2 — Round ID 25754001, 5 mines, nonce 0, three safe reveals, cashed out. Verified from mines-phaseE-550bets.json:

serverSeed  = 5c0cb6589645e00abebd80b697cb739f2c4883a632fc10bdf4122c1e02ef0e22
clientSeed  = BFkh4hKDVgdKYmrl
nonce       = 0
mines_count = 5
reveals     = [0, 1, 2]
cashed_out  = true
reached_k   = 3
3 columns
StepProcessOutput
1Backward Fisher-Yates: 24 HMAC-SHA256 drawsShuffled tiles
2tiles[0..4] (sorted) → mine set{4, 6, 9, 13, 19}
3Player opens tiles 0, 1, 2 — none a mine3 safe reveals (win)
4Multiplier chain C(25,k)/C(20,k), k = 1, 2, 3; edge at cash-out1.2500× → 1.5789× → 2.0175× → paid 2.0155×
5Cash-out payout: 0.01 × 2.0155260.020155 ✅
HMAC-SHA256 recomputation + formula · Verified
// computeMinePositions("5c0cb658…", "BFkh4hKDVgdKYmrl", 0, 5)// 24 draws → mine set = {4, 6, 9, 13, 19}//// Reveal chain (tiles 0, 1, 2 — all safe). reveal_steps carry the raw ratio://   k=1: C(25,1) / C(20,1) = 25/20                   = 1.250000×//   k=2: C(25,2) / C(20,2) = (25·24)/(20·19)         = 1.578947×//   k=3: C(25,3) / C(20,3) = (25·24·23)/(20·19·18)   = 2.017544×//// Cash-out at k=3 applies the 0.1% base edge://   no_house_edge_multiplier = 2.017544 × 0.999 = 2.015526//   Payout: 0.01 × 2.015526 = 0.020155//   Live amount_won: 0.020155263157894753 ✅
Parity verified: Round #25754001 — mine set, reveal sequence, multiplier chain and cash-out payout all match. This round is covered by Steps 9, 20, 21 and 23, and by the verifier runs in Step 5.
Live GameSET = {4,6,9,13,19}, payout = 0.02016
VerifierSET = {4,6,9,13,19}, payout = 0.02016
Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary12 checks
3 columns
Verification AreaCoverageResult
Mine-set recomputation (Step 5)6,500 / 6,500 primaryPass
Payout math (Step 7)6,500 primary + 417 Phase E rounds, relative 1e-12Pass
Multiplier formula (Step 8)2,795 primary + 39 Phase E wins at k = 1Pass
Win condition (Step 9)7,050 rounds from our recomputed layoutPass
Phase C bet-size invariance (Step 10)200 bets at $10, 105 winsPass
Config & payout-cell coverage (Step 11)24 × 200 Phase A; 33 of 300 cells reachedPass
Phase D client seed variation (Step 17)500 / 500 under 10 player-set seedsPass
Multi-reveal multiplier chain (Step 20)1,173 reveal steps, k = 1–5Pass
Mine-set invariance (Step 21)550 layouts, 1,173 steps, 11 out-of-order roundsPass
Reveal-position independence (Step 22)50 bets, tiles {3, 7, 11, 17, 23}Pass
Cash-out payout correctness (Step 23)133 cash-outs: k=2: 14, k=3: 74, k=5: 45Pass
Multiplier monotonicity & bounds (Step 25)7,107 served multipliers inside the exact ladder’s rangePass
3.11Code References6 source files
2 columns
FilePurpose
tests/steps/determinism.tsStep 5: recomputation, verifier parity, Duel-code cross-check
tests/steps/payouts.tsSteps 7–12: payouts, multipliers, win condition, Phase C, coverage, house edge
tests/steps/multireveal.tsSteps 20–23: multi-reveal chain, invariance, reveal position, cash-outs
src/exact.tsExact binomials and rational comparison
src/site-verifier.tsPins and runs this site’s verifier
src/live-site-verifier.tsPins and runs the www.provablyfair.org/verify-bets bundle
3.12Datasets UsedSource artifacts
Primary dataset: data/mines-master-6500bets.json — 6,500 live bets across Phases A–D (130 epochs)
Phase E dataset: data/mines-phaseE-550bets.json — 550 multi-reveal bets across 5 sub-phases (12 epochs)
Verifier copies: verifier-parity/ — this site’s and the live site’s verifier code, byte for byte
Verification output: outputs/verification-results.json — Steps 5, 7–11, 17, 20–23, 25
3.13Verified Invariants9 invariants
2 columns
InvariantResult
Recomputed mine set = served mines_positions for all 7,050 betsPass
amount_won = amount × no_house_edge_multiplier, relative 1e-12, every winPass
Every loss credits exactly 0Pass
Every served multiplier = C(25,k)/C(25−m,k) (× 999/1000 settled), relative 1e-12, k = 1–5Pass
Outcome from our recomputed layout = served outcome, 7,050 roundsPass
$10 wins served identical multiplier strings to $0.01 winsPass
Both ProvablyFair.org verifiers return the served layout on every roundPass
Duel’s published code returns the served layout on every roundPass
Mine set fixed at round start, unchanged by reveal order (Phase E)Pass
3.14Reproduction InstructionsRun locally
reproduce-s3.sh · 5 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm test# Steps 5, 7–11, 17, 20–23, 25 cover S3
S3-related steps, as printed:

[PASS] Step 5 — Mine Position Recomputation
[PASS] Step 7 — Payout Math
[PASS] Step 8 — Multiplier Formula (C(25,1)/C(25-m,1) × edge)
[PASS] Step 9 — Win Condition (tile not in mines)
[PASS] Step 10 — Phase C Bet-Size Invariance ($10 bets)
[PASS] Step 11 — Config Completeness & Payout-Cell Coverage
[PASS] Step 17 — Phase D — Client Seed Variation
[PASS] Step 20 — Multi-Reveal Multiplier Chain
[PASS] Step 21 — Mine-Set Invariance Across Reveals (per-step, order-independent)
[PASS] Step 22 — Reveal-Position Independence (Phase E5)
[PASS] Step 23 — Cash-Out Payout Correctness (k>1)
[PASS] Step 25 — Multiplier Monotonicity & Bounds
04

RTP & Payout Logic

Is the house edge what the casino claims?

Theoretical RTP is 99.9% at Duel’s 0.1% base edge. We derive it from first principles: survival is counted over all 2^25 tile subsets, and the payout formula × the counted probability equals exactly 1 − edge on every cell, with no casino-supplied probability. Duel states its edge in its game settings: 0.1% on 294 cells, 0.14–0.21% on the six full-board cash-outs. The RTP claim rule holds each of the 300 (mines, reveals) cells to that stated figure within ±0.1 pp, and all 300 pass. A 24M-round simulation is consistent with the proof, and the cherry-pick tests find no sign that seeds were chosen.

Return to Player Verification

99.9%theoretical RTP · base tier

What we verified

  • Theoretical RTP is exactly 1 − edge on all 300 (mines, reveals) cells: 99.9% at the 0.1% base edge, from first principles
  • Duel’s stated edge holds on every cell: RTP claim rule PASS, 0 of 300 beyond ±0.1 pp
  • The six full-board cash-outs (10–15 mines) start at 0.14–0.21% in Duel’s settings and return 99.86%, 99.82% or 99.79%
  • All 7,050 captured bets were served the 0.1% base edge (effective_edge 0.1)
  • 24M simulated rounds: mean 99.904%, consistent with 99.9%
  • The cherry-pick tests on all 130 revealed casino seeds find no sign of seed selection

What this means for you

  • The edge is 0.1% until potential profit at the current tile passes $25,000; deep cash-outs can pass that at small stakes
  • Above that, Duel’s settings raise the edge in steps up to 1.0%; that range was not tested
  • The RTP proof does not rely on trusting the casino
  • Duel’s published edge matches the game’s real return
  • Your bet size does not move the mines
99.9%theoretical RTP · base tier
  • Theoretical RTP is exactly 1 − edge on all 300 (mines, reveals) cells: 99.9% at the 0.1% base edge, from first principles
  • Duel’s stated edge holds on every cell: RTP claim rule PASS, 0 of 300 beyond ±0.1 pp
  • The six full-board cash-outs (10–15 mines) start at 0.14–0.21% in Duel’s settings and return 99.86%, 99.82% or 99.79%
  • All 7,050 captured bets were served the 0.1% base edge (effective_edge 0.1)
  • 24M simulated rounds: mean 99.904%, consistent with 99.9%
  • The cherry-pick tests on all 130 revealed casino seeds find no sign of seed selection
INDEPENDENT DERIVATION
P(survive k) × multiplier(m, k)= 0.999
Survival counted over all 2²⁵ tile subsets · All 24 mine counts · All 300 (mines, reveals) cells · 0.1% base edge

Exactly 1 − edge on every cell. Duel’s settings start the six full-board cash-outs (10–15 mines) at 0.14–0.21%, which return 99.79–99.86%.

99.9%Theoretical RTP at the 0.1% base edge
99.904%Simulated (24M rounds)
0.1%Base edge (scaled up to 1.0%)
300 / 300RTP claim cells pass
CheckResultEvidence
Anti-circularityPassSurvival counted over all 2^25 subsets; formula × counted probability = 1 − edge exactly on all 300 cells; negative controls rejected
RTP claim (RTP-CLAIM 1.2.0)PassClaim: the house edge in Duel’s game settings — 0.1% on 294 cells, 0.14–0.21% on 6 full-board cash-outs. Scored on Step 16: 0 of 300 cells beyond ±0.1 pp; true range 99.79–99.90%
House edge servedPasseffective_edge = 0.1 on all 6,500 primary bets (Step 12); all 7,050 captured bets inside the 0.1% tier
Stake tiers (scaling edge)InfoFrom Duel’s settings: 0.1% up to $25,000 potential profit, then +0.01% per tier up to 1.0% at $250,000. Explained from the config, not certified (S4.7)
Multipliers and payoutsPassEvery served multiplier = the exact rational and every payout = stake × multiplier, both to 1e-12 relative
Simulated RTP (Pass 1)Pass24M rounds, mean 99.904%; positions 0 / 24 and serial 0 / 24 at α/24
Cherry-pick tests (Pass 2)Pass130 seeds × 10,000 nonces: Test A 1 / 130, Test B 7 / 130, Test C 3 / 130; 0 seeds off in both windows
Bet-size invariancePass$10 and $0.01 wins served identical multiplier strings (Phase C, 105 wins)
Anti-circularityPass
Survival counted over all 2^25 subsets; formula × counted probability = 1 − edge exactly on all 300 cells; negative controls rejected
RTP claim (RTP-CLAIM 1.2.0)Pass
Claim: the house edge in Duel’s game settings — 0.1% on 294 cells, 0.14–0.21% on 6 full-board cash-outs. Scored on Step 16: 0 of 300 cells beyond ±0.1 pp; true range 99.79–99.90%
House edge servedPass
effective_edge = 0.1 on all 6,500 primary bets (Step 12); all 7,050 captured bets inside the 0.1% tier
Stake tiers (scaling edge)Info
From Duel’s settings: 0.1% up to $25,000 potential profit, then +0.01% per tier up to 1.0% at $250,000. Explained from the config, not certified (S4.7)
Multipliers and payoutsPass
Every served multiplier = the exact rational and every payout = stake × multiplier, both to 1e-12 relative
Simulated RTP (Pass 1)Pass
24M rounds, mean 99.904%; positions 0 / 24 and serial 0 / 24 at α/24
Cherry-pick tests (Pass 2)Pass
130 seeds × 10,000 nonces: Test A 1 / 130, Test B 7 / 130, Test C 3 / 130; 0 seeds off in both windows
Bet-size invariancePass
$10 and $0.01 wins served identical multiplier strings (Phase C, 105 wins)
✓  RTP holds as stated

The theoretical RTP is exactly 1 − edge on every cell, derived from first principles: 99.9% at Duel’s 0.1% base edge. Duel’s stated edge matches the game’s real return on all 300 cells. The simulation is consistent with it, and the cherry-pick tests find no sign of seed selection.

How It Works — RTP & Payout Logic10 sections
4.1Anti-Circularity Proof (Step 16)

The RTP is derived without any casino-supplied probability. For k reveals with m mines the payout multiplier is C(25,k) / C(25−m,k) × (1 − edge) and the chance of surviving k reveals is C(25−m,k) / C(25,k). The product is 1 − edge by cancellation, and that alone would be a tautology: a wrong binomial would cancel out too. So Step 16 counts survival instead: it visits all 2^25 subsets of the board and tallies the k-subsets that avoid m given tiles, with no binomial formula in the path.

Anti-Circularity Proof (Step 16) — illustrated flow
3 columns
ComponentFormulaSource
Survival after k revealscounted over all 2^25 tile subsets = C(25−m, k) / C(25, k)Counting — independent of every closed form
Payout multiplierC(25, k) / C(25−m, k) × (1 − edge)The formula Duel’s served multipliers follow (S3)
RTPcounted survival × multiplier, exact rationalIndependent probability × the paid multiplier
Result= 1 − edge on all 300 cells: 999/1000 at the 0.1% base edgeExact; floating-point check within 2.2 × 10⁻¹⁶
5 columns
Mines (m)Win chance (k = 1)Multiplier (base edge)ProductRTP
124/25 = 0.96000025/24 × 0.999 = 1.0406250.99900000099.9%
322/25 = 0.88000025/22 × 0.999 = 1.1352270.99900000099.9%
520/25 = 0.80000025/20 × 0.999 = 1.2487500.99900000099.9%
1213/25 = 0.52000025/13 × 0.999 = 1.9211540.99900000099.9%
205/25 = 0.20000025/5 × 0.999 = 4.9950000.99900000099.9%
241/25 = 0.04000025/1 × 0.999 = 24.9750000.99900000099.9%
Result: On all 300 cells the counted survivals equal the integer binomials, and formula × counted probability equals 1 − edge exactly: 999/1000 at the base edge. Negative controls are rejected on every run: the corrupted form C(26−m,k) fails, and a layout with one mine moved is refused.

The counting anchor:

src/exact.ts · enumerateSurvivalCounts · Verified
export function enumerateSurvivalCounts(): { survive: number[][]; total: number[] } {  const total = new Array(GRID + 1).fill(0);  // byLow[k][b]: k-subsets whose lowest tile index is b (b = GRID for the empty set).  const byLow: number[][] = Array.from({ length: GRID + 1 }, () => new Array(GRID + 1).fill(0));  const limit = 1 << GRID;  for (let s = 0; s < limit; s++) {    // popcount    let x = s - ((s >>> 1) & 0x55555555);    x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);    const k = (((x + (x >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;    const low = s === 0 ? GRID : 31 - Math.clz32(s & -s);    total[k]++;    byLow[k][low]++;  }  // A subset avoids {0..m−1} iff its lowest tile is >= m.  const survive: number[][] = Array.from({ length: GRID + 1 }, () => new Array(GRID + 1).fill(0));  for (let k = 0; k <= GRID; k++) {    let acc = 0;    for (let b = GRID; b >= 0; b--) {      acc += byLow[k][b];      survive[b][k] = acc;         // lowest >= b  ⇔  avoids the b tiles {0..b−1}    }  }  return { survive, total };}

Step 16, per cell:

tests/steps/dataset.ts · Step 16 · Verified
// (1) counting anchor — integers, exact.anchorCells++;const N = survive[m][k], T = total[k];if (BigInt(N) !== binomialBig(25 - m, k) || BigInt(T) !== binomialBig(25, k)) anchorErrors++;const opMult = exactMultiplierAtEdge(m, k, edge);         // C(25,k)·(1 − edge) / C(25−m,k)const rtpExact = { num: opMult.num * BigInt(N), den: opMult.den * BigInt(T) };if (!row || compareRational(rtpExact, row) !== 0) exactRtpErrors++;

Why this is non-circular: the survival probability comes from counting tile subsets, not from Duel’s data or from the same formula the multiplier uses. A cell whose real return fell below the figure Duel states for it would show up as an RTP claim miss on this step (4.2), not cancel away.

4.2RTP Claim Rule (RTP-CLAIM 1.2.0)

The claim and where it is published. Duel states the house edge for every stake tier of every (mines, reveals) cell in its game settings — one of the rule’s six places (game page, fairness page, help page, bet panel, rules, game settings). The claim is tiered: each cell is held to 1 − the edge of the first tier of its list, the tier a minimum stake falls in. That is 99.9% on 294 cells; the six full-board cash-outs (10–15 mines) have no 0.1% tier and are held to 99.86%, 99.82% or 99.79%.

How it is scored. The rule is scored on Step 16 against a ±0.1 pp band. A house-side miss would make the verdict RTP FIGURE OVERSTATED (exit 5) — a published figure above the game’s real return — never a fairness fail, because the draws themselves would still pass.

5 columns
MinesCellsFirst-tier edgeTheoretical RTPResult
1240.1%99.90%Pass
2230.1%99.90%Pass
3220.1%99.90%Pass
4210.1%99.90%Pass
5200.1%99.90%Pass
6190.1%99.90%Pass
7180.1%99.90%Pass
8170.1%99.90%Pass
9160.1%99.90%Pass
10150.1% · full board 0.14%99.90% · full board 99.86%Pass
11140.1% · full board 0.18%99.90% · full board 99.82%Pass
12130.1% · full board 0.21%99.90% · full board 99.79%Pass
13120.1% · full board 0.21%99.90% · full board 99.79%Pass
14110.1% · full board 0.18%99.90% · full board 99.82%Pass
15100.1% · full board 0.14%99.90% · full board 99.86%Pass
1690.1%99.90%Pass
1780.1%99.90%Pass
1870.1%99.90%Pass
1960.1%99.90%Pass
2050.1%99.90%Pass
2140.1%99.90%Pass
2230.1%99.90%Pass
2320.1%99.90%Pass
2410.1%99.90%Pass
src/rtp-claim-switch.ts + src/rtp-settings.ts · Verified
export const RTP_CLAIM_RULE_ENFORCED: boolean = true; export function computeRtpClaim(): RtpClaimResult {  const lists = settingsLists();  const acc = new RtpClaimAccumulator(RTP_CLAIM);  for (let m = 1; m <= GRID - 1; m++) {    for (let k = 1; k <= GRID - m; k++) {      const first = lists.get(`${m}:${k}`)?.[0];      if (!first) throw new Error(`rtp-settings: E14 has no tier list for mines=${m} depth=${k}`);      const edge = first.house_edge;      const pay = exactMultiplierAtEdge(m, k, edge);      acc.add(`mines=${m} k=${k}`, binomialBig(GRID - m, k) * pay.num, binomialBig(GRID, k) * pay.den,        edge === BASE_EDGE ? 'first tier 0.1% (E14)' : 'first tier above 0.1% (E14): full-board cash-outs', tierOf(edge));    }  }  return acc.result();}
Result: PASS. 0 of 300 cells beyond their band, 0 player-favourable; true minimum 99.79% (12 mines, 13 tiles and 13 mines, 12 tiles), true maximum 99.90%. No captured bet settled at the six full-board edges, so their 99.79–99.86% is the formula at Duel’s stated edge. The higher stake tiers are not tabled: Duel’s settings carry no multiplier, so a row there would be the formula held to its own edge. Full table: outputs/rtp-claim-table.json.
4.3House Edge Audit (Step 12)

Every bet response carries an effective_edge field. At the base tier the paid multiplier is C(25,k) / C(25−m,k) × (1 − effective_edge / 100). Step 12 requires effective_edge = 0.1 on all 6,500 primary bets, and Steps 8, 10 and 23 hold every served multiplier to the formula at that edge. Every captured bet was in the 0.1% tier: the largest potential profit of any captured bet was $9.21, and the closest a stake came to the tier limit was $10.00 against a limit of $27,139.87 (12 mines, first tile).

Result: effective_edge = 0.1 on 6,500 / 6,500 primary bets and on all 7,050 captured bets; 7,673 of 7,673 (bet, depth) pairs inside the 0.1% tier of Duel’s settings.
Variance note: Mines is high-variance at high mine counts: 24 mines pays 24.975× at a 4% win chance. Observed returns on small samples move a long way from 99.9%; the proof in 4.1 is the RTP evidence.
4.4Full RTP Table — All 24 Configurations

Pass 1 plays one reveal per round, so every configuration has the same theoretical RTP at the base edge, 99.9%. The simulated RTP varies by configuration with sampling variance, most for high mine counts where a rare, large multiplier dominates.

4 columns
ConfigTheoretical RTPSimulated RTPDeviation
mines=199.900%99.929%+0.029%
mines=299.900%99.906%+0.006%
mines=399.900%99.905%+0.005%
mines=499.900%99.946%+0.046%
mines=599.900%99.941%+0.041%
mines=699.900%99.876%−0.024%
mines=799.900%99.812%−0.088%
mines=899.900%99.858%−0.042%
mines=999.900%99.895%−0.005%
mines=1099.900%99.863%−0.037%
mines=1199.900%99.962%+0.062%
mines=1299.900%99.993%+0.093%
mines=1399.900%99.929%+0.029%
mines=1499.900%100.003%+0.103%
mines=1599.900%99.919%+0.019%
mines=1699.900%99.812%−0.088%
mines=1799.900%99.935%+0.035%
mines=1899.900%100.035%+0.135%
mines=1999.900%99.758%−0.142%
mines=2099.900%99.753%−0.147%
mines=2199.900%100.183%+0.283%
mines=2299.900%99.893%−0.007%
mines=2399.900%99.739%−0.161%
mines=2499.900%99.850%−0.050%
Result: Mean simulated RTP 99.904% across the 24 configurations, consistent with the theoretical 99.9%.
Variance note: High-mine configurations deviate more because the winning multiplier is large and rare. 21 mines (+0.283%) wins 16% of first reveals at 6.25× × 0.999; a few extra wins in 1M rounds move the mean noticeably.
4.5Simulation Pass 1 — Fresh Seeds (Step 18)

4.1 derives the RTP exactly. Pass 1 checks the implementation against it: 1,000,000 rounds per mine count through our spec-built RNG on pinned auditor seeds, opening tile nonce mod 25. The verifier re-derives every statistic from the artifact’s integer census and replays the first 10,000 rounds of each configuration.

Simulation Pass 1 — Fresh Seeds (Step 18) — illustrated flow

Mine positions: Observed tile frequencies against the uniform lattice, with the without-replacement correction. 0 / 24 configurations below the Bonferroni α/24 = 0.000417.

Serial independence: Lag-1 autocorrelation and a runs test on the win/loss sequence. 0 / 24 configurations flag.

RTP: Mean simulated RTP 99.904% against 99.900%, consistent with sampling variance.

src/simulate.ts · Pass 1 core loop · Verified
for (let nonce = 0; nonce < ROUNDS_PER_CONFIG; nonce++) {  const mines = computeMinePositionsFromBuffer(keyBuffer, seedPair.client, nonce, mineCount);   // Count mine position frequencies for chi-squared  for (const pos of mines) {    positionFreq[pos]++;  }   // Reveal tile = nonce % 25 (rotating tile strategy)  const revealTile = nonce % GRID_SIZE;  const mineSet    = new Set(mines);  const won        = !mineSet.has(revealTile);   if (won) {    totalWins++;    totalPayout += mult;  }  winSequence[nonce] = won ? 1 : 0;  // …}
Result: 24M rounds. No sign of positional bias or serial dependence; mean RTP 99.904%, consistent with the theoretical 99.9%.
4.6Cherry-Pick Detection — Pass 2 (Step 19)

Could Duel have chosen server seeds that play badly for players? Pass 2 replays every one of the 130 revealed casino seeds over 10,000 nonces. Tests A and B use a 3-mine board (88% win chance); Test C uses the configurations each epoch actually served, in nonce order, against the seed’s own 199 later windows. The early window of every seed is replayed from the revealed seed and equals the outcomes Duel served.

Stated power (Test C): if 10% of seeds had been chosen so their served window sat in the lowest 5% of its own null, the test would fail with probability 0.46; at 25%, 0.9999; at 50%, about 1.

False alarms: on a fair game the chance the step ends FLAG or worse is at most 0.0441, and FAIL at most 0.0047.

3 columns
TestResultMoves Step 19 to
Test A — chi-squared per seed, α = 0.011 / 130FAIL above 7.97
Test B — early (nonces 0–49) vs late window7 / 130, all isolated-earlyFLAG above 14, FAIL above 28
Seeds off in both windows (p < 0.05)0 / 130FLAG at 2, FAIL at 3
Test C — return of the served configurations3 / 130FAIL above 18.67
tests/steps/simulation.ts · Step 19 · Verified
const testCExpected = rows.length * alphaC;const testCBound = testCExpected + 5 * Math.sqrt(rows.length * alphaC * (1 - alphaC)) + 1;const power = [0.1, 0.25, 0.5].map(f => ({ fractionPicked: f,  detectionPower: binomialUpperTail(rows.length, alphaC + f * (1 - alphaC), testCBound) }));  // …const verdict = flags > failThreshold || broadFail || broadSevere > 0 || !testAOk || !testBOk || !testCOk ? 'FAIL'  : flags > threshold || broadFlag ? 'FLAG'  : 'PASS';
Result: PASS. All four rules sit well inside their bounds. The cherry-pick tests find no sign of seed selection. Without a public randomness beacon, seed choice before commitment remains operator trust; these tests are how it is checked.
4.7Stake Tiers — Scaling Edge (From the Config)

0.1% is Duel’s base edge, not a fixed rate. In Duel’s mines settings (fetched 5 October 2026, read-only), the edge is tiered by the potential profit at the current tile: up to $25,000 it is 0.1%, and above that it rises in 0.01% steps to 1.0%, where potential profit reaches Duel’s $250,000 maximum. Because potential profit grows with every safe tile, a round’s later tiles can fall in a higher tier than its first. The six full-board cash-outs at 10–15 mines pass $25,000 even at a $0.01 stake, so they start at 0.14–0.21%.

This is explained from the config, not certified. The settings carry no multiplier, and no captured bet left the 0.1% tier, so what the server pays above it was not observed. The settings were read in October 2026 and agree with every captured April round.

3 columns
Mines, tileStakes at the 0.1% edgeMax stake (1.0% edge)
1 mine, 1st tileup to $615k$8.0m
3 mines, 1st tileup to $185k$2.0m
12 mines, 1st tileup to $27.1k$277k
3 mines, 5th tileup to $24.6k$251k
24 mines, 1st tileup to $1,043$10,526
3 mines, 22nd tileup to $10.89$110
From the config: All 24 settings responses match their SHA-256 pins: 300 tier lists, 27,254 tiers, each list contiguous from a $0 stake, +0.01% per tier, ending at 1.0%. On every tier, max bet × (multiplier − 1) = $25,000,000 × the tier’s edge — consistent with the formula, not a verified payout.
4.8Bet-Size Invariance (Step 10)

Phase C placed 200 bets at $10 on 12 mines, the configuration also played at $0.01. Every layout recomputes, every $10 win pays stake × the formula multiplier to 1e-12 relative, and the served multiplier strings are identical to the $0.01 wins. Bet amount is not an input to the RNG.

3 columns
MetricPhase A ($0.01)Phase C ($10)
Bets4,800 (all 24 mine counts)200 (12 mines)
Bet amount$0.01$10.00
Layouts recomputed4,800 / 4,800200 / 200
Multiplier at 12 mines, k = 125/13 × 0.99925/13 × 0.999, identical strings
RNG pathHMAC-SHA256 Fisher-YatesHMAC-SHA256 Fisher-Yates
Result: Same RNG, same multiplier, same layouts at both stakes; 105 $10 wins, 0 errors.
4.9Informational Items (Not Scored)

Observed returns during the capture, for context only. At these sample sizes they show variance; the proof in 4.1 is the RTP evidence.

3 columns
ItemValueContext
Phase A observed RTP100.37%4,800 bets at $0.01, mines 1–24 (200 each)
Phase B observed RTP97.40%1,000 bets at $0.01, 24 mines
Phase C observed RTP100.86%200 bets at $10, 12 mines
Phase D observed RTP111.71%500 bets at $0.01, 10 player-set client seeds
Primary total100.86%6,500 bets, $2,063.00 wagered; the $10 phase dominates
Win-rate fit, 24 mine counts0 / 24 at α = 0.01Smallest p = 0.0345 (1 mine: 206 wins in 221 bets)
4.10Worked Example — Payout Verification

Real bet from Phase A — Round ID 25075415, 3 mines, nonce 6. Verified from mines-master-6500bets.json:

serverSeed  = 01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3
clientSeed  = NxcarOV28bkerHJk
nonce       = 6
mines_count = 3
revealed    = [0]
k           = 1

Step 1 — Mines: computeMinePositions(serverSeed, clientSeed, 6, 3) → 24 draws → mine set {5, 16, 21}

Step 2 — Win check: Tile 0 opened. 0 ∉ {5, 16, 21} → win

Step 3 — Multiplier: C(25,1) / C(22,1) × 0.999 = 25/22 × 0.999 = 1.135227×

Step 4 — Payout: 0.01 × 1.135227 = 0.011352

3 columns
StepProcessOutput
1Backward Fisher-Yates: 24 HMAC drawsmine set = {5, 16, 21} ✅
2Win check: opened tile in the mine set?0 ∉ {5,16,21} → win
3Multiplier: 25/22 × 0.9991.135227×
4RTP check: win chance × multiplier22/25 × 1.135227 = 0.999
5Payout: 0.01 × 1.1352270.011352 ✅
RTP proof for 3 mines, k = 1 · Verified
// mines=3, k=1// win chance = (25-3)/25 = 22/25 = 0.88// multiplier = 25/(25-3) × 0.999 = 25/22 × 0.999 = 1.135227273 // RTP = win chance × multiplier//     = 0.88 × 1.135227273//     = 0.999000000 (99.9%) ✅ // Exact cancellation://     (25-m)/25 × 25/(25-m) × 0.999 = 0.999
Parity verified: Round #25075415 — mine set, win condition, multiplier and payout all match. RTP for 3 mines is 99.9% at the base edge, independent of any casino data.
Live GameSET = {5,16,21}, win, payout = 0.011352
VerifierSET = {5,16,21}, win, payout = 0.011352
Technical Evidence & Verification5 sections
4.11Evidence Coverage Summary9 checks
3 columns
Verification AreaCoverageResult
Anti-circularity (Step 16)300 / 300 cells exact; float within 2.2 × 10⁻¹⁶Pass
RTP claim rule (Step 16)300 / 300 cells within ±0.1 pp of the stated edgePass
House edge audit (Step 12)effective_edge 0.1 on 6,500 / 6,500Pass
Multiplier formula (Steps 8, 20, 23)2,834 wins at k = 1, 1,173 reveal steps, 133 cash-outsPass
Simulation Pass 1 (Step 18)24M rounds; positions 0 / 24, serial 0 / 24Pass
Simulation Pass 2 (Step 19)130 seeds; Tests A, B, C inside their boundsPass
Bet-size invariance (Step 10)200 / 200 at $10Pass
Multiplier bounds (Step 25)276 + 276 ladder pairs increasing; 7,107 served values in rangePass
Stake tiers (informational)24 / 24 settings responses match their pins; all captured bets in the 0.1% tierInfo
4.12Code References7 source files
2 columns
FilePurpose
tests/steps/dataset.tsStep 16: counting anchor, exact identity, negative controls
src/exact.tsExact binomials, subset enumeration, multiplier at a stated edge
src/rtp-claim.tsThe framework’s RTP claim rule, version 1.2.0
src/rtp-settings.tsThe claim (Duel’s game settings) and the 300-cell table
src/scaling-edge.tsReads and checks Duel’s stake-tier settings
tests/steps/simulation.tsSteps 18–19: simulation integrity and cherry-pick tests
src/simulate.tsMonte Carlo simulation, Pass 1 and Pass 2
4.13Datasets UsedSource artifacts
Simulation: outputs/simulation-results.json — Pass 1 (24M rounds) and Pass 2 (130 seeds × 10,000 nonces)
RTP claim table: outputs/rtp-claim-table.json — all 300 cells against Duel’s stated edge
Game settings: evidence/settings/ — Duel’s 24 mines settings responses, fetched 5 October 2026, SHA-256 pinned
Primary dataset: data/mines-master-6500bets.json — served edge, Phase C invariance, observed returns
Phase E dataset: data/mines-phaseE-550bets.json — multipliers at k > 1
4.14Verified Invariants9 invariants
2 columns
InvariantResult
Counted survival = C(25−m,k)/C(25,k) on all 300 cellsPass
Counted survival × multiplier = 1 − edge exactly, all 300 cellsPass
Each cell’s RTP within ±0.1 pp of the edge Duel’s settings state for itPass
effective_edge = 0.1 on every primary betPass
Every served multiplier = the exact formula (relative 1e-12)Pass
Simulated mean RTP 99.904%, consistent with 99.9%Pass
No configuration flags on positions or serial tests (α/24)Pass
No sign of seed selection across 130 casino seedsPass
$10 and $0.01 wins served identical multipliersPass
4.15Reproduction InstructionsRun locally
reproduce-s4.sh · 5 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm test# Steps 8, 10, 12, 16, 18, 19, 20, 23 and the RTP claim cover S4
S4-related lines, as printed:

[PASS] Step 8 — Multiplier Formula (C(25,1)/C(25-m,1) × edge)
[PASS] Step 10 — Phase C Bet-Size Invariance ($10 bets)
[PASS] Step 12 — House Edge Audit (effective_edge = 0.1%)
[PASS] Step 16 — Probability Independence (Anti-Circularity)
[PASS] Step 18 — Simulation Results — Pass 1 Integrity
[PASS] Step 19 — Simulation Results — Pass 2 Cherry-Pick Test
[PASS] Step 20 — Multi-Reveal Multiplier Chain
[PASS] Step 23 — Cash-Out Payout Correctness (k>1)

rtp-claim: ENFORCED — PASS
rtp-claim:   band ±0.10 pp · 300 settings · true min 99.790000% (mines=12 k=13) · true max 99.900000% (mines=1 k=1)
rtp-claim:   house side beyond band: 0 · player-favourable beyond band: 0 · worst mines=1 k=1 at 0.000000 pp
rtp-claim:   outcome PASS · minimal fix: none — the claim holds for every setting it states a figure for
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 16 fairness integrity tests covering nonce integrity, seed commitment, outcome determinism, cross-player isolation, and payout integrity (including Mines-specific multi-step game-state checks). All 16 tests passed, including one Mines-specific multi-step state integrity test.

Fairness Integrity Testing

16pass

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 mine counts or grid sizes be submitted?
  • Mines-specific — can the same tile be revealed twice to advance the multiplier?

What this means for you

  • Across the 16 tests we ran, no API path allowed outcomes to be altered, replayed, or injected — by player or casino
  • Once a bet is placed, the mine layout 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
16pass
  • 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 mine counts or grid sizes be submitted?
  • Mines-specific — can the same tile be revealed twice to advance the multiplier?
4 / 4Nonce Integrity
5 / 5Seed Commitment
2 / 2Outcome Determinism
2 / 2Player Isolation
3 / 3Payout Integrity

Category Coverage

Nonce Integrity4/4
Seed Commitment5/5
Outcome Determinism2/2
Player Isolation2/2
Payout Integrity3/3
CheckResultEvidence
Nonce integrityPassSequential, server-controlled, 0 operator-side gaps or duplicates across 130 primary epochs; one Phase E nonce has no captured round (capture script, not Duel)
Seed commitment integrityPassLocked at bet acceptance, unique per epoch — 149/149 seed reveals verified across both datasets
Outcome determinismPassIdentical inputs produce identical mine sets — 7,050/7,050 confirmed including multi-reveal
Round & player isolationPassPer-user seeds, serial independence confirmed (0/24 fail in 24M-round simulation)
Payout integrityPassParameter limits enforced (5/5 invalid mineCount rejected); injected payout fields ignored (0 honoured); duplicate-reveal advancement blocked
Nonce integrityPass
Sequential, server-controlled, 0 operator-side gaps or duplicates across 130 primary epochs; one Phase E nonce has no captured round (capture script, not Duel)
Seed commitment integrityPass
Locked at bet acceptance, unique per epoch — 149/149 seed reveals verified across both datasets
Outcome determinismPass
Identical inputs produce identical mine sets — 7,050/7,050 confirmed including multi-reveal
Round & player isolationPass
Per-user seeds, serial independence confirmed (0/24 fail in 24M-round simulation)
Payout integrityPass
Parameter limits enforced (5/5 invalid mineCount rejected); injected payout fields ignored (0 honoured); duplicate-reveal advancement blocked
✓  All Fairness Guarantees Verified

16 fairness integrity tests: all 16 pass, including one Mines-specific multi-step state integrity test.

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, with Payout Integrity extended to cover Mines' multi-step reveal and cash-out surface. 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, cash-out manipulation
Player Isolation2Cross-round correlation, cross-user outcome dependence
Payout Integrity3Parameter enforcement, server-side computation, duplicate-reveal idempotency
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
Mine-set recomputation mismatchUndisclosed inputs affecting mine placement
Client seed not used in HMACPlayer has no influence on outcomes
Mine set changes during reveal sequencePer-reveal manipulation possible
Duplicate reveal advances payout multiplierMulti-step state corruption
Hard fail criteria: Any single hard fail = NOT PROVABLY FAIR. The audit cannot proceed past a hard fail without operator remediation and re-verification.

16 tests · 16 pass

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 mine-start requests. All 7 silently ignored; server assigned valid sequential nonces. Continuity preserved (baseline 21 → post-test 29); 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 — 6/7 invalid client seeds rejected (empty, null, special chars, emoji, CJK, whitespace-only). Oversized seed (>1000 chars) accepted — permissive but safe (long entropy). All Mines 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 ~52 seconds. All 10 server seed hashes distinct; no two shared 6+ leading hex characters. Time-correlated derivation ruled out.

Outcome Determinism2/2
FI-OUTCOME-002Pass

A completed bet cannot be replayed to generate a duplicate payout — mine set is cryptographically fixed at bet time and cash-out payouts are deterministically bound to the formula

S3, Steps 21 & 23 — mine layout fixed at round start (unchanged by reveal sequence across 550 multi-reveal bets); 133 multi-reveal cash-outs at k ∈ {2, 3, 5} verified: multiplier = C(25,k)/C(25−m,k), payout = amount × mult × 0.999, 0 errors. The server cannot re-credit a finished bet because the mine set, reveal count, and multiplier are all determined by the seed triple at bet time.

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 Integrity3/3
FI-PAYOUT-001Pass

Game parameters cannot exceed defined limits — only valid mine counts (1–24) for the 25-tile grid are accepted

API probe — 5/5 invalid minesCount values rejected with HTTP 422 (0, 25, 26, −1, 'abc'). All 3 valid boundary bets (minesCount=1, 3, 24) 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 the combinatorial formula, not from client-supplied values

API probe — 5 injected fields (multiplier='9999', mines_positions, is_win, amount_won, cashout_amount) all silently ignored. Server computed mine positions and payout values independently from the seed pair on every request. noInjectionHonoured=true.

FI-MINES-STATE-002Pass

Revealing the same tile twice does not advance the payout multiplier — the server must reject duplicate reveals or return an idempotent response (Mines-specific multi-step state integrity)

API probe — game started, safe tile revealed (multiplier 1.0416…), duplicate reveal of same tile rejected with HTTP 400. Multiplier did not advance from first-reveal value; cashout at first-reveal multiplier completed normally. multiplierAdvanced=false.

Technical Evidence & Verification4 sections
5.3Coverage Summary16 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, Steps 5, 21, 22 (data-driven)Pass
FI-OUTCOME-002DeterminismS3, Steps 21 & 23 (data-driven)Pass
FI-ISO-001IsolationS2, Step 18 (simulation)Pass
FI-ISO-002IsolationStructural — seed uniquenessPass
FI-PAYOUT-001PayoutAPI probePass
FI-PAYOUT-002PayoutAPI probePass
FI-MINES-STATE-002PayoutAPI probePass
Method breakdown: 9 tests verified via verification suite steps and structural analysis, 7 tests verified via direct API probes against the running game. The Mines-specific game-state test (FI-MINES-STATE-002) covers the multi-step reveal/cash-out surface and is grouped under Payout Integrity alongside the standard parameter-enforcement and field-injection tests. All 16 tests pass.
5.4Additional Integrity Evidence (S1–S4)8 records
3 columns
PropertySourceFinding
149/149 seed hashes verifiedS1, Step 1Commit-reveal chain intact
133/133 + 16/16 rotation linksS1, Step 2Seed rotation chain intact
6,500/6,500 exact parity (primary) + 550/550 Phase ES3, Steps 5 & 21No post-RNG conditional logic, mine set fixed at round start
Anti-circularity proven (algebraic)S4, Step 160.1% house edge from first principles
Test A 1/130, Test B 7/130, Test C 3/130S4, Step 19 (Pass 2)No seed pre-selection bias
99.4% client seed influence (646/650)S1, Step 6Player entropy is genuine
133 cash-outs verified at k ∈ {2,3,5}S3, Step 23Multi-step payout integrity intact
1,173 reveal steps verified across k ∈ {1..5}S3, Step 20Multi-reveal multiplier chain correct
5.5Scope

This certification covers the 16 fairness integrity tests listed above — the minimum required to verify that the provably fair implementation holds up under non-standard conditions, including one Mines-specific multi-step state integrity test under Payout Integrity. This is not a penetration test. It focuses specifically on the provably fair implementation — not the operator's broader platform security.

Standard scope: The 16 tests above are our standard Mines fairness integrity matrix. The base list is applied to every game we audit, with per-game adaptations where a test does not apply (and additions where multi-step game state requires extra coverage — Mines includes FI-MINES-STATE-002 for duplicate-reveal idempotency, which is not applicable to single-step games).

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 (9 of 16): Fully reproducible from the open-source repo. These tests run against the captured dataset and produce deterministic results.

API probe tests (7 of 16): Verified by issuing live adversarial requests against the running game. Per-test evidence (HTTP status codes, server-assigned nonces, seed hashes, server-computed multipliers, mine-set decisions) 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-mines.gitcd duel-minesgit checkout v1.2.2npm test
Expected output (S5-related steps):

[PASS] Step 1  — Seed Hash Integrity                        → FI-SEED-003
[PASS] Step 3  — Hash Consistency Within Epoch              → FI-SEED-002
[FLAG:capture] Step 4 — Nonce Audit                         → FI-NONCE-001, 002, 004
[PASS] Step 5  — Mine Position Recomputation                → FI-OUTCOME-001
[PASS] Step 6  — Client Seed Influence                      → FI-SEED-002
[PASS] Step 18 — Simulation Results — Pass 1 Integrity      → FI-ISO-001
[PASS] Step 20 — Multi-Reveal Multiplier Chain              → FI-OUTCOME-001 (multi-reveal)
[PASS] Step 21 — Mine-Set Invariance Across Reveals         → FI-OUTCOME-001, 002
[PASS] Step 22 — Reveal-Position Independence (Phase E5)    → FI-OUTCOME-001
[PASS] Step 23 — Cash-Out Payout Correctness (k>1)          → FI-OUTCOME-002

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 → 6/7 rejected; oversized accepted[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 mineCount handling  → 5/5 boundary violations rejected (HTTP 422)[PASS] FI-PAYOUT-002      — Field injection handling    → 0 injections honoured[PASS] FI-MINES-STATE-002 — Duplicate reveal idempotency → multiplier did not advance, HTTP 400 on duplicate
API probes: All 7 API probe tests completed. Per-test evidence — requests, server responses, HTTP status codes, server-assigned nonces and seed hashes, multiplier values — 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 Mines layout can be recomputed from inputs the player can see: the server seed revealed after rotation, the client seed, the nonce and the mine count. Save the server seed hash before your first bet on a seed. A revealed seed that hashes to your saved copy is the seed that was fixed before you played. This section walks through the steps, with an independent verifier and a script you can run yourself.

Independent Result Verification

4 Stepsto verify any bet

Key principles

  • Save the server seed hash before your first bet on a seed: your own copy is what shows the seed was fixed in advance
  • Every Mines layout recomputes from inputs you can see; no hidden input goes in
  • If the revealed seed hashes to your saved copy and the recomputed mine set matches, the round is the one that seed produces
  • The ProvablyFair.org verifiers returned the served layout on all 7,050 captured rounds

What you need

  • Server Seed — revealed in the transaction detail after you rotate the seed pair
  • Client Seed — your player-controlled seed
  • Nonce — the bet number within the seed pair (starts at 0, one per round)
  • Mine Count — the number of mines you chose for the round (1–24)
4 Stepsto verify any bet
  • Save the server seed hash before your first bet on a seed: your own copy is what shows the seed was fixed in advance
  • Every Mines layout recomputes from inputs you can see; no hidden input goes in
  • If the revealed seed hashes to your saved copy and the recomputed mine set matches, the round is the one that seed produces
  • The ProvablyFair.org verifiers returned the served layout on all 7,050 captured rounds
From Saved Hash to Independent Verification — 4-step flow — illustrated flow
Server SeedRevealed after rotation
Client SeedPlayer-controlled input
NonceRecorded bet sequence
Mine Count1–24, as played
  1. 1

    Save the Hash Before You Bet

    Open the Provably Fair panel on the game page. It shows your client seed, the hashed server seed and your nonce. Before your first bet on a seed, copy the full hash with the field’s copy button (the panel can shorten it on screen) and keep it.

  2. 2

    Play, Then Rotate

    Choose your mine count (1–24) and play. When you want to check your rounds, press Rotate seed: the server seed you played on is retired, and the next pair, whose hash the panel already showed, becomes active. Save that hash too before you bet on it.

  3. 3

    Open a Past Bet

    Open Transactions and click a past Mines round. After the rotation, its transaction detail shows the revealed server seed with the client seed and nonce.

  4. 4

    Recompute & Confirm

    Enter the revealed server seed, the hash you saved, the client seed, nonce and mine count in the ProvablyFair.org verifier. It checks the hash and recomputes the mine set, which must match your round.

Visual Walkthroughstep-by-step
6.1Step 1: Save the Hash Before You Bet

Open the Provably Fair panel on the game page. It shows your active client seed, the hashed server seed (Duel’s commitment), your nonce and the hash of the next seed pair. Before your first bet on a seed, copy the full hash with the field’s copy button (the panel can shorten it on screen) and keep it. That saved copy is what lets you check later that the seed was fixed before you played.

Provably Fair panel — active client seed, hashed server seed, nonce, a new client seed you can set, the next pair’s hash, and Rotate seed.

Provably Fair panel — active client seed, hashed server seed, nonce, a new client seed you can set, the next pair’s hash, and Rotate seed.

6.2Step 2: Place a Mines Bet

Choose your mine count (1–24) and play. The layout is fixed when the round starts: it depends only on the server seed, your client seed, the nonce and the mine count, not on which tiles you open or in what order. When you want to check your rounds, press Rotate seed. The seed you played on is retired and the next pair becomes active; save its hash before you bet on it.

Duel.com Mines — 25-tile grid with the mine-count selector. The layout is fixed when the round starts.

Duel.com Mines — 25-tile grid with the mine-count selector. The layout is fixed when the round starts.

6.3Step 3: Open a Past Bet to Reveal the Seed

Open Transactions and click a past Mines round. After the rotation, its transaction detail shows the revealed server seed with the bet ID, client seed and nonce. SHA-256 of the revealed seed, hashed as the 32 bytes its hex encodes, must equal the hash you saved:

Server Seed (revealed) — the plaintext behind the commitment. Hash it and compare it with your saved copy.

Client Seed — your player-controlled input.

Nonce — the bet counter for this seed pair.

Per-bet transaction detail — revealed server seed, client seed and nonce for the round.

Per-bet transaction detail — revealed server seed, client seed and nonce for the round.

6.4Step 4: Recompute & Confirm

Click Verify in the per-bet detail to open Duel’s Provably Fair page with the seeds filled in; it recomputes the mine positions inline. For a check that does not rely on Duel’s page, enter the same values and the hash you saved in the ProvablyFair.org verifier, which returned the served layout on all 7,050 captured rounds. If the recomputed mine set matches your round, the result is the one that seed pair and nonce produce.

Duel’s Provably Fair page — seeds filled in from the per-bet detail, recomputed mine set shown inline.

Duel’s Provably Fair page — seeds filled in from the per-bet detail, recomputed mine set shown inline.

Manual Verification (Advanced)7 sections
6.5Why Manual Verification Matters

Manual verification needs no casino tool and no verifier you have to trust. The calculation runs on your own machine, from the specification in the release, and you can read every line of it.

6.6How the Algorithm Works (Plain English)

Four inputs fix the mine layout before you reveal anything:

  • The server seed — Duel’s secret, committed by showing its SHA-256 hash before you bet
  • Your client seed — generated in your browser by default; you can set your own
  • The nonce — a counter that makes each round unique
  • The mine count — how many mines you chose (1–24)

For each of 24 draws, HMAC-SHA256 keyed with the server seed mixes your client seed, the nonce and the draw number. Each draw picks a swap index without bias, and a backward Fisher-Yates shuffle reorders the 25 tiles; the first tiles, as many as your mine count, are the mines. The tiles you open, their order and when you cash out do not change the layout. The next seed’s hash is shown before you set a new client seed, so Duel cannot pick a seed to suit yours without the revealed seed failing the hash you saved.

6.7Casino Verifier vs ProvablyFair.org Verifier4 records

Both tools should give the same mine set. If they ever differ, something has changed.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent, open source
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Checked in this auditPublished code run unmodified on 7,050 rounds; the live button not testedBoth run on all 7,050 captured rounds, 0 mismatches; SHA-256 pinned
Trust modelRequires trusting the casinoOpen source and pinned: anyone can check it
6.8JavaScript Verification Script

The audit package’s own script. Paste your values into the six constants and run it with Node.js. Use the hash you saved before betting, not one read after the reveal:

verify-round.js · Node.js, no dependencies
// node verify-round.js — paste your values into the six constants// serverSeedHashed: the hash you saved from the Provably Fair panel BEFORE bettingconst crypto = require('crypto');const serverSeed = '', serverSeedHashed = '', clientSeed = '', nonce = 0, mines_count = 0;const mines_positions = []; const key = Buffer.from(serverSeed, 'hex');const hashMatches = crypto.createHash('sha256').update(key).digest('hex') === serverSeedHashed;const tiles = Array.from({ length: 25 }, (_, t) => t);for (let i = 0; i < 24; i++) {  const r = 25 - i, limit = Math.floor(2 ** 32 / r) * r;  const h = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${i}`).digest();  let j = -1;  for (let off = 0; off < 32 && j < 0; off += 4) { const v = h.readUInt32BE(off); if (v < limit) j = v % r; }  if (j < 0) throw new Error('all eight chunks rejected: not specified (docs/ALGORITHM.md O1)');  [tiles[r - 1], tiles[j]] = [tiles[j], tiles[r - 1]];}const mines = tiles.slice(0, mines_count).sort((a, b) => a - b);console.log({ hashMatches, mines, matches: JSON.stringify(mines) === JSON.stringify([...mines_positions].sort((a, b) => a - b)) });
Checked: On the worked vector below it prints hashMatches: true and matches: true.
6.9Python Verification Script

The same steps in Python, standard library only:

verify_round.py · Python 3, standard library
# python3 verify_round.py — paste your values into the six constants# server_seed_hashed: the hash you saved from the Provably Fair panel BEFORE bettingimport hashlib, hmac server_seed, server_seed_hashed, client_seed, nonce, mines_count = '', '', '', 0, 0mines_positions = [] key = bytes.fromhex(server_seed)hash_matches = hashlib.sha256(key).hexdigest() == server_seed_hashedtiles = list(range(25))for i in range(24):    r = 25 - i    limit = (2 ** 32 // r) * r    h = hmac.new(key, f'{client_seed}:{nonce}:{i}'.encode(), hashlib.sha256).digest()    j = next((v % r for v in (int.from_bytes(h[off:off + 4], 'big') for off in range(0, 32, 4)) if v < limit), None)    if j is None:        raise ValueError('all eight chunks rejected: not specified (docs/ALGORITHM.md O1)')    tiles[r - 1], tiles[j] = tiles[j], tiles[r - 1]mines = sorted(tiles[:mines_count])print({'hash_matches': hash_matches, 'mines': mines, 'matches': mines == sorted(mines_positions)})
Checked: Run on all 7,050 captured rounds, it confirms the hash and the served mine set on every one.
6.10Worked Example3 records

A captured round: server seed b255e0f55d255669bbd42a777b0e6b6570027b058d1db571df57325a2269a75f, client seed EveJlkDtA24dfvBr, nonce 0, 14 mines. Its commitment, SHA-256 of the seed bytes, is eecc6f36cd2e55109959a19a9667bfcccf27e8a75842bd800d77ed054766ff30. The first three swaps:

6 columns
Draw irMessageFirst chunkjSwap
025EveJlkDtA24dfvBr:0:00xd8c82daa = 363699754621tiles[24] ↔ tiles[21]
124EveJlkDtA24dfvBr:0:10xa6cb9b87 = 279836147923no-op
223EveJlkDtA24dfvBr:0:20x291cf2f0 = 6897630562tiles[22] ↔ tiles[2]

After all 24 swaps the first 14 tiles, sorted, are [1, 4, 5, 7, 8, 13, 14, 15, 16, 17, 19, 20, 22, 24], exactly the served mines_positions.

6.11Evidence Screenshots5 records
2 columns
EvidenceDescription
client-seed-origin.pngDuel’s live game code, where the default client seed is drawn in the browser with crypto.getRandomValues
E02Duel.com fairness page overview
E03Mines verification tab on the fairness page, code panel collapsed
E04Provably Fair panel with an active server seed hash at nonce 0 (illustrative: its seeds are not in the dataset)
E09The same panel after rotating: E04’s next hash and new client seed are now active (illustrative)
From Saved Hash to Independent Verification — 4-step flow — illustrated flow
How it works
  1. 1

    Save the Hash Before You Bet

    Open the Provably Fair panel on the game page. It shows your client seed, the hashed server seed and your nonce. Before your first bet on a seed, copy the full hash with the field’s copy button (the panel can shorten it on screen) and keep it.

  2. 2

    Play, Then Rotate

    Choose your mine count (1–24) and play. When you want to check your rounds, press Rotate seed: the server seed you played on is retired, and the next pair, whose hash the panel already showed, becomes active. Save that hash too before you bet on it.

  3. 3

    Open a Past Bet

    Open Transactions and click a past Mines round. After the rotation, its transaction detail shows the revealed server seed with the client seed and nonce.

  4. 4

    Recompute & Confirm

    Enter the revealed server seed, the hash you saved, the client seed, nonce and mine count in the ProvablyFair.org verifier. It checks the hash and recomputes the mine set, which must match your round.

Visual Walkthroughstep-by-step
6.1Step 1: Save the Hash Before You Bet

Open the Provably Fair panel on the game page. It shows your active client seed, the hashed server seed (Duel’s commitment), your nonce and the hash of the next seed pair. Before your first bet on a seed, copy the full hash with the field’s copy button (the panel can shorten it on screen) and keep it. That saved copy is what lets you check later that the seed was fixed before you played.

Provably Fair panel — active client seed, hashed server seed, nonce, a new client seed you can set, the next pair’s hash, and Rotate seed.

Provably Fair panel — active client seed, hashed server seed, nonce, a new client seed you can set, the next pair’s hash, and Rotate seed.

6.2Step 2: Place a Mines Bet

Choose your mine count (1–24) and play. The layout is fixed when the round starts: it depends only on the server seed, your client seed, the nonce and the mine count, not on which tiles you open or in what order. When you want to check your rounds, press Rotate seed. The seed you played on is retired and the next pair becomes active; save its hash before you bet on it.

Duel.com Mines — 25-tile grid with the mine-count selector. The layout is fixed when the round starts.

Duel.com Mines — 25-tile grid with the mine-count selector. The layout is fixed when the round starts.

6.3Step 3: Open a Past Bet to Reveal the Seed

Open Transactions and click a past Mines round. After the rotation, its transaction detail shows the revealed server seed with the bet ID, client seed and nonce. SHA-256 of the revealed seed, hashed as the 32 bytes its hex encodes, must equal the hash you saved:

Server Seed (revealed) — the plaintext behind the commitment. Hash it and compare it with your saved copy.

Client Seed — your player-controlled input.

Nonce — the bet counter for this seed pair.

Per-bet transaction detail — revealed server seed, client seed and nonce for the round.

Per-bet transaction detail — revealed server seed, client seed and nonce for the round.

6.4Step 4: Recompute & Confirm

Click Verify in the per-bet detail to open Duel’s Provably Fair page with the seeds filled in; it recomputes the mine positions inline. For a check that does not rely on Duel’s page, enter the same values and the hash you saved in the ProvablyFair.org verifier, which returned the served layout on all 7,050 captured rounds. If the recomputed mine set matches your round, the result is the one that seed pair and nonce produce.

Duel’s Provably Fair page — seeds filled in from the per-bet detail, recomputed mine set shown inline.

Duel’s Provably Fair page — seeds filled in from the per-bet detail, recomputed mine set shown inline.

Technical evidence
6.5Why Manual Verification Matters

Manual verification needs no casino tool and no verifier you have to trust. The calculation runs on your own machine, from the specification in the release, and you can read every line of it.

6.6How the Algorithm Works (Plain English)

Four inputs fix the mine layout before you reveal anything:

  • The server seed — Duel’s secret, committed by showing its SHA-256 hash before you bet
  • Your client seed — generated in your browser by default; you can set your own
  • The nonce — a counter that makes each round unique
  • The mine count — how many mines you chose (1–24)

For each of 24 draws, HMAC-SHA256 keyed with the server seed mixes your client seed, the nonce and the draw number. Each draw picks a swap index without bias, and a backward Fisher-Yates shuffle reorders the 25 tiles; the first tiles, as many as your mine count, are the mines. The tiles you open, their order and when you cash out do not change the layout. The next seed’s hash is shown before you set a new client seed, so Duel cannot pick a seed to suit yours without the revealed seed failing the hash you saved.

6.7Casino Verifier vs ProvablyFair.org Verifier4 records

Both tools should give the same mine set. If they ever differ, something has changed.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent, open source
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Checked in this auditPublished code run unmodified on 7,050 rounds; the live button not testedBoth run on all 7,050 captured rounds, 0 mismatches; SHA-256 pinned
Trust modelRequires trusting the casinoOpen source and pinned: anyone can check it
6.8JavaScript Verification Script

The audit package’s own script. Paste your values into the six constants and run it with Node.js. Use the hash you saved before betting, not one read after the reveal:

verify-round.js · Node.js, no dependencies
// node verify-round.js — paste your values into the six constants// serverSeedHashed: the hash you saved from the Provably Fair panel BEFORE bettingconst crypto = require('crypto');const serverSeed = '', serverSeedHashed = '', clientSeed = '', nonce = 0, mines_count = 0;const mines_positions = []; const key = Buffer.from(serverSeed, 'hex');const hashMatches = crypto.createHash('sha256').update(key).digest('hex') === serverSeedHashed;const tiles = Array.from({ length: 25 }, (_, t) => t);for (let i = 0; i < 24; i++) {  const r = 25 - i, limit = Math.floor(2 ** 32 / r) * r;  const h = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${i}`).digest();  let j = -1;  for (let off = 0; off < 32 && j < 0; off += 4) { const v = h.readUInt32BE(off); if (v < limit) j = v % r; }  if (j < 0) throw new Error('all eight chunks rejected: not specified (docs/ALGORITHM.md O1)');  [tiles[r - 1], tiles[j]] = [tiles[j], tiles[r - 1]];}const mines = tiles.slice(0, mines_count).sort((a, b) => a - b);console.log({ hashMatches, mines, matches: JSON.stringify(mines) === JSON.stringify([...mines_positions].sort((a, b) => a - b)) });
Checked: On the worked vector below it prints hashMatches: true and matches: true.
6.9Python Verification Script

The same steps in Python, standard library only:

verify_round.py · Python 3, standard library
# python3 verify_round.py — paste your values into the six constants# server_seed_hashed: the hash you saved from the Provably Fair panel BEFORE bettingimport hashlib, hmac server_seed, server_seed_hashed, client_seed, nonce, mines_count = '', '', '', 0, 0mines_positions = [] key = bytes.fromhex(server_seed)hash_matches = hashlib.sha256(key).hexdigest() == server_seed_hashedtiles = list(range(25))for i in range(24):    r = 25 - i    limit = (2 ** 32 // r) * r    h = hmac.new(key, f'{client_seed}:{nonce}:{i}'.encode(), hashlib.sha256).digest()    j = next((v % r for v in (int.from_bytes(h[off:off + 4], 'big') for off in range(0, 32, 4)) if v < limit), None)    if j is None:        raise ValueError('all eight chunks rejected: not specified (docs/ALGORITHM.md O1)')    tiles[r - 1], tiles[j] = tiles[j], tiles[r - 1]mines = sorted(tiles[:mines_count])print({'hash_matches': hash_matches, 'mines': mines, 'matches': mines == sorted(mines_positions)})
Checked: Run on all 7,050 captured rounds, it confirms the hash and the served mine set on every one.
6.10Worked Example3 records

A captured round: server seed b255e0f55d255669bbd42a777b0e6b6570027b058d1db571df57325a2269a75f, client seed EveJlkDtA24dfvBr, nonce 0, 14 mines. Its commitment, SHA-256 of the seed bytes, is eecc6f36cd2e55109959a19a9667bfcccf27e8a75842bd800d77ed054766ff30. The first three swaps:

6 columns
Draw irMessageFirst chunkjSwap
025EveJlkDtA24dfvBr:0:00xd8c82daa = 363699754621tiles[24] ↔ tiles[21]
124EveJlkDtA24dfvBr:0:10xa6cb9b87 = 279836147923no-op
223EveJlkDtA24dfvBr:0:20x291cf2f0 = 6897630562tiles[22] ↔ tiles[2]

After all 24 swaps the first 14 tiles, sorted, are [1, 4, 5, 7, 8, 13, 14, 15, 16, 17, 19, 20, 22, 24], exactly the served mines_positions.

6.11Evidence Screenshots5 records
2 columns
EvidenceDescription
client-seed-origin.pngDuel’s live game code, where the default client seed is drawn in the browser with crypto.getRandomValues
E02Duel.com fairness page overview
E03Mines verification tab on the fairness page, code panel collapsed
E04Provably Fair panel with an active server seed hash at nonce 0 (illustrative: its seeds are not in the dataset)
E09The same panel after rotating: E04’s next hash and new client seed are now active (illustrative)
✓  Any Player Can Reproduce Mines Results

Only disclosed inputs are used, and identical inputs always give the same layout. Save the hash before you bet and the timing is yours to check too.

07

Reproducibility & Artifacts

Can anyone independently reproduce every finding in this audit?

All 26 scored steps ship as code in the open-source release. Check out v1.2.2 and run npm test: there is nothing to install, and in about 80 seconds it re-verifies all 7,050 live bets and compares its results field by field with the committed ones. The repository is the credential, not this report.

Open-Source Audit Repository

v1.2.2release tag

Repository Details

Prerequisites

  • Node.js 22.x (.nvmrc)
  • Git
  • Nothing to install for npm test
  • npm ci only for the optional toolchain
v1.2.2release tag
github.com/ProvablyFair-org/duel-minesRelease v1.2.2 · original audit 6927bec

Commands to Reproduce

Clone the release tag and confirm its release manifest: artifact hashes, verdict and scored counts. Node 22.x; nothing to install.

sh
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2node scripts/release-manifest.mjs --check
Expected output
  [release-manifest] OK: 9 artifact hashes match disk, verdict "PROVABLY FAIR — Full Pass", scored 25/26 (flags 1)

Audit Reproducibility Pinning

Release
v1.2.2 · commit 25cc963321e40da6890ceb513bc01ed39406168d
Original Audit
commit 6927bec239024666a22a4767ec5c28461a857063 · 4 June 2026
Framework
1.1 · Mines profile 1.0.2
Node Version
22.x (.nvmrc)
Primary Dataset
data/mines-master-6500bets.json (6,500 bets, 130 epochs)
Primary Dataset Hash (SHA-256)
331f74ff98b88d06242d57e806186548612f13c4269eb754ebb571d8a6fc9b20
Phase E Dataset
data/mines-phaseE-550bets.json (550 bets, 12 epochs)
Phase E Dataset Hash (SHA-256)
def563907949db10d584256a13b33102dfa46d33509424f642f803d74cd1b17b
RNG Code (SHA-256)
src/rng.ts · 408e4640c2328bc267d70df967fbabb54b2bb0e532cb34f9199b9f8ddc546df3
Capture Window
16–21 April 2026 (UTC)
Runtime
npm test 81 s (Apple M2 Max, Node 22.23.1)
Mutation Battery
47 / 47 must-fail mutations caught by their named step; all 26 scored steps reached
Signed Tag
v1.2.2, ProvablyFair.org SSH key SHA256:gEujiJm2pRyq7lQsfYQfQ1r97H/J7GdaKHbOW8GtikY
Audit ID
PF-2026-DL04
Output Artifacts7 files · SHA-256 pinned
3 columns
FileContentsSHA-256
verification-results.jsonAll 26 scored steps: status, detail, profile checks and informational items2c7912464ab85ecb…
rtp-claim-table.jsonAll 300 (mines, reveals) cells against the edge Duel’s game settings state499c4f3dd1167550…
simulation-results.json24M-round Pass 1 census and per-config RTP; Pass 2 on 130 casino seeds8f628aa69a303ebc…
payout-coverage.jsonPayout-cell coverage: 33 of 300 (mines, reveals) cells reached in live play; the 267 others listed with their chance of being reached32bfe33cf0a4ca62…
chi-squared-results.jsonWin rate per mine count against the binomialc73aa5b90fc626c6…
determinism-log.jsonLayout recomputation tally: 6,500 verified, 0 mismatches12c39c309bbb7539…
rtp-convergence.htmlInteractive RTP convergence chart, self-contained4d5cadeca0ab206d…
Repository Structure
duel-mines/  (v1.2.2)
├── src/
│   ├── rng.ts                  → HMAC-SHA256 backward Fisher-Yates, built from docs/ALGORITHM.md
│   ├── exact.ts                → Exact binomials, subset counting, multipliers
│   ├── rtp-claim.ts            → The framework’s RTP claim rule (1.2.0)
│   ├── rtp-settings.ts         → The claim: Duel’s game settings, 300-cell table
│   ├── scaling-edge.ts         → Reads and checks Duel’s stake-tier settings
│   ├── operator-verifier.ts    → Runs Duel’s Verify-tab code unmodified (cross-check)
│   ├── site-verifier.ts        → Pins and runs the ProvablyFair.org site verifier
│   ├── live-site-verifier.ts   → Pins and runs the www.provablyfair.org verifier bundle
│   ├── simulate.ts · sim-plan.ts → Monte Carlo, 1M rounds × 24 configs; pinned seeds
│   ├── artifact-pins.ts        → SHA-256 pins of the artifacts of record
│   └── loader.ts               → Datasets, SHA-256 guard, capture plan
├── tests/
│   ├── verify.ts               → 26 scored steps
│   ├── steps/                  → commitment, determinism, payouts, dataset, simulation,
│   │                             multireveal, artifacts, bounds
│   ├── mines/                  → 32 unit tests (Mocha and the zero-install bundle)
│   └── mutations.json          → 47 must-fail mutations
├── data/
│   ├── mines-master-6500bets.json  → 6,500 primary bets (Phases A–D, 130 epochs)
│   └── mines-phaseE-550bets.json   → 550 multi-reveal bets (Phase E, 12 epochs)
├── outputs/                    → Committed results of record
│   └── run/                    → Your run writes here, never over the record
├── evidence/                   → Screenshots, Duel’s settings, Duel’s Verify-tab code
├── verifier-parity/            → Pinned copies of the ProvablyFair.org verifiers
├── docs/ALGORITHM.md           → The written specification
├── capture/                    → Reference records of the capture scripts
├── verify.js · test.js         → Zero-install bundles
├── README.md · MANIFEST.md
└── RELEASE-MANIFEST.json       → Artifact hashes, verdict, signing key
Step-to-Section Cross-Reference26 scored steps mapped
3 columns
StepTest NameReport Section
1Seed Hash IntegrityS1
2Next-Seed Promotion (Commitment Linkage)S1
3Hash Consistency Within EpochS1, S5
4Nonce AuditS1, S5
5Mine Position RecomputationS2, S3, S6
6Client Seed InfluenceS1
7Payout MathS3, S5
8Multiplier Formula (C(25,1)/C(25-m,1) × edge)S3, S4
9Win Condition (tile not in mines)S3, S5
10Phase C Bet-Size Invariance ($10 bets)S3, S4
11Config Completeness & Payout-Cell CoverageS3
12House Edge Audit (effective_edge = 0.1%)S4
13Population & Phase LabelsS3
14Dataset HashS1, S7
15Epoch SizeS1, S3
16Probability Independence (Anti-Circularity)S4
17Phase D — Client Seed VariationS1
18Simulation Results — Pass 1 IntegrityS2, S4
19Simulation Results — Pass 2 Cherry-Pick TestS4
20Multi-Reveal Multiplier ChainS3, S4
21Mine-Set Invariance Across Reveals (per-step, order-independent)S3, S5
22Reveal-Position Independence (Phase E5)S3
23Cash-Out Payout Correctness (k>1)S3, S4, S5
24Artifact Integrity (pinned artifacts of record)S7
25Multiplier Monotonicity & BoundsS3, S4
26Live-Sample Fit (win rate & mine positions)S2
Exit Codes0 · 1 · 2 · 5

The exit code is the verdict, so a script or CI job can read it directly.

3 columns
CodeVerdictWhen
0PROVABLY FAIR — Full PassEvery step passes and the run reproduces the committed results. A capture flag, a gap in our own capture, leaves it at 0
2PROVABLY FAIR — Conditional PassAt least one operator-side flag
5RTP FIGURE OVERSTATEDNo draw check failed, but a published RTP figure is above the game’s real return beyond the ±0.1 pp band
1NOT PROVABLY FAIRAt least one hard fail, or a reproduction difference beyond tolerance
Reproduction Gateoutputs/run/

An ordinary run writes nothing into outputs/. Its results, determinism log, chi-squared table and diff.json go to outputs/run/, so a re-run can never replace the evidence it scores. outputs/run/diff.json compares the run with the committed artifacts field by field: 1e-14 absolute + 1e-12 relative, and two distinct integers never agree.

2 columns
Committed artifactDifferences in our run
outputs/verification-results.json0
outputs/determinism-log.json0
outputs/chi-squared-results.json0
outputs/payout-coverage.json0

Result: REPRODUCED, 0 fields beyond tolerance.

Release History6 entries

The dataset is the same in every release.

3 columns
ReleaseWhat changedVerdict
6927bec · 4 June 2026Original audit published: 23 scored stepsPROVABLY FAIR — Full Pass
v1.0.0Original audit tagged, with artifact pinning (24 steps)Unchanged
v1.1.0Re-certified under Framework 1.1: 26 scored steps, the RTP claim rule, the Phase E nonce auditUnchanged
v1.2.0RNG code rebuilt from the written specification; Duel’s Verify-tab code kept as a cross-checkUnchanged
v1.2.1Line-ending fix so a Windows clone stays byte-identical; no audit content changedUnchanged
v1.2.2Documentation fix: a check label used in the notes is now defined in MANIFEST.md, and an undefined one is removed from a code comment; no audit content changedUnchanged
reproduce-audit.sh
reproduce-audit.sh
# Clone the releasegit clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2 # Run the audit: no install needed (Node 22.x)npm test # Optional: re-simulate into outputs/run/ and diff it (about 15 minutes)npm cinpm run test:full # Confirm the release manifestnode scripts/release-manifest.mjs --check
provablyfair.org/verify-bets/duel
This is an open-source audit. Every scored step, dataset and line of verification code is public. Clone the repo, run the tests, and check the results yourself.
✓  Fully Reproducible

Check out v1.2.2 and npm test reproduces all 26 scored steps and compares them with the committed evidence: REPRODUCED, exit 0. The dataset hashes pin the same 7,050 bets.

Framework 1.1

Game Profile Coverage

Is every check of the Mines profile accounted for?

Framework 1.1 gives each game a profile: a fixed list of checks the audit must cover. Mines profile 1.0.2 has 30 checks. 22 are covered by scored steps, 7 by package checks, and 1 is not applicable, with its reason. One check, the client seed, is partial, as the package states.

1.0.2Mines profile
22Scored steps
7Package checks
1N/A, with reason
4 columns
CheckWhat it coversCovered byCoverage
MINES-01Every revealed seed hashes to its commitmentStep 1Full
MINES-02Each rotation’s next-seed hash is the next epoch’s commitmentStep 2Full
MINES-03Every bet carries its epoch’s commitment and one client seedSteps 3, 4Full
MINES-04Nonces start at the declared base 0, with no reuse; gaps declaredStep 4Full
MINES-05Bet, seed and epoch counts match the capture planSteps 13, 15Full
MINES-06Client seed changes the layout; client-seed originSteps 6, 17Partial
MINES-07Every layout recomputes from its revealed seedSteps 5, 21Full
MINES-08Draw-bias bound for all 24 draw rangesStep 5Full
MINES-09RNG built from the written spec; operator code as a cross-checkPackage check: spec, spec tests, operator-code runFull
MINES-10Win condition from the recomputed layoutSteps 9, 21, 22Full
MINES-11Every credit equals stake × the served multiplierSteps 7, 10, 23Full
MINES-12Bet size does not change the layout or multiplierStep 10Full
MINES-13Served multipliers match the exact formula at every depth reached, to 1e-12 relativeSteps 8, 20, 23Full
MINES-14Multipliers increase with depth and mines; caps (none declared)Step 25Full
MINES-15Mine-count and depth coverage against the planStep 11Full
MINES-16Balance ledger across consecutive betsn/a — no balance or wallet field appears anywhere in the captured data, so there is no wallet delta to reconcile; every credit is verified on the settle response instead (Steps 7, 10, 23)N/A
MINES-17Multi-reveal state: per-step multipliers, order and positionSteps 20, 21, 22, 23Full
MINES-18RTP from counted survival, not casino dataStep 16Full
MINES-19House edge served and derivedSteps 12, 16Full
MINES-20Simulation, 1M rounds per mine countStep 18Full
MINES-21Cherry-pick tests on every revealed casino seedStep 19Full
MINES-22Live-sample fit of win rates and mine positionsStep 26Full
MINES-23Framework S5 matrix in the packagePackage check: MANIFEST S5 matrixFull
MINES-24ProvablyFair.org verifiers match the audit RNGPackage check: both site verifiers pinned and runFull
MINES-25Player instructions: where the seed is, fields, encoding, shufflePackage check: MANIFEST, Verify a betFull
MINES-26Datasets pinned by SHA-256Step 14Full
MINES-27Artifacts of record pinned, with value domainsStep 24Full
MINES-28Zero-install reproduction and test-count parityPackage check: bundles and build checkFull
MINES-29Mutation battery reaches every scored stepPackage check: 47 must-fail mutationsFull
MINES-30Declared limitations and premisesPackage check: MANIFEST limitationsFull
Partial coverage: MINES-06 asks for the client seeds to come from a secure generator. Our capture generated the Phase A–C client seeds with Math.random(), which is not one. Every layout still recomputes, and a wrong client seed still changes the layout; closing the check needs a new capture.