
Mines
Independent verification, backed by open-source code.
- 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
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.
The casino result, reproduced.
- Casino outcome
- 5 safe reveals · Cashed out
- Our reproduction
- 5 safe reveals · Cashed out
- Recorded payout
- $0.0202
- Seed Hash IntegrityPass
- Commitment LinkagePass
- Hash ConsistencyPass
- Mine Position RecomputationPass
- Client Seed InfluencePass
- Payout MathPass
- Multiplier FormulaPass
- Win ConditionPass
- Bet-Size InvariancePass
- Config & Cell CoveragePass
- House Edge AuditPass
- Population & Phase LabelsPass
- Dataset HashPass
- Epoch SizePass
- Anti-CircularityPass
- Client Seed VariationPass
- Simulation Pass 1Pass
- Cherry-Pick DetectionPass
- Multi-Reveal ChainPass
- Mine-Set InvariancePass
- Reveal-Position Indep.Pass
- Cash-Out PayoutPass
- Artifact IntegrityPass
- Multiplier BoundsPass
- Live-Sample FitPass
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.
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.
Audit Verdict
| Check | Result | Evidence |
|---|---|---|
| Overall Status | Pass | PROVABLY FAIR — Full Pass · 25 of 26 scored steps pass · 1 capture flag · 0 hard fails · Framework 1.1, release v1.2.2 |
| RTP Verified | Pass | 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 Parity | Pass | 100% — 7,050 / 7,050 mine layouts reproduced, 0 mismatches |
| Commit-Reveal System | Pass | 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 Audit | Capture 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 Seed | Pass | 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 Analysis | Pass | 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 Logic | Pass | 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-Circularity | Pass | Survival counted over all 2^25 tile subsets; formula × counted probability = 1 − edge exactly on all 300 cells, with no casino-supplied probability |
| Fairness Integrity | Pass | 16 fairness integrity tests — all 16 pass (includes one Mines-specific multi-step state test) |
| Determinism | Pass | Same inputs, same mine set: 7,050 / 7,050, including all 1,173 multi-reveal steps |
Overall StatusPass
RTP VerifiedPass
Live ↔︎ Verifier ParityPass
Commit-Reveal SystemPass
Nonce AuditCapture flag
Client SeedPass
RNG AnalysisPass
Payout LogicPass
Anti-CircularityPass
Fairness IntegrityPass
DeterminismPass
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
| Area | Description |
|---|---|
| Commit-Reveal System | SHA-256 commitments of the hex-decoded server seed, rotation links, reveal on rotation (consistency); commitment timing from the capture’s records |
| Nonce Audit | Declared base 0, planned epoch sizes, no reuse; capture-origin gaps declared and flagged |
| Client Seed | Browser origin, server echo, influence on the layout, empty-seed control |
| RNG Analysis | Spec-built HMAC-SHA256 backward Fisher-Yates, draw-bias bound for all 24 ranges, rejection census |
| Live Parity | All 7,050 rounds recomputed; ProvablyFair.org verifiers and Duel’s verify code run on the same rounds |
| Payout Logic | Multipliers and payouts against the exact formula to 1e-12 relative, depths 1–5, win condition from our recomputed layout, $10 vs $0.01 |
| RTP Validation | Theoretical RTP from counted survival, RTP claim rule against Duel’s game settings, stake tiers from the config, 24M-round simulation, cherry-pick tests |
| Fairness Integrity | Standard 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.
Win Conditions
The win condition in Mines depends on whether the revealed tile is in the mine set.
| Outcome | Condition | Example (mines=3, k=5) |
|---|---|---|
| Safe reveal | Revealed tile is not in mine set | Multiplier grows; player may cash out or continue |
| Cash out | Player stops after k safe reveals | k=5 → stake × 2.0155× (2.0175× before the edge) |
| Loss | Revealed tile is in mine set | Round ends, bet is lost |
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
| Parameter | Value | Notes |
|---|---|---|
| Grid Size | 25 tiles (5×5) | Fixed; tiles numbered 0–24 |
| Mine Count | 1–24 | Player-selected; sets the risk and the multiplier curve |
| Payout Cells | 300 | Every (mines, reveals) pair, reveals 1 to 25 − mines |
| House Edge | 0.1% base tier | Duel’s settings raise it in 0.01% steps up to 1.0% above $25,000 potential profit (from the config, not tested) |
| Theoretical RTP | 99.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 round | Duel’s setting; outside our testing |
| RNG Algorithm | HMAC-SHA256 | Backward 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.
| Seed Type | Format | Example | Purpose |
|---|---|---|---|
| Server Seed | 64-char hex (32 bytes) | 01b20487103f970a… | Casino-provided randomness |
| Client Seed | Text string (by default 16 letters, digits or _; you can set your own) | NxcarOV28bkerHJk | Player-contributed entropy |
| Nonce | Integer ≥ 0 | 6 | Per-round counter within the active seed pair |
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| Reveals (k) | Mines (m) | Raw multiplier | With 0.1% edge |
|---|---|---|---|
| 1 | 1 | 1.0417× | 1.0406× |
| 1 | 3 | 1.1364× | 1.1352× |
| 1 | 5 | 1.2500× | 1.2488× |
| 3 | 5 | 2.0175× | 2.0155× |
| 5 | 3 | 2.0175× | 2.0155× |
| 10 | 3 | 5.0549× | 5.0499× |
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
| Check | What it shows |
|---|---|
| SHA-256 of the revealed seed matches its commitment | The revealed seed is the one behind that hash |
| Each epoch’s hash equals the previous rotation’s next-seed hash | The seed records form one consistent chain |
| Commitment recorded before the epoch’s first bet | Timing, from our capture’s timestamps |
Seed System
| Check | What it shows |
|---|---|
| Nonces start at 0 and are never reused | No nonce served twice; gaps are declared and flagged |
| Single client seed per epoch | The client seed is not swapped mid-epoch |
| Client seed echoed, not assigned | The seed you set is the seed used |
RNG & Parity
| Check | What it shows |
|---|---|
| Mine positions recompute from seeds + nonce | The outcome is deterministic and verifiable |
| Our spec-built RNG and Duel’s code agree on every round | No hidden inputs to the RNG |
| Mine set invariant across the reveal sequence | The layout is fixed at round start |
Payout & RTP
| Check | What it shows |
|---|---|
| Multiplier matches C(25,k)/C(25−m,k) × 0.999 | Payouts follow the fair-odds formula, less the 0.1% edge |
| amount_won = amount × no_house_edge_multiplier | Payout arithmetic holds to 1e-12 relative |
| Counted survival × multiplier = 1 − edge on all 300 cells | RTP is 99.9% at the base edge by construction, not observation |
Integrity
| Check | What it shows |
|---|---|
| Wrong client seed produces different mines | The 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 seeds | No 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.
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 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
// 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 0Determinism 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:
// 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] sortedTechnical Glossary7 categories▶
Terms and definitions used throughout this audit report, grouped by category.
Core Concepts
| Term | Definition |
|---|---|
| Provably Fair | A system where every game outcome can be independently verified from public cryptographic inputs, without trusting the operator. |
| Commit-Reveal | A 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. |
| Determinism | A property where the same inputs always produce the same output. Mines is deterministic: (serverSeed, clientSeed, nonce, mineCount) uniquely determines the mine set. |
| Epoch | The set of bets placed under a single active seed pair, from activation to rotation. Also called a seed pair lifecycle. |
| Framework 1.1 | The 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 flag | A 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
| Term | Definition |
|---|---|
| Server Seed | A 32-byte random value generated by the casino. Represented as a 64-character hex string. Used as the HMAC key (hex-decoded). |
| Server Seed Hashed | SHA-256(hex_bytes(serverSeed)). The commitment published before play. |
| Client Seed | A player-controlled string, generated in the browser by default. Part of the HMAC message. |
| Nonce | A 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. |
| Cursor | The 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 Pair | The combination of one server seed and one client seed. A seed pair defines an epoch. |
| Next Server Seed Hash | A pre-commitment to the server seed that will become active after the current one is rotated. Locks the future chain in advance. |
Cryptographic Functions
| Term | Definition |
|---|---|
| SHA-256 | A 256-bit cryptographic hash function. Used here for server seed commitment: SHA-256(hex_bytes(serverSeed)) = serverSeedHashed. |
| HMAC-SHA256 | Hash-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-Yates | The 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 Sampling | Bias-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
| Term | Definition |
|---|---|
| Parity | Agreement between the live game's reported outcome and an independent recomputation from the same inputs. 100% parity means zero mismatches. |
| Recomputation | Running the audit's standalone RNG implementation on captured seed triples and comparing the output to the live API response. |
| Anti-Circularity Proof | Deriving 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 Rule | RTP-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 Tier | The 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
| Term | Definition |
|---|---|
| Mine Count | The number of mines placed on the 25-tile grid for a given round. Player-selected, range 1–24. |
| Reveal | The act of clicking a tile. A safe reveal grows the multiplier; a mine reveal ends the round. |
| Multiplier Chain | The 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-Out | Stopping after k safe reveals and collecting amount × mₖ. Only available after at least one safe reveal. |
| Mine Set Invariance | The 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 Identity | P(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 Edge | Duel’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
| Term | Definition |
|---|---|
| Fairness Integrity (FI) Matrix | Our 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 Test | A 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 Correction | A multiple-comparison adjustment: when testing N hypotheses at significance α, the per-test threshold is α/N. Prevents false positives from mass testing. |
| Point-in-Time Audit | An audit verdict that applies to the code and configuration in force at the audit date. Subsequent changes are outside scope unless re-certified. |
| Game Profile | The 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
| Term | Definition |
|---|---|
| mines-master-6500bets.json | Primary 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.json | Multi-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.json | Output of the 26-step verification suite: per-step status, detail, profile checks and informational items. |
| simulation-results.json | Output 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.json | All 300 (mines, cash-out) cells against the edge Duel’s game settings state for them, under the RTP claim rule. |
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.
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)
- 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
- 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)
Seed hash integrityPass
Commitment linkagePass
Commitment timingInfo
Hash consistency within epochPass
Nonce auditCapture flag
Client seed originPass
crypto.getRandomValues; the ten Phase D seeds come back in our capture’s own formClient seed influencePass
Deterministic outputPass
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.
| Check | Result | Evidence |
|---|---|---|
| Seed hash integrity | Pass | 149 / 149 seed reveals hash to their commitment (SHA-256 of the hex-decoded bytes); 0 mismatches |
| Commitment linkage | Pass | 133 / 133 primary and 16 / 16 Phase E rotation links recomputed from the raw hashes; both pre-capture anchors verified |
| Commitment timing | Info | 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 epoch | Pass | Every bet under each of the 130 bet-bearing rotation records carries that record’s hash and client seed; 0 orphan bets |
| Nonce audit | Capture 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 origin | Pass | Drawn in the browser with crypto.getRandomValues; the ten Phase D seeds come back in our capture’s own form |
| Client seed influence | Pass | 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 output | Pass | Same (server seed, client seed, nonce, mine count) → same mine set: 7,050 / 7,050 |
Seed hash integrityPass
Commitment linkagePass
Commitment timingInfo
Hash consistency within epochPass
Nonce auditCapture flag
Client seed originPass
crypto.getRandomValues; the ten Phase D seeds come back in our capture’s own formClient seed influencePass
Deterministic outputPass
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.
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();}Real Example from Live Data:
// Seed block recorded with the bet (round 25075415){ "serverSeedHashed": "2d3a2c76d354a0a859d84b9fe8183e8f48cf6e973e0264947af3f95c1505e72b", "clientSeed": "NxcarOV28bkerHJk", "nonce": 6} // After the rotation, the transaction detail revealed:// serverSeed = "01b20487103f970a94c7d615ba53497605020ee1dc3e9e601261d4088275bbe3"Verification:
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.
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}`);}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).
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.
for (const e of epochs) { if (e.bets.length === 0) { empty++; continue; } betBearing++; const tag = `seeds[${e.index}] (${e.record.seed.serverSeedHashed.substring(0, 16)})`; const hashes = new Set(e.bets.map(b => b.seed.serverSeedHashed)); const clients = new Set(e.bets.map(b => b.seed.clientSeed)); if (hashes.size !== 1) { s3Failures.push(`${tag}: ${hashes.size} distinct serverSeedHashed among its ${e.bets.length} bets`); } else if (!hashes.has(e.record.seed.serverSeedHashed)) { s3Failures.push(`${tag}: its bets carry ${[...hashes][0].substring(0, 16)}, not the hash the rotation committed`); } if (clients.size !== 1) { s3Failures.push(`${tag}: ${clients.size} distinct client seeds among its bets`); } else if (!clients.has(e.record.seed.clientSeed)) { s3Failures.push(`${tag}: its bets carry client seed ${[...clients][0]}, not the rotation record's ${e.record.seed.clientSeed}`); }}1.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.
EveJlkDtA24dfvBrNxcarOV28bkerHJkdatWCpUusET02jWwQfpCgsRdMX8w1CZbDZINIfo9nv2pxGzu
client-seed-origin.png, mines-master-6500bets.json, mines-phaseE-550bets.json1.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.
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';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.
export function computeMinePositions( serverSeed: string, clientSeed: string, nonce: number, mineCount: number, gridSize: number = GRID_SIZE,): number[] { return computeMinePositionsFromBuffer(decodeServerSeed(serverSeed), clientSeed, nonce, mineCount, gridSize);}mines_positions. Zero set mismatches. No external entropy enters the layout.Real Bet 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:
// 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.
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;Technical Evidence & Verification5 sections
1.9Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Seed hash integrity (Step 1) | 149 / 149 seed reveals across both datasets | Pass |
| Commitment linkage (Step 2) | 133 / 133 primary + 16 / 16 Phase E links, both anchors | Pass |
| Hash consistency (Step 3) | 130 / 130 bet-bearing rotation records, 0 orphans | Pass |
| Nonce audit (Step 4) | 142 epochs; 1 declared capture gap (Phase E), 0 operator-side gaps, 0 reuse | Capture flag |
| Mine position recomputation (Step 5) | 6,500 / 6,500 primary | Pass |
| Client seed influence (Step 6) | 646 / 650 changed; empty-seed control 56 / 6,500 | Pass |
| Epoch size (Step 15) | 130 × 50 primary; every Phase E record on plan | Pass |
| Phase D client seed variation (Step 17) | 500 / 500 recomputed under 10 player-set seeds | Pass |
1.10Code References6 source files
| File | Purpose |
|---|---|
| tests/verify.ts | 26-step verification suite (Steps 1–6 and 15, 17 cover S1) |
| tests/steps/commitment.ts | Steps 1–4: seed hashes, rotation links, epoch consistency, nonce audit |
| tests/steps/determinism.ts | Steps 5–6: mine position recomputation, client seed influence |
| src/rng.ts | Spec-built HMAC-SHA256 backward Fisher-Yates (computeMinePositions, verifyHash) |
| src/loader.ts | Dataset pins, the capture plan in code, the declared capture gap |
| capture/mines-capture.reference.js | Reference record of the capture script (Phases A–D) |
1.11Datasets UsedSource artifacts
| Property | Value |
|---|---|
| Source | Live Mines rounds on Duel.com, captured 16–21 April 2026 |
| Total Records | 7,050 bets across 142 bet-bearing epochs (151 seed records) |
| Primary SHA-256 | 331f74ff98b88d06242d57e806186548612f13c4269eb754ebb571d8a6fc9b20 |
| Phase E SHA-256 | def563907949db10d584256a13b33102dfa46d33509424f642f803d74cd1b17b |
Fields used: serverSeed, serverSeedHashed, nextServerSeedHash, clientSeed, nonce, mines_count, mines_positions, revealed_positions
1.12Verified Invariants9 invariants
| Invariant | Result |
|---|---|
| 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 seed | Pass |
| Nonces start at the declared base 0 in all 142 epochs | Pass |
| No nonce served twice in any epoch | Pass |
| Every gap is a declared capture gap (1, Phase E) | Capture flag |
| Same inputs → same mine set for all 7,050 bets | Pass |
| Wrong client seed changes the set on 646 / 650, within the combinatorial bound | Pass |
| Client seed generated in the browser and echoed by the server | Pass |
1.13Reproduction InstructionsRun locally
Clone the release and run the suite. Nothing needs installing:
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:captureS1-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 InfluenceRNG & 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.
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
- 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
- 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
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 reproducedDuel verify code (cross-check)Pass
Disclosed inputs onlyPass
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i); no beacon field in either dataset; every layout reproduces from the four inputsDraw biasPass
Rejection censusPass
Key encodingPass
Simulation uniformity & serial independencePass
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.
| Check | Result | Evidence |
|---|---|---|
| RNG written from the spec | Pass | 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 only | Pass | HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i); no beacon field in either dataset; every layout reproduces from the four inputs |
| Draw bias | Pass | 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 census | Pass | 156,000 draws over 6,500 recomputed rounds: 0 rejected chunks, 0 cursor advances |
| Key encoding | Pass | Server seed hex-decoded to 32 bytes; the UTF-8 key gives different layouts on all 7 test vectors |
| Simulation uniformity & serial independence | Pass | 24M 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 reproducedDuel verify code (cross-check)Pass
Disclosed inputs onlyPass
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:i); no beacon field in either dataset; every layout reproduces from the four inputsDraw biasPass
Rejection censusPass
Key encodingPass
Simulation uniformity & serial independencePass
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.
| Component | Detail |
|---|---|
| Hash function | HMAC-SHA256 |
| Key | Buffer.from(serverSeed, 'hex') — 32 bytes |
| Message | clientSeed:nonce:i, draw index i = 0 … 23 |
| Extraction | eight 4-byte big-endian chunks per digest → uint32 |
| Rejection | v < floor(2^32 / r) · r — exact window per range |
| Reduction | v mod r → swap index j ∈ [0, r) |
| Shuffle | Backward Fisher-Yates: r = 25 down to 2, swap tiles[r − 1] ↔ tiles[j] |
| Output | tiles[0..mineCount−1] (sorted) → mine set |
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;}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⁻⁶⁰.
2.3Entropy Sources
All randomness comes from HMAC-SHA256 over cleanly separated inputs:
| Source | Controlled By | Purpose |
|---|---|---|
| Server Seed | Casino | Base randomness, committed by SHA-256 hash before betting |
| Client Seed | Player | Player-contributed entropy |
| Nonce | System | Uniqueness per bet, from 0 within each epoch |
| Draw index | System | Per-step separation, 0 to 23, one per shuffle step |
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)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.
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.
| Metric | Value |
|---|---|
| Mean simulated RTP | 99.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 |
/** 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;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.
export function lag1Autocorrelation(series: number[]): number { const n = series.length; const mean = series.reduce((a, b) => a + b, 0) / n; let num = 0, den = 0; for (let i = 0; i < n - 1; i++) num += (series[i] - mean) * (series[i + 1] - mean); for (let i = 0; i < n; i++) den += (series[i] - mean) ** 2; return den === 0 ? 0 : num / den;}2.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]| i | r | message | first chunk | uint32 | j | swap |
|---|---|---|---|---|---|---|
| 0 | 25 | NxcarOV28bkerHJk:6:0 | ff89d959 | 4,287,224,153 | 3 | tiles[24] ↔ tiles[3] |
| 1 | 24 | NxcarOV28bkerHJk:6:1 | ee24d5d2 | 3,995,391,442 | 10 | tiles[23] ↔ tiles[10] |
| 2 | 23 | NxcarOV28bkerHJk:6:2 | 93470e02 | 2,470,907,394 | 6 | tiles[22] ↔ tiles[6] |
| 3 | 22 | NxcarOV28bkerHJk:6:3 | c883330b | 3,364,041,483 | 11 | tiles[21] ↔ tiles[11] |
| 4 | 21 | NxcarOV28bkerHJk:6:4 | 9e8e4926 | 2,660,124,966 | 9 | tiles[20] ↔ tiles[9] |
25 / 22 = 1.1364×; payout 0.01 × 25/22 × 0.999 = 0.011352.Technical Evidence & Verification5 sections
2.9Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Spec-built RNG vs live layouts (Steps 5, 21) | 7,050 / 7,050 | Pass |
| Duel verify code, unmodified (Step 5) | 7,050 / 7,050 | Pass |
| Draw-bias bound (Step 5) | 24 / 24 ranges exact, bias 0 | Pass |
| Rejection census (Step 5) | 156,000 draws, 0 rejected | Pass |
| Key encoding (unit test) | UTF-8 key differs on 7 / 7 vectors | Pass |
| Simulation positions (Step 18) | 0 / 24 at α/24 | Pass |
| Serial independence (Step 18) | 0 / 24 at α/24 | Pass |
| Live-sample fit (Step 26) | 24 groups, first-drawn mine p = 0.938; 0 flags | Pass |
2.10Code References7 source files
| File | Purpose |
|---|---|
| src/rng.ts | Spec-built HMAC-SHA256 backward Fisher-Yates |
| docs/ALGORITHM.md | The written specification src/rng.ts is built from |
| src/bias.ts | Draw-bias bound, measured from drawFromChunk |
| src/operator-verifier.ts | Runs Duel’s Verify-tab code unmodified (the cross-check) |
| src/simulate.ts | Monte Carlo simulation, Pass 1 and Pass 2 |
| src/sim-plan.ts | Simulation plan and pinned seeds |
| tests/mines/RngSpecTests.ts | The spec’s vectors and properties against src/rng.ts |
2.11Verified Invariants8 invariants
| Invariant | Result |
|---|---|
| Spec-built RNG matches the live game for all 7,050 rounds | Pass |
| Duel’s published code matches the live game and ours for all 7,050 rounds | Pass |
| Key is hex-decoded (not UTF-8) | Pass |
| Every draw range 2–25 has an exact acceptance window in our RNG | Pass |
| No external entropy needed to reproduce a layout | Pass |
| 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
2.13Reproduction InstructionsRun locally
Clone the release and run the suite:
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm test# Steps 5, 18, 26 cover S2S2-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)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.
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
- 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
- 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
Mine-set recomputationPass
Payout correctnessPass
Multiplier formulaPass
Win conditionPass
Bet-size invariancePass
ProvablyFair.org verifier parityPass
Duel verify code (cross-check)Pass
Multi-reveal parityPass
is_mine matches our layout and revealed_positions is the exact prefix, including 11 out-of-order roundsAll 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.
| Check | Result | Evidence |
|---|---|---|
| Mine-set recomputation | Pass | 7,050 / 7,050 (6,500 primary in Step 5, 550 Phase E in Step 21); 0 mismatches |
| Payout correctness | Pass | 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 formula | Pass | 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 condition | Pass | 7,050 rounds, outcome derived from our recomputed layout; all 4,083 busts end on exactly the opened mine |
| Bet-size invariance | Pass | 200 $10 bets recomputed; their 105 wins were served the identical multiplier strings as $0.01 wins |
| ProvablyFair.org verifier parity | Pass | 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 parity | Pass | 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 |
Mine-set recomputationPass
Payout correctnessPass
Multiplier formulaPass
Win conditionPass
Bet-size invariancePass
ProvablyFair.org verifier parityPass
Duel verify code (cross-check)Pass
Multi-reveal parityPass
is_mine matches our layout and revealed_positions is the exact prefix, including 11 out-of-order roundsAll 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.
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.
| Phase | Bets | Config | Bet Amount | Purpose |
|---|---|---|---|---|
| A — Configuration coverage | 4,800 | 24 configs (mines 1–24, 200 each) | $0.01 | Every mine count |
| B — High-mine edge case | 1,000 | mines = 24 | $0.01 | Maximum variance: one safe tile in 25 |
| C — Stake equivalence | 200 | mines = 12 | $10.00 | Bet amount is not an RNG input |
| D — Client seed variation | 500 | mines 1–24 | $0.01 | 10 player-set client seeds |
| E — Multi-reveal & cash-out | 550 | mines 2, 3, 4, 5, 8, 12, 15; up to 5 reveals | $0.01 | Reveal chains, cash-outs, reveal-position independence |
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.
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++;}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.
| Verifier | What runs | Pinned | Result |
|---|---|---|---|
| This site’s verifier | VerifyBets games/mines/derive.js + lib/hmac-sha256.js, vendored | SHA-256 2321b23c…, bc30bfe9… | Pass 7,050 / 7,050 |
| www.provablyfair.org/verify-bets | The deployed bundle (3 chunks), with the page’s own Verify call | 4 / 4 SHA-256 pins | Pass 7,050 / 7,050 |
| Duel’s Verify-tab code | Copied verbatim 25 Sept 2026, run unmodified (cross-check) | SHA-256 88f5268b… | Pass 7,050 / 7,050 |
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.
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}`); }};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.
| Population | Checked | Worst deviation |
|---|---|---|
| Primary wins at k = 1 (Step 8) | 2,795 | 6.4 × 10⁻¹⁹ |
| Phase E wins at k = 1 (Step 8) | 39 | 6.0 × 10⁻¹⁹ |
| Phase E reveal steps, k = 1–5 (Step 20) | 1,173 | 9.2 × 10⁻¹⁵ |
| Phase E cash-outs at k > 1 (Step 23) | 133 | 5.9 × 10⁻¹⁵ |
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++;};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.
| Scope | Coverage | Verified |
|---|---|---|
| Primary dataset (Phases A–D) | 6,500 bets, tile 0 opened | 6,500 / 6,500 |
| Phase E rounds | 550 rounds, up to 5 reveals | 550 / 550 |
| Busts ending on the opened mine | 4,083 losses | 4,083 / 4,083 |
| Reveal-position independence (Step 22) | 50 bets, tiles {3, 7, 11, 17, 23} | 50 / 50 |
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.
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| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher-Yates: 24 HMAC-SHA256 draws | Shuffled tiles |
| 2 | tiles[0..4] (sorted) → mine set | {4, 6, 9, 13, 19} |
| 3 | Player opens tiles 0, 1, 2 — none a mine | 3 safe reveals (win) |
| 4 | Multiplier chain C(25,k)/C(20,k), k = 1, 2, 3; edge at cash-out | 1.2500× → 1.5789× → 2.0175× → paid 2.0155× |
| 5 | Cash-out payout: 0.01 × 2.015526 | 0.020155 ✅ |
// 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 ✅Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary12 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Mine-set recomputation (Step 5) | 6,500 / 6,500 primary | Pass |
| Payout math (Step 7) | 6,500 primary + 417 Phase E rounds, relative 1e-12 | Pass |
| Multiplier formula (Step 8) | 2,795 primary + 39 Phase E wins at k = 1 | Pass |
| Win condition (Step 9) | 7,050 rounds from our recomputed layout | Pass |
| Phase C bet-size invariance (Step 10) | 200 bets at $10, 105 wins | Pass |
| Config & payout-cell coverage (Step 11) | 24 × 200 Phase A; 33 of 300 cells reached | Pass |
| Phase D client seed variation (Step 17) | 500 / 500 under 10 player-set seeds | Pass |
| Multi-reveal multiplier chain (Step 20) | 1,173 reveal steps, k = 1–5 | Pass |
| Mine-set invariance (Step 21) | 550 layouts, 1,173 steps, 11 out-of-order rounds | Pass |
| 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: 45 | Pass |
| Multiplier monotonicity & bounds (Step 25) | 7,107 served multipliers inside the exact ladder’s range | Pass |
3.11Code References6 source files
| File | Purpose |
|---|---|
| tests/steps/determinism.ts | Step 5: recomputation, verifier parity, Duel-code cross-check |
| tests/steps/payouts.ts | Steps 7–12: payouts, multipliers, win condition, Phase C, coverage, house edge |
| tests/steps/multireveal.ts | Steps 20–23: multi-reveal chain, invariance, reveal position, cash-outs |
| src/exact.ts | Exact binomials and rational comparison |
| src/site-verifier.ts | Pins and runs this site’s verifier |
| src/live-site-verifier.ts | Pins and runs the www.provablyfair.org/verify-bets bundle |
3.12Datasets UsedSource artifacts
3.13Verified Invariants9 invariants
| Invariant | Result |
|---|---|
| Recomputed mine set = served mines_positions for all 7,050 bets | Pass |
| amount_won = amount × no_house_edge_multiplier, relative 1e-12, every win | Pass |
| Every loss credits exactly 0 | Pass |
| Every served multiplier = C(25,k)/C(25−m,k) (× 999/1000 settled), relative 1e-12, k = 1–5 | Pass |
| Outcome from our recomputed layout = served outcome, 7,050 rounds | Pass |
| $10 wins served identical multiplier strings to $0.01 wins | Pass |
| Both ProvablyFair.org verifiers return the served layout on every round | Pass |
| Duel’s published code returns the served layout on every round | Pass |
| Mine set fixed at round start, unchanged by reveal order (Phase E) | Pass |
3.14Reproduction InstructionsRun locally
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 S3S3-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 & BoundsRTP & 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.
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_edge0.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
- 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_edge0.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
- 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
Anti-circularityPass
RTP claim (RTP-CLAIM 1.2.0)Pass
House edge servedPass
effective_edge = 0.1 on all 6,500 primary bets (Step 12); all 7,050 captured bets inside the 0.1% tierStake tiers (scaling edge)Info
Multipliers and payoutsPass
Simulated RTP (Pass 1)Pass
Cherry-pick tests (Pass 2)Pass
Bet-size invariancePass
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.
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%.
| Check | Result | Evidence |
|---|---|---|
| Anti-circularity | Pass | 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 served | Pass | 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 payouts | Pass | 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 invariance | Pass | $10 and $0.01 wins served identical multiplier strings (Phase C, 105 wins) |
Anti-circularityPass
RTP claim (RTP-CLAIM 1.2.0)Pass
House edge servedPass
effective_edge = 0.1 on all 6,500 primary bets (Step 12); all 7,050 captured bets inside the 0.1% tierStake tiers (scaling edge)Info
Multipliers and payoutsPass
Simulated RTP (Pass 1)Pass
Cherry-pick tests (Pass 2)Pass
Bet-size invariancePass
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.
| Component | Formula | Source |
|---|---|---|
| Survival after k reveals | counted over all 2^25 tile subsets = C(25−m, k) / C(25, k) | Counting — independent of every closed form |
| Payout multiplier | C(25, k) / C(25−m, k) × (1 − edge) | The formula Duel’s served multipliers follow (S3) |
| RTP | counted survival × multiplier, exact rational | Independent probability × the paid multiplier |
| Result | = 1 − edge on all 300 cells: 999/1000 at the 0.1% base edge | Exact; floating-point check within 2.2 × 10⁻¹⁶ |
| Mines (m) | Win chance (k = 1) | Multiplier (base edge) | Product | RTP |
|---|---|---|---|---|
| 1 | 24/25 = 0.960000 | 25/24 × 0.999 = 1.040625 | 0.999000000 | 99.9% |
| 3 | 22/25 = 0.880000 | 25/22 × 0.999 = 1.135227 | 0.999000000 | 99.9% |
| 5 | 20/25 = 0.800000 | 25/20 × 0.999 = 1.248750 | 0.999000000 | 99.9% |
| 12 | 13/25 = 0.520000 | 25/13 × 0.999 = 1.921154 | 0.999000000 | 99.9% |
| 20 | 5/25 = 0.200000 | 25/5 × 0.999 = 4.995000 | 0.999000000 | 99.9% |
| 24 | 1/25 = 0.040000 | 25/1 × 0.999 = 24.975000 | 0.999000000 | 99.9% |
The counting anchor:
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:
// (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.
| Mines | Cells | First-tier edge | Theoretical RTP | Result |
|---|---|---|---|---|
| 1 | 24 | 0.1% | 99.90% | Pass |
| 2 | 23 | 0.1% | 99.90% | Pass |
| 3 | 22 | 0.1% | 99.90% | Pass |
| 4 | 21 | 0.1% | 99.90% | Pass |
| 5 | 20 | 0.1% | 99.90% | Pass |
| 6 | 19 | 0.1% | 99.90% | Pass |
| 7 | 18 | 0.1% | 99.90% | Pass |
| 8 | 17 | 0.1% | 99.90% | Pass |
| 9 | 16 | 0.1% | 99.90% | Pass |
| 10 | 15 | 0.1% · full board 0.14% | 99.90% · full board 99.86% | Pass |
| 11 | 14 | 0.1% · full board 0.18% | 99.90% · full board 99.82% | Pass |
| 12 | 13 | 0.1% · full board 0.21% | 99.90% · full board 99.79% | Pass |
| 13 | 12 | 0.1% · full board 0.21% | 99.90% · full board 99.79% | Pass |
| 14 | 11 | 0.1% · full board 0.18% | 99.90% · full board 99.82% | Pass |
| 15 | 10 | 0.1% · full board 0.14% | 99.90% · full board 99.86% | Pass |
| 16 | 9 | 0.1% | 99.90% | Pass |
| 17 | 8 | 0.1% | 99.90% | Pass |
| 18 | 7 | 0.1% | 99.90% | Pass |
| 19 | 6 | 0.1% | 99.90% | Pass |
| 20 | 5 | 0.1% | 99.90% | Pass |
| 21 | 4 | 0.1% | 99.90% | Pass |
| 22 | 3 | 0.1% | 99.90% | Pass |
| 23 | 2 | 0.1% | 99.90% | Pass |
| 24 | 1 | 0.1% | 99.90% | Pass |
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();}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).
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.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.
| Config | Theoretical RTP | Simulated RTP | Deviation |
|---|---|---|---|
| mines=1 | 99.900% | 99.929% | +0.029% |
| mines=2 | 99.900% | 99.906% | +0.006% |
| mines=3 | 99.900% | 99.905% | +0.005% |
| mines=4 | 99.900% | 99.946% | +0.046% |
| mines=5 | 99.900% | 99.941% | +0.041% |
| mines=6 | 99.900% | 99.876% | −0.024% |
| mines=7 | 99.900% | 99.812% | −0.088% |
| mines=8 | 99.900% | 99.858% | −0.042% |
| mines=9 | 99.900% | 99.895% | −0.005% |
| mines=10 | 99.900% | 99.863% | −0.037% |
| mines=11 | 99.900% | 99.962% | +0.062% |
| mines=12 | 99.900% | 99.993% | +0.093% |
| mines=13 | 99.900% | 99.929% | +0.029% |
| mines=14 | 99.900% | 100.003% | +0.103% |
| mines=15 | 99.900% | 99.919% | +0.019% |
| mines=16 | 99.900% | 99.812% | −0.088% |
| mines=17 | 99.900% | 99.935% | +0.035% |
| mines=18 | 99.900% | 100.035% | +0.135% |
| mines=19 | 99.900% | 99.758% | −0.142% |
| mines=20 | 99.900% | 99.753% | −0.147% |
| mines=21 | 99.900% | 100.183% | +0.283% |
| mines=22 | 99.900% | 99.893% | −0.007% |
| mines=23 | 99.900% | 99.739% | −0.161% |
| mines=24 | 99.900% | 99.850% | −0.050% |
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.
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.
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; // …}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.
| Test | Result | Moves Step 19 to |
|---|---|---|
| Test A — chi-squared per seed, α = 0.01 | 1 / 130 | FAIL above 7.97 |
| Test B — early (nonces 0–49) vs late window | 7 / 130, all isolated-early | FLAG above 14, FAIL above 28 |
| Seeds off in both windows (p < 0.05) | 0 / 130 | FLAG at 2, FAIL at 3 |
| Test C — return of the served configurations | 3 / 130 | FAIL above 18.67 |
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';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.
| Mines, tile | Stakes at the 0.1% edge | Max stake (1.0% edge) |
|---|---|---|
| 1 mine, 1st tile | up to $615k | $8.0m |
| 3 mines, 1st tile | up to $185k | $2.0m |
| 12 mines, 1st tile | up to $27.1k | $277k |
| 3 mines, 5th tile | up to $24.6k | $251k |
| 24 mines, 1st tile | up to $1,043 | $10,526 |
| 3 mines, 22nd tile | up to $10.89 | $110 |
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.
| Metric | Phase A ($0.01) | Phase C ($10) |
|---|---|---|
| Bets | 4,800 (all 24 mine counts) | 200 (12 mines) |
| Bet amount | $0.01 | $10.00 |
| Layouts recomputed | 4,800 / 4,800 | 200 / 200 |
| Multiplier at 12 mines, k = 1 | 25/13 × 0.999 | 25/13 × 0.999, identical strings |
| RNG path | HMAC-SHA256 Fisher-Yates | HMAC-SHA256 Fisher-Yates |
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.
| Item | Value | Context |
|---|---|---|
| Phase A observed RTP | 100.37% | 4,800 bets at $0.01, mines 1–24 (200 each) |
| Phase B observed RTP | 97.40% | 1,000 bets at $0.01, 24 mines |
| Phase C observed RTP | 100.86% | 200 bets at $10, 12 mines |
| Phase D observed RTP | 111.71% | 500 bets at $0.01, 10 player-set client seeds |
| Primary total | 100.86% | 6,500 bets, $2,063.00 wagered; the $10 phase dominates |
| Win-rate fit, 24 mine counts | 0 / 24 at α = 0.01 | Smallest 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 = 1Step 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
| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher-Yates: 24 HMAC draws | mine set = {5, 16, 21} ✅ |
| 2 | Win check: opened tile in the mine set? | 0 ∉ {5,16,21} → win |
| 3 | Multiplier: 25/22 × 0.999 | 1.135227× |
| 4 | RTP check: win chance × multiplier | 22/25 × 1.135227 = 0.999 |
| 5 | Payout: 0.01 × 1.135227 | 0.011352 ✅ |
// 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.999Technical Evidence & Verification5 sections
4.11Evidence Coverage Summary9 checks
| Verification Area | Coverage | Result |
|---|---|---|
| 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 edge | Pass |
| House edge audit (Step 12) | effective_edge 0.1 on 6,500 / 6,500 | Pass |
| Multiplier formula (Steps 8, 20, 23) | 2,834 wins at k = 1, 1,173 reveal steps, 133 cash-outs | Pass |
| Simulation Pass 1 (Step 18) | 24M rounds; positions 0 / 24, serial 0 / 24 | Pass |
| Simulation Pass 2 (Step 19) | 130 seeds; Tests A, B, C inside their bounds | Pass |
| Bet-size invariance (Step 10) | 200 / 200 at $10 | Pass |
| Multiplier bounds (Step 25) | 276 + 276 ladder pairs increasing; 7,107 served values in range | Pass |
| Stake tiers (informational) | 24 / 24 settings responses match their pins; all captured bets in the 0.1% tier | Info |
4.12Code References7 source files
| File | Purpose |
|---|---|
| tests/steps/dataset.ts | Step 16: counting anchor, exact identity, negative controls |
| src/exact.ts | Exact binomials, subset enumeration, multiplier at a stated edge |
| src/rtp-claim.ts | The framework’s RTP claim rule, version 1.2.0 |
| src/rtp-settings.ts | The claim (Duel’s game settings) and the 300-cell table |
| src/scaling-edge.ts | Reads and checks Duel’s stake-tier settings |
| tests/steps/simulation.ts | Steps 18–19: simulation integrity and cherry-pick tests |
| src/simulate.ts | Monte Carlo simulation, Pass 1 and Pass 2 |
4.13Datasets UsedSource artifacts
4.14Verified Invariants9 invariants
| Invariant | Result |
|---|---|
| Counted survival = C(25−m,k)/C(25,k) on all 300 cells | Pass |
| Counted survival × multiplier = 1 − edge exactly, all 300 cells | Pass |
| Each cell’s RTP within ±0.1 pp of the edge Duel’s settings state for it | Pass |
effective_edge = 0.1 on every primary bet | Pass |
| 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 seeds | Pass |
| $10 and $0.01 wins served identical multipliers | Pass |
4.15Reproduction InstructionsRun locally
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 S4S4-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 forFairness 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.
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
- 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?
- 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
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
16 fairness integrity tests: all 16 pass, including one Mines-specific multi-step state integrity test.
Category Coverage
| Check | Result | Evidence |
|---|---|---|
| Nonce integrity | Pass | 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 integrity | Pass | Locked at bet acceptance, unique per epoch — 149/149 seed reveals verified across both datasets |
| Outcome determinism | Pass | Identical inputs produce identical mine sets — 7,050/7,050 confirmed including multi-reveal |
| Round & player isolation | Pass | Per-user seeds, serial independence confirmed (0/24 fail in 24M-round simulation) |
| Payout integrity | Pass | Parameter limits enforced (5/5 invalid mineCount rejected); injected payout fields ignored (0 honoured); duplicate-reveal advancement blocked |
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
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.
| Category | Tests | What It Catches |
|---|---|---|
| Nonce Integrity | 4 | Sequence gaps, server-side nonce manipulation, session continuity |
| Seed Commitment | 5 | Mid-epoch seed changes, seed reuse, predictable seed generation |
| Outcome Determinism | 2 | Non-deterministic outputs, outcome replay, cash-out manipulation |
| Player Isolation | 2 | Cross-round correlation, cross-user outcome dependence |
| Payout Integrity | 3 | Parameter 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.
| Severity | Meaning | Action |
|---|---|---|
| PASS | Test passed — no issue detected | None |
| N/A | Test not applicable to this game type | None |
| FLAG | Anomaly detected, documented for transparency | Disclosed |
| HARD FAIL | Fairness guarantee cannot be confirmed | Certification blocked until remediated |
| Condition | Consequence |
|---|---|
| Nonce gap or duplicate within epoch | Outcome sequence integrity broken |
| Server seed changed mid-epoch | Commit-reveal guarantee broken |
| Mine-set recomputation mismatch | Undisclosed inputs affecting mine placement |
| Client seed not used in HMAC | Player has no influence on outcomes |
| Mine set changes during reveal sequence | Per-reveal manipulation possible |
| Duplicate reveal advances payout multiplier | Multi-step state corruption |
16 tests · 16 pass
Nonce Integrity4/4
FI-NONCE-001PassEach bet increments the nonce sequentially with no gaps, repeats, or resets — preventing the server from skipping unfavourable outcomes
FI-NONCE-002PassNonce progression is server-controlled — the client cannot inject, skip, or replay a nonce value via the API
S1, Step 4 — server controls nonce assignment. Client bet requests do not include a nonce field.
FI-NONCE-003PassSubmitting an invalid or out-of-sequence nonce does not produce a game outcome — the server rejects the request
API probe — 7 adversarial nonce values (−1, 0, 999999999, 'abc', INT32_MAX, INT32_MAX+1, 9e18) injected into mine-start requests. All 7 silently ignored; server assigned valid sequential nonces. Continuity preserved (baseline 21 → post-test 29); no stack traces leaked.
FI-NONCE-004PassNonce sequence continues correctly after disconnect/reconnect — no reset to zero mid-epoch
Seed Commitment5/5
FI-SEED-001PassEmpty, null, or invalid client seeds are handled deterministically — the server enforces input requirements
API probe — 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-002PassOnce a bet is accepted, the seed pair is locked for the epoch — no mid-epoch mutation of server or client seed is possible
FI-SEED-003PassEach epoch uses a unique server seed — no seed is reused across epochs or sessions
FI-SEED-004PassNo shared seed pool across users — each player's seeds are independently generated and isolated
API probe — 10 concurrent seed rotations on Account A and 10 on Account B. Zero hash collisions across 20 rotations; all hashes within each account distinct. Full account isolation confirmed.
FI-SEED-005PassServer seeds show no correlation with timestamps, sequential patterns, or other predictable inputs
API probe — 10 rotations spaced 5 seconds apart over ~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-001PassGiven identical inputs (serverSeed, clientSeed, nonce, mineCount), the game always produces the same mine set — verified across all 7,050 live bets including 550 multi-reveal bets with varied reveal positions
FI-OUTCOME-002PassA 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
Player Isolation2/2
FI-ISO-001PassRNG state is fully independent across rounds — no carry-over from one bet to the next. Each nonce produces a fresh HMAC-SHA256 computation
FI-ISO-002PassOne player's seeds, nonces, and outcomes cannot be observed or influenced by another player — complete cross-user isolation
Follows from seed uniqueness (FI-SEED-003) — if each user has a unique server seed, outcomes are isolated by construction. Confirmed by FI-SEED-004 — zero hash collisions across 20 cross-account rotations.
Payout Integrity3/3
FI-PAYOUT-001PassGame 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-002PassMultiplier 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-002PassRevealing 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
| Test ID | Category | Verification Source | Status |
|---|---|---|---|
| FI-NONCE-001 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-002 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-003 | Nonce | API probe | Pass |
| FI-NONCE-004 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-SEED-001 | Seed | API probe | Pass |
| FI-SEED-002 | Seed | S1, Steps 3 & 6 (data-driven) | Pass |
| FI-SEED-003 | Seed | S1, Step 1 (data-driven) | Pass |
| FI-SEED-004 | Seed | API probe | Pass |
| FI-SEED-005 | Seed | API probe | Pass |
| FI-OUTCOME-001 | Determinism | S3, Steps 5, 21, 22 (data-driven) | Pass |
| FI-OUTCOME-002 | Determinism | S3, Steps 21 & 23 (data-driven) | Pass |
| FI-ISO-001 | Isolation | S2, Step 18 (simulation) | Pass |
| FI-ISO-002 | Isolation | Structural — seed uniqueness | Pass |
| FI-PAYOUT-001 | Payout | API probe | Pass |
| FI-PAYOUT-002 | Payout | API probe | Pass |
| FI-MINES-STATE-002 | Payout | API probe | Pass |
5.4Additional Integrity Evidence (S1–S4)8 records
| Property | Source | Finding |
|---|---|---|
| 149/149 seed hashes verified | S1, Step 1 | Commit-reveal chain intact |
| 133/133 + 16/16 rotation links | S1, Step 2 | Seed rotation chain intact |
| 6,500/6,500 exact parity (primary) + 550/550 Phase E | S3, Steps 5 & 21 | No post-RNG conditional logic, mine set fixed at round start |
| Anti-circularity proven (algebraic) | S4, Step 16 | 0.1% house edge from first principles |
| Test A 1/130, Test B 7/130, Test C 3/130 | S4, Step 19 (Pass 2) | No seed pre-selection bias |
| 99.4% client seed influence (646/650) | S1, Step 6 | Player entropy is genuine |
| 133 cash-outs verified at k ∈ {2,3,5} | S3, Step 23 | Multi-step payout integrity intact |
| 1,173 reveal steps verified across k ∈ {1..5} | S3, Step 20 | Multi-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.
git clone https://github.com/ProvablyFair-org/duel-mines.gitcd duel-minesgit checkout v1.2.2npm testExpected 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-002API Probe Tests (completed):
[PASS] FI-NONCE-003 — Invalid nonce handling → 7/7 invalid nonces ignored (HTTP 200)[PASS] FI-SEED-001 — Invalid client seed handling → 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 duplicatePlayer 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.
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)
- 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
- 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)
Player can access all required inputsPass
Commitment can be saved before bettingPass
Client seed origin transparentPass
crypto.getRandomValues, echoed by the server, changeable at any timeIndependent verifier availablePass
Casino verifier cross-checkedPass
Manual recomputation possiblePass
No hidden or proprietary stepsPass
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.
- 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
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
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
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.
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
Verify with the audit code
Independent verifier, pinned by the audit package and run on all 7,050 captured rounds: the served layout every time.
Open independent verifierBuilt-in verification
Duel’s own Verify page. Its published code returned the served layout on all 7,050 captured rounds; the live button was not tested with them.
Open Duel verifierVisual Walkthroughstep-by-step
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.
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.
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.
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.
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.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent, open source |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Checked in this audit | Published code run unmodified on 7,050 rounds; the live button not tested | Both run on all 7,050 captured rounds, 0 mismatches; SHA-256 pinned |
| Trust model | Requires trusting the casino | Open 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:
// 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)) });hashMatches: true and matches: true.6.9Python Verification Script
The same steps in Python, standard library only:
# 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)})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:
| Draw i | r | Message | First chunk | j | Swap |
|---|---|---|---|---|---|
| 0 | 25 | EveJlkDtA24dfvBr:0:0 | 0xd8c82daa = 3636997546 | 21 | tiles[24] ↔ tiles[21] |
| 1 | 24 | EveJlkDtA24dfvBr:0:1 | 0xa6cb9b87 = 2798361479 | 23 | no-op |
| 2 | 23 | EveJlkDtA24dfvBr:0:2 | 0x291cf2f0 = 689763056 | 2 | tiles[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
| Evidence | Description |
|---|---|
| client-seed-origin.png | Duel’s live game code, where the default client seed is drawn in the browser with crypto.getRandomValues |
| E02 | Duel.com fairness page overview |
| E03 | Mines verification tab on the fairness page, code panel collapsed |
| E04 | Provably Fair panel with an active server seed hash at nonce 0 (illustrative: its seeds are not in the dataset) |
| E09 | The same panel after rotating: E04’s next hash and new client seed are now active (illustrative) |
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
How it works
- 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
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
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
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
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.
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.
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.
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.
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.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent, open source |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Checked in this audit | Published code run unmodified on 7,050 rounds; the live button not tested | Both run on all 7,050 captured rounds, 0 mismatches; SHA-256 pinned |
| Trust model | Requires trusting the casino | Open 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:
// 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)) });hashMatches: true and matches: true.6.9Python Verification Script
The same steps in Python, standard library only:
# 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)})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:
| Draw i | r | Message | First chunk | j | Swap |
|---|---|---|---|---|---|
| 0 | 25 | EveJlkDtA24dfvBr:0:0 | 0xd8c82daa = 3636997546 | 21 | tiles[24] ↔ tiles[21] |
| 1 | 24 | EveJlkDtA24dfvBr:0:1 | 0xa6cb9b87 = 2798361479 | 23 | no-op |
| 2 | 23 | EveJlkDtA24dfvBr:0:2 | 0x291cf2f0 = 689763056 | 2 | tiles[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
| Evidence | Description |
|---|---|
| client-seed-origin.png | Duel’s live game code, where the default client seed is drawn in the browser with crypto.getRandomValues |
| E02 | Duel.com fairness page overview |
| E03 | Mines verification tab on the fairness page, code panel collapsed |
| E04 | Provably Fair panel with an active server seed hash at nonce 0 (illustrative: its seeds are not in the dataset) |
| E09 | The same panel after rotating: E04’s next hash and new client seed are now active (illustrative) |
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.
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.
Repository Details
- GitHub: ProvablyFair-org/duel-mines
- Release: v1.2.2 · commit
25cc963, 22 October 2026 - Original audit: commit
6927bec, 4 June 2026 - Public Verifier: provablyfair.org/verify-bets/duel
Prerequisites
- Node.js 22.x (
.nvmrc) - Git
- Nothing to install for
npm test npm cionly for the optional toolchain
- GitHub: ProvablyFair-org/duel-mines
- Release: v1.2.2 · commit
25cc963, 22 October 2026 - Original audit: commit
6927bec, 4 June 2026 - Public Verifier: provablyfair.org/verify-bets/duel
- Node.js 22.x (
.nvmrc) - Git
- Nothing to install for
npm test npm cionly for the optional toolchain
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.
Commands to Reproduce
Clone the release tag and confirm its release manifest: artifact hashes, verdict and scored counts. Node 22.x; nothing to install.
No install needed: verify.js and test.js are dependency-free bundles. npm test checks they are the build of today’s sources, runs the 32 unit tests, then the 26 scored steps, and compares the run with the committed results. Below is the output as run on a fresh clone; two very long lines are shortened (…). The Node version printed is your own.
Optional. npm ci installs the toolchain (Mocha, ts-node). npm run test:full re-simulates all 24M rounds into outputs/run/ (about 15 minutes), diffs the regeneration field by field with the committed artifact, then runs npm test.
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 test81 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
| File | Contents | SHA-256 |
|---|---|---|
| verification-results.json | All 26 scored steps: status, detail, profile checks and informational items | 2c7912464ab85ecb… |
| rtp-claim-table.json | All 300 (mines, reveals) cells against the edge Duel’s game settings state | 499c4f3dd1167550… |
| simulation-results.json | 24M-round Pass 1 census and per-config RTP; Pass 2 on 130 casino seeds | 8f628aa69a303ebc… |
| payout-coverage.json | Payout-cell coverage: 33 of 300 (mines, reveals) cells reached in live play; the 267 others listed with their chance of being reached | 32bfe33cf0a4ca62… |
| chi-squared-results.json | Win rate per mine count against the binomial | c73aa5b90fc626c6… |
| determinism-log.json | Layout recomputation tally: 6,500 verified, 0 mismatches | 12c39c309bbb7539… |
| rtp-convergence.html | Interactive RTP convergence chart, self-contained | 4d5cadeca0ab206d… |
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
| Step | Test Name | Report Section |
|---|---|---|
| 1 | Seed Hash Integrity | S1 |
| 2 | Next-Seed Promotion (Commitment Linkage) | S1 |
| 3 | Hash Consistency Within Epoch | S1, S5 |
| 4 | Nonce Audit | S1, S5 |
| 5 | Mine Position Recomputation | S2, S3, S6 |
| 6 | Client Seed Influence | S1 |
| 7 | Payout Math | S3, S5 |
| 8 | Multiplier Formula (C(25,1)/C(25-m,1) × edge) | S3, S4 |
| 9 | Win Condition (tile not in mines) | S3, S5 |
| 10 | Phase C Bet-Size Invariance ($10 bets) | S3, S4 |
| 11 | Config Completeness & Payout-Cell Coverage | S3 |
| 12 | House Edge Audit (effective_edge = 0.1%) | S4 |
| 13 | Population & Phase Labels | S3 |
| 14 | Dataset Hash | S1, S7 |
| 15 | Epoch Size | S1, S3 |
| 16 | Probability Independence (Anti-Circularity) | S4 |
| 17 | Phase D — Client Seed Variation | S1 |
| 18 | Simulation Results — Pass 1 Integrity | S2, S4 |
| 19 | Simulation Results — Pass 2 Cherry-Pick Test | S4 |
| 20 | Multi-Reveal Multiplier Chain | S3, S4 |
| 21 | Mine-Set Invariance Across Reveals (per-step, order-independent) | S3, S5 |
| 22 | Reveal-Position Independence (Phase E5) | S3 |
| 23 | Cash-Out Payout Correctness (k>1) | S3, S4, S5 |
| 24 | Artifact Integrity (pinned artifacts of record) | S7 |
| 25 | Multiplier Monotonicity & Bounds | S3, S4 |
| 26 | Live-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.
| Code | Verdict | When |
|---|---|---|
| 0 | PROVABLY FAIR — Full Pass | Every step passes and the run reproduces the committed results. A capture flag, a gap in our own capture, leaves it at 0 |
| 2 | PROVABLY FAIR — Conditional Pass | At least one operator-side flag |
| 5 | RTP FIGURE OVERSTATED | No draw check failed, but a published RTP figure is above the game’s real return beyond the ±0.1 pp band |
| 1 | NOT PROVABLY FAIR | At 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.
| Committed artifact | Differences in our run |
|---|---|
| outputs/verification-results.json | 0 |
| outputs/determinism-log.json | 0 |
| outputs/chi-squared-results.json | 0 |
| outputs/payout-coverage.json | 0 |
Result: REPRODUCED, 0 fields beyond tolerance.
Release History6 entries
The dataset is the same in every release.
| Release | What changed | Verdict |
|---|---|---|
| 6927bec · 4 June 2026 | Original audit published: 23 scored steps | PROVABLY FAIR — Full Pass |
| v1.0.0 | Original audit tagged, with artifact pinning (24 steps) | Unchanged |
| v1.1.0 | Re-certified under Framework 1.1: 26 scored steps, the RTP claim rule, the Phase E nonce audit | Unchanged |
| v1.2.0 | RNG code rebuilt from the written specification; Duel’s Verify-tab code kept as a cross-check | Unchanged |
| v1.2.1 | Line-ending fix so a Windows clone stays byte-identical; no audit content changed | Unchanged |
| v1.2.2 | Documentation 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 changed | Unchanged |
reproduce-audit.sh
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.
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.
| Check | What it covers | Covered by | Coverage |
|---|---|---|---|
| MINES-01 | Every revealed seed hashes to its commitment | Step 1 | Full |
| MINES-02 | Each rotation’s next-seed hash is the next epoch’s commitment | Step 2 | Full |
| MINES-03 | Every bet carries its epoch’s commitment and one client seed | Steps 3, 4 | Full |
| MINES-04 | Nonces start at the declared base 0, with no reuse; gaps declared | Step 4 | Full |
| MINES-05 | Bet, seed and epoch counts match the capture plan | Steps 13, 15 | Full |
| MINES-06 | Client seed changes the layout; client-seed origin | Steps 6, 17 | Partial |
| MINES-07 | Every layout recomputes from its revealed seed | Steps 5, 21 | Full |
| MINES-08 | Draw-bias bound for all 24 draw ranges | Step 5 | Full |
| MINES-09 | RNG built from the written spec; operator code as a cross-check | Package check: spec, spec tests, operator-code run | Full |
| MINES-10 | Win condition from the recomputed layout | Steps 9, 21, 22 | Full |
| MINES-11 | Every credit equals stake × the served multiplier | Steps 7, 10, 23 | Full |
| MINES-12 | Bet size does not change the layout or multiplier | Step 10 | Full |
| MINES-13 | Served multipliers match the exact formula at every depth reached, to 1e-12 relative | Steps 8, 20, 23 | Full |
| MINES-14 | Multipliers increase with depth and mines; caps (none declared) | Step 25 | Full |
| MINES-15 | Mine-count and depth coverage against the plan | Step 11 | Full |
| MINES-16 | Balance ledger across consecutive bets | n/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-17 | Multi-reveal state: per-step multipliers, order and position | Steps 20, 21, 22, 23 | Full |
| MINES-18 | RTP from counted survival, not casino data | Step 16 | Full |
| MINES-19 | House edge served and derived | Steps 12, 16 | Full |
| MINES-20 | Simulation, 1M rounds per mine count | Step 18 | Full |
| MINES-21 | Cherry-pick tests on every revealed casino seed | Step 19 | Full |
| MINES-22 | Live-sample fit of win rates and mine positions | Step 26 | Full |
| MINES-23 | Framework S5 matrix in the package | Package check: MANIFEST S5 matrix | Full |
| MINES-24 | ProvablyFair.org verifiers match the audit RNG | Package check: both site verifiers pinned and run | Full |
| MINES-25 | Player instructions: where the seed is, fields, encoding, shuffle | Package check: MANIFEST, Verify a bet | Full |
| MINES-26 | Datasets pinned by SHA-256 | Step 14 | Full |
| MINES-27 | Artifacts of record pinned, with value domains | Step 24 | Full |
| MINES-28 | Zero-install reproduction and test-count parity | Package check: bundles and build check | Full |
| MINES-29 | Mutation battery reaches every scored step | Package check: 47 must-fail mutations | Full |
| MINES-30 | Declared limitations and premises | Package check: MANIFEST limitations | Full |
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.