
Groomer's Van
Independent verification, backed by open-source code.
- Live Bets Verified
- 6,225
- 6,205 recomputed · 20 canned buy spins
- Parity Rate
- 100%
- Simulated RoundsSimulated RTP 100.06%
- 30M
- Simulated RTP 100.06%
- Enumerated RTP · no edge
- 99.9720%
- No edge applied · 2³² enumeration
Verification pipeline
Real bets. Independently reproduced.
Placed anonymously at Duel.com. We rebuilt the game logic from scratch and matched all 6,205 recomputable outcomes. The 20 bonus-buy spins are generated by Duel outside the seeds.
Recorded spin · Initial grid reproduced.
- Casino outcome
- Initial grid · 30 cells
- Our reproduction
- 30 / 30 cells match
- Recorded payout
- $0.44
- Seed Hash IntegrityPass
- Commitment LinkagePass
- Hash ConsistencyPass
- Outcome RecomputationPass
- Client Seed InfluencePass
- Payout MathPass
- Multiplier ProvenancePass
- Bet-Size InvariancePass
- House Edge (Zero Edge)Pass
- Config & Paytable CoveragePass
- Epoch SizePass
- Population & PhasesPass
- Dataset HashPass
- Phase D Client Seed VariationPass
- Anti-CircularityPass
- Simulation Pass 1Pass
- Cherry-Pick Test (Pass 2)Pass
- Cluster Pays AnywherePass
- Tumble Cascade IntegrityPass
- Wild Substitution RulePass
- Bonus TriggerPass
- Retrigger BehaviourPass
- Cosmetic Buy-Spin DisclosurePass
- Buy-Bonus StructurePass
- Free-Spin Payout ReconciliationPass
- Bonus Multiplier SymbolPass
- Cascade RNG Byte-Exact ReplayPass
- Base 2³² Artifact IntegrityPass
- Bonus 2³² Artifact IntegrityPass
- Session-EV Artifact IntegrityPass
- Headline RTP + ClaimPass
- Artifact IntegrityPass
- Max-Win CapPass
- Live-Sample FitPass
The repo is the credential. Every finding ships as code. At release v1.2.1, npm test runs the unit tests and all 35 scored steps against the 6,225 captured entries, then compares the fresh results with the committed ones. It prints 34 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, and exits 0.
PROVABLY FAIR — Full Pass. We captured 6,225 real Groomer's Van entries on Duel.com on 7–8 May 2026 (5,730 spins, 20 bonus buys and 475 free spins) and recomputed every grid, cascade and payout with our own implementation, written from the specification. 34 of 35 steps pass, with one capture flag (four nonces our capture script missed, not a Duel issue) and no hard fails. Certified under ProvablyFair.org Framework 1.1 at release v1.2.1.
Audit Verdict
| Check | Result | Evidence |
|---|---|---|
| Overall Status | Pass | PROVABLY FAIR — Full Pass. 34 of 35 steps pass, 1 capture flag, 0 hard fails (Framework 1.1, release v1.2.1). The capture flag is Step 4: limited by our capture script, not a Duel issue. |
| Enumerated RTP | Pass | 99.9720% with no edge applied, as on every captured bet: all 2³² spin outcomes enumerated and the bonus resolved by exact convolution, from the published weights and paytable alone. RTP claim (RTP-CLAIM 1.2.0): Duel's game settings state 100%, and the figure is 0.028 pp below it, inside the ±0.1 pp band: PASS (Step 32) |
| Live ↔︎ Verifier Parity | Pass | 6,205 / 6,205 non-buy entries and 4,323 / 4,323 cascades (129,690 cells) recompute exactly. Duel's Verify-tab code, run unmodified as a cross-check, agrees on all 6,205, and the ProvablyFair.org verifier on all 5,730 base spins (Steps 5, 28) |
| Commit-Reveal System | Pass | 116 / 116 revealed server seeds hash to their commitments; 116 / 116 links consistent (Steps 1–3). That each commitment was shown before its bets rests on the capture's rotation records |
| Nonce Audit | Capture flag | 112 / 116 epochs gap-free, no reuse. Four nonces were missed when our capture script retried a request: limited by our capture script, not a Duel issue (Step 4) |
| Client Seed | Pass | A genuine HMAC input: 623 / 623 outcome indexes change under a tampered client seed, and 500 Phase D bets recompute under auditor-set seeds (Steps 6, 15). Duel's default seed is generated in the browser and players can set their own |
| RNG Analysis | Pass | Our own HMAC-SHA256 → PCG32 implementation, written from the specification, reproduces every grid and cascade; every weighted draw is exactly unbiased on all 13 weight totals (Step 5) |
| Payout Logic | Pass | 6,205 / 6,205 non-buy entries paid exactly to the cent; 4,985 / 4,985 payline multipliers equal the published paytable; 475 / 475 free spins reconcile (Steps 7, 8, 26) |
| Bonus Buy | Info | The buy spin is canned, as Duel discloses, so the buy is not in the RTP table. 20 / 20 buys show 4 scatters and award 10 free spins, and their 203 free spins recompute (Steps 5, 24, 25) |
| Scaling House Edge | Info | Without Zero Edge, Duel's config adds 0.01% at $0.20, up to 1.15% on spins and 1.82% on bonus play at the $1,000 maximum stake. No captured bet had an edge applied. Explained from the config, not certified (S4.5) |
| Anti-Circularity | Pass | RTP derived from the published weights and paytable alone; the 30M simulation (100.06%) is scored against it, not against the 100% claim, and wrong trigger rules are rejected (Steps 16, 29–32) |
| Fairness Integrity | Pass | 18 fairness integrity tests: 15 pass, 2 flagged (server-side input-validation gaps at /spin and /buy — no fairness impact, both disclosed to Duel.com), 1 N/A |
| Determinism | Pass | Every grid, cascade and free spin recomputes from (serverSeed, clientSeed, nonce, round index) |
| Reproducibility | Pass | npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results |
Overall StatusPass
v1.2.1). The capture flag is Step 4: limited by our capture script, not a Duel issue.Enumerated RTPPass
Live ↔︎ Verifier ParityPass
Commit-Reveal SystemPass
Nonce AuditCapture flag
Client SeedPass
RNG AnalysisPass
Payout LogicPass
Bonus BuyInfo
Scaling House EdgeInfo
Anti-CircularityPass
Fairness IntegrityPass
/spin and /buy — no fairness impact, both disclosed to Duel.com), 1 N/ADeterminismPass
ReproducibilityPass
npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed resultsWhat Was Audited
✓ Audited
- Every grid and cascade is set by the server seed, client seed and nonce, and recomputes exactly (6,205 / 6,205 entries, 4,323 / 4,323 cascades)
- Revealed server seeds match their commitments (116 / 116), and the seed records link up
- Your client seed is a genuine input: changing it changes the outcome
- Every weighted draw is exactly proportional to the published weights
- Clusters, wilds, cascades, scatters, free spins and multipliers follow the published rules, and every payout is exact to the cent
- Enumerated RTP is 99.9720%, and Duel's 100% claim holds within ±0.1 pp
- The stake does not change the grid ($1 to $50 bets)
- Players can check every spin and every free spin
What Audit Excludes
- Scaling edge without Zero Edge (up to 1.15% on spins, 1.82% on bonus play) — explained from the config in S4.5
- Bonus buy — its first spin is canned, so the buy is not certified; the free spins it starts are
- Max win
- Rakeback and promotions — operator-side; 99.9720% is the enumerated RTP with no edge applied, as on every captured bet
- 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 server-seed hashing, the commitment links, reveal on rotation |
| Client Seed Origin | Browser-generated default, player-customisable; the capture's own seeds disclosed |
| Seed Handling | Client seed control, nonce lifecycle, seed pair rotation, free-spin nonce and round index |
| RNG Analysis | HMAC-SHA256 outcome index, tumble seed, PCG32 written from the specification, the discard rule and its bias bound |
| Cascade Mechanics | A fresh stream per cascade, gravity, fill from the fresh grid; all 4,323 captured cascades replayed |
| Payout Logic | Counted clusters with wilds, scatter pays, free-spin multipliers per spin, exact settlement, bet-size invariance |
| Buy-Bonus Mechanics | The disclosed canned buy spin, its 4 scatters and 10 free spins; the free spins recomputed |
| Live Parity | Our recomputation, Duel's Verify-tab code (cross-check) and the ProvablyFair.org verifier against the live game |
| RTP Validation | Anti-circularity, 2³² enumeration, exact session convolution, RTP claim rule, 30M simulation, cherry-pick test (Pass 2) |
| Fairness Integrity | 18-test integrity matrix — nonce, seed commitment, determinism, isolation, payout, plus 3 Groomer's Van-specific multi-step state tests (/buy, /confirm-animation, free-spin session) |
| Game Profile Coverage | All 30 Groomer's Van profile checks mapped to a step, a package check, or n/a |
What Audit Guarantees
- With no edge applied, the RTP is 99.9720% by exhaustive enumeration of all 2³² spin outcomes and exact convolution of the bonus, from the published weights and paytable alone; a 30M-spin simulation is consistent with it at 100.06%
- Duel's stated 100% holds under the RTP claim rule (0.028 pp below, inside ±0.1 pp)
- Every non-buy spin and free spin reproduces from (server seed, client seed, nonce, round index): 6,205 / 6,205
- Every cascade reproduces cell for cell from its own stream: 4,323 / 4,323
- Every multiplier value is drawn from the seeds with the published weights: 335 / 335 on first deals and 146 / 146 in cascades
- The casino can't change a spin after committing to the server seed; save the hash before you play to prove the timing
- The client seed is a genuine input: 623 / 623 outcome indexes change under a tampered seed
- The buy spin is the one part not drawn from the seeds, as Duel discloses; the 10 free spins it starts are
References
Groomer's Van — Game Rules8 sections▶
Groomer's Van is a 6-reel, 5-row cluster-pays slot with tumbling reels, wilds and a free-spin bonus with multipliers. Each spin deals a 30-cell grid; a symbol pays when 8 or more of it land anywhere on the grid, wilds counting toward it. Winning cells are removed and the gaps refill from above, cascading until no new cluster forms. 3 or more scatters start the bonus: 8, 10, 12 or 14 free spins for 3, 4, 5 or 6+ scatters, where multiplier symbols multiply each free spin's win.
How to Play
1. Enter bet amount — Choose how much to wager, from $0.20 to $1,000.
2. Spin — The reels produce a grid of 6 reels × 5 rows, 30 symbols.
3. Clusters — A symbol pays when 8 or more of it appear anywhere on the grid. Wilds count toward every paying symbol.
4. Tumble — Winning symbols and wilds are removed, the remaining cells fall, and new cells fill the top. Repeats until no new cluster forms.
5. Bonus trigger — 3+ scatters on the grid award free spins (3 scatters → 8 spins, 4 → 10, 5 → 12, 6+ → 14).
6. Buy-bonus shortcut — Pay 125× your stake to go straight to the free spins (no regular spin first).
7. Outcome — A spin pays its cluster wins over every cascade, plus any scatter pay. In the bonus, each free spin is paid on its own.
Cluster Pays
Unlike payline slots, Groomer's Van pays when 8 or more of the same symbol appear anywhere on the grid. There are no paylines, and the symbols don't need to touch.
- Minimum cluster size: 8 symbols — fewer than 8 of a symbol pays nothing
- No adjacency needed — symbols count wherever they land on the grid
- Wilds count toward every paying symbol — one wild can complete a
symbol_1cluster and asymbol_7cluster in the same round - Cluster size sets the tier — 8, 9, 10, 11 and 12+ symbols each have their own pay; a bigger cluster never pays less
Tumbling Reels
After each win, the winning symbols and the wilds are removed and the remaining cells fall to fill the gaps. New symbols enter from the top. The cascade can chain: a new cluster pays again and triggers another tumble.
- Cascades chain — a spin keeps tumbling until no new cluster forms or the 5,000× cap is reached
- Each cascade is independently verifiable — it draws from a fresh PCG32 stream seeded from the spin's outcome index
- Gravity fills column by column — remaining cells settle to the bottom of their column; new cells fill from the top
- Verified across all captured cascades — 4,323 of 4,323 reproduce cell for cell in the audit
Wild Substitution
The wild symbol substitutes for any paying symbol (symbol_1 to symbol_9) to help complete clusters. It does not substitute for scatters or multipliers.
- One wild can lift several clusters at once — 7 of one symbol and 7 of another both become paying clusters of 8 with one wild on the grid
- Wilds are part of the cluster count — 7
symbol_1+ 1 wild pays at the 8-symbol tier - Verified on the capture — 410 captured rounds pay two or more symbols with a wild on the grid, and every one counts the wilds for every cluster
Free-Spin Bonus & Multipliers
Three or more scatters on the grid start the bonus, with more free spins for more scatters: 3 award 8 spins, 4 award 10, 5 award 12, and 6+ award 14. Free spins use the bonus reels, which add the multiplier symbol.
- Free spins awarded scale with scatter count: 3 → 8, 4 → 10, 5 → 12, 6+ → 14 (Duel's published
scatter_rewards). - Multipliers land only in free spins, with values from 2× to 250×; they stay on the grid through that spin's cascades
- Multipliers add up, per spin — 2× and 5× landing in the same free spin multiply its cluster win by 7×; the next free spin starts fresh
- Multiplier values come from the published weights — 14 weighted values from 2× to 250×
- Retriggers — 3, 4, 5 or 6+ scatters in a free spin add 3, 5, 8 or 10 spins, up to 3 retriggers per bonus
Buy-Bonus
Players can skip directly to the free-spin round by paying 125× their current stake. This is the buy-bonus feature.
- Cost — 125× the current stake (e.g. $25 to buy at a $0.20 stake)
- Fixed result — every buy shows exactly 4 scatters and awards 10 free spins (Duel discloses this; all 20 captured buys did)
- The buy spin pays the 4-scatter 3× and starts the bonus — its grid is canned by Duel and isn't part of the provably fair chain
- The 10 free spins that follow are provably fair — 203 / 203 free spins from the captured buys recompute and reconcile
- Buy RTP not certified — a bought session's exact EV is 121.9996× the stake plus the 3× scatter pay, against 125×, but the buy spin isn't generated from the seeds
Seed Formats
Every Groomer's Van spin uses three cryptographic inputs to generate the result.
| Seed Type | Format | Example | Purpose |
|---|---|---|---|
| Server Seed | 64-char hex (32 bytes) | 38daabbe1a0a8e47… | Casino-provided randomness |
| Client Seed | Alphanumeric string | pf_ww6Oka8nm8byd | Player-contributed entropy |
| Nonce | Integer (0, 1, 2…) | 23 | One per paid spin in a seed pair; free spins use the nonce of the spin that started the bonus |
Parameters
| Parameter | Value | Notes |
|---|---|---|
| Grid Size | 5 rows × 6 columns | 30 cells per grid |
| Minimum Cluster Size | 8 symbols | Anywhere on the grid, wilds included; 12+ pays the 12 tier |
| Symbols | 9 paying symbols (4 common + 3 rare + 1 epic + 1 premium) + wild + scatter; the multiplier in free spins only | 11 in the base game, 12 in the bonus |
| Bonus Trigger | 3+ scatters | Awards 8–14 free spins (3 scatters → 8, 4 → 10, 5 → 12, 6 → 14) |
| Buy-Bonus Cost | 125× stake | Operator-disclosed guaranteed trigger |
| Max Win | 5,000× | Duel's max_multiplier; never reached in the capture |
| Min / Max Bet | $0.20 / $1,000 | Per regular paid spin — UI-enforced at the input level |
| House Edge | 0% with Zero Edge (every captured bet) | Without Zero Edge, 0.01% and up by stake (S4.5) |
| Enumerated RTP | 99.9720% | By full 2³² enumeration; 30M simulation at 100.06% |
| RNG Algorithm | HMAC-SHA256 → PCG32 | One HMAC per spin → fresh PCG32 stream per cascade round |
| RTP Claim | 100% (game settings) | PASS under RTP-CLAIM 1.2.0: 0.028 pp below, inside ±0.1 pp |
Why Provably Fair Matters▶
Traditional online casinos require players to trust that games are fair. Provably fair systems eliminate this trust requirement by allowing players to mathematically verify that outcomes were not manipulated. Every spin is cryptographically committed before play and fully reproducible afterwards from publicly disclosed inputs.
- The casino commits to a result before the player bets
- The player contributes randomness that the casino cannot predict
- Anyone can verify the outcome after the fact
High-Level Overview7 sections▶
Checklist Reference
Based on the ProvablyFair.org Audit Execution Checklist, here are the tests covered under this audit document.
1. Commit-Reveal System & Seed Handling
| Test | Description |
|---|---|
| Server seed commit exists before play | SHA-256 hash shown to player before betting |
| Server seed reveal matches commit | SHA-256(hexDecode(revealed)) = committed hash — 116 / 116 revealed seeds verified |
| Client seed control | Player can set/change client seed via rotation UI |
| Nonce increments correctly | Starts at 0 and rises by 1 per paid spin in each seed pair; 4 gaps from our capture script's retries (capture flag) |
| Full determinism | Same (serverSeed, clientSeed, nonce) → same grid and same cascade chain |
2. Randomness & Entropy Model
| Test | Description |
|---|---|
| RNG depends only on seeds + nonce | No external inputs — no drand, no timestamps, no server-side state |
| No mixed entropy sources | Audit independently verifies the two-layer pipeline: HMAC-SHA256 → outcome_index → PCG32 |
| Unbiased weighted draw | The discard rule leaves bias exactly 0 on all 13 weight totals |
| No state leakage | Each cascade and free spin draws from its own PCG32 stream — rounds are independent |
3. Verifier ↔ Live Parity
| Test | Description |
|---|---|
| Live outcomes match verifier | 6,205 / 6,205 non-buy entries reproduced across 186,150 grid cells |
| Cascade reproduction | 4,323 / 4,323 cascade rounds reproduce byte-exact — 129,690 cells |
| Multi-phase verification | Phases A–E: baseline, bracket sampling ($1–$50), buy-bonus, custom client seeds, edge cases; counts bound to the plan |
| Bet-size invariance | Same grid from the same seeds at any stake — 30 Phase B bets from $1 to $50 |
4. Game Logic & RTP Validation
| Test | Description |
|---|---|
| Anti-circularity check | 99.9720% RTP computed by full 2³² enumeration from per-reel weights + paytable alone |
| House edge audit | edge_multiplier 1 (Zero Edge) on all 6,225 captured bets; the scaling edge without Zero Edge is explained from the config, not certified |
| Payout rules correctness | All 6,205 non-buy entries reconcile exactly in integer cents, cascades and free spins included |
| Monte Carlo cross-check | 30M base spins + 132,222 bonus sessions corroborate the enumerated RTP at 100.06% |
| Cherry-pick detection | Aggregate z = +0.91; 115 seeds × 10,000 nonces, 4 flagged (p = 0.83): no sign of seed pre-selection |
| RTP claim rule (RTP-CLAIM 1.2.0) | Duel's 100% from the game settings, scored on Step 32 with a ±0.1 pp band — PASS |
5. Fairness Integrity & Player Verification
| Test | Description |
|---|---|
| Player can reproduce results offline | Using (serverSeed, clientSeed, nonce) inputs — every grid, cascade, and bonus session |
| Verifier logic matches live logic | Our RNG (written from the spec), Duel's Verify-tab code and the ProvablyFair.org verifier agree |
| Verifier publicly accessible | ProvablyFair.org verifier — no login required |
| No reliance on private APIs | Fully client-side verification using only published seeds |
| Fairness integrity tests | Commit-reveal, determinism, payout, isolation, plus GV-specific game-state surfaces (/buy, /confirm-animation, free-spin session state) |
High-Level Flow
To get an overview of how the process works, here is a high-level breakdown:
1. Player Bets — Selects stake; the game state (regular spin or free-spin session) determines which RNG pipeline applies
2. Seeds Combined — HMAC-SHA256(hexDecode(serverSeed), hex(clientSeed) + ':' + nonce) produces a 256-bit hash
3. Outcome Index — First 4 bytes of the HMAC output become the 32-bit outcome_index for this spin
4. Grid Generation — outcome_index seeds a PCG32 stream that drives bias-free rejection-sampled weighted draws across all 30 grid cells
5. Cascade Rounds — Each cascade draws from a fresh PCG32 stream seeded from the spin's outcome_index, round and cascade number
6. Payout Resolution — A symbol pays when 8 or more of it, wilds included, are on the grid; winning cells are removed and the grid tumbles until no new cluster forms
Provably Fair Model
Provably fair gambling systems use cryptographic primitives to guarantee the integrity of outcomes. The model relies on three components: a server seed committed via hash before play, a player-controlled client seed, and an incrementing nonce. These inputs are combined using HMAC-SHA256 to produce deterministic, verifiable results. This section documents the global provably fair architecture used by almost all casinos and all relevant games.
Commit-Reveal Model
The Commit-Reveal model is integral to ensuring fairness and transparency in online gambling. This model involves several key phases:
Commit Phase:
Before any bets are placed, the casino generates a random server seed. To prove its authenticity and prevent later manipulation, only the SHA-256 hash of the hex-decoded seed is sent to the player. This ensures that while the player cannot know the seed initially, they can verify it later.
Bet Phase:
The player places their bet. The server combines the server seed with the player's client seed via HMAC-SHA256 to compute each spin's outcome_index, which then seeds the PCG32 stream for the full cascade chain. Each seed pair uses the same server seed and client seed throughout its lifetime.
Reveal Phase:
After the seed pair ends, the server rotates seeds and reveals the plaintext server seed. The player can now independently verify SHA-256(hexDecode(serverSeed)) = committedHash.
Verify Phase:
Anyone can recompute every spin's outcome_index and full cascade chain from the revealed server seed, client seed, and nonce using the published HMAC-SHA256 → PCG32 pipeline.
Player-Controlled Client Seed
Duel generates the default client seed in your browser and sends it when you rotate seeds. You can set your own at any time. This ensures:
- The casino cannot predict the full RNG input
- Players contribute entropy that they control
- Results depend on both parties' inputs
Nonce Lifecycle
The nonce is a counter that increments with each bet within a seed pair:
- Starts at 0 for each new server seed
- Increments by exactly 1 per paid spin or bonus buy
- Free spins use the nonce of the spin that started the bonus, with their own round index
- Never reused within the same seed pair
Seed Pair: (serverSeed, clientSeed) Bet 1: nonce = 0 → Grid A + cascade chain ABet 2: nonce = 1 → Grid B + cascade chain BBet 3: nonce = 2 → Grid C + cascade chain C ...[Player rotates seed — seed pair complete]Next bet: nonce = 0 → Grid X (new seed pair)Determinism Guarantee
Given identical inputs, the output is always identical:
HMAC-SHA256(hexDecode(serverSeed), hex(clientSeed) + ':' + nonce) → Always same hashFirst 4 bytes of hash → Always same outcome_indexoutcome_index + round + cascade number → Always same PCG32 streamPCG32 stream + per-reel weights → Always same 30-cell gridSame grid + same cascade depth → Always same cascade roundSame cascade chain + same paytable → Always same payoutTechnical Glossary7 categories▶
Framework 1.1
| Term | Definition |
|---|---|
| Framework 1.1 | The ProvablyFair.org audit framework this report is certified under (October 2026). It adds the RTP claim rule, capture flags, the base-stake-tier rule, the standard S5 matrix and game profile coverage. |
| Capture flag | A flag caused by our capture, not by the casino — here, four nonces our capture script missed on retried requests. Disclosed and counted, and verdict-neutral. |
| RTP claim rule | RTP-CLAIM 1.2.0. Holds the audited RTP to the figure the casino publishes (game page, fairness page, help page, bet panel, rules or game settings) within ±0.1 pp. A house-side miss makes the verdict RTP FIGURE OVERSTATED (exit 5). |
| Base stake tier | The tier the audit's guarantees apply to. For Groomer's Van: play with no edge applied (Zero Edge, edge_multiplier 1), as on every captured bet from $0.20 to $50. |
Core Concepts
| Term | Definition |
|---|---|
| Provably Fair | A cryptographic system that allows players to mathematically verify that game outcomes were not altered. Relies on commit-reveal schemes and deterministic algorithms. |
| Commit-Reveal Protocol | A two-phase process in which the casino commits to a result (by showing its hash) before the player bets, then reveals the actual value after the bet. |
| Determinism | The property that identical inputs always produce identical outputs. Same (serverSeed, clientSeed, nonce) must always generate the same grid and the same cascade chain. |
| Client Seed Origin | The method by which the client seed is generated. Full Pass: browser-generated default + player customizable seed. Conditional Pass: server-assigned default + player customizable seed. Hard Fail: player cannot set own seed. |
Seed System
| Term | Definition |
|---|---|
| Server Seed | A random 32-byte value generated by Duel.com, transmitted as a 64-character hex string. Hashed and shown to players before betting, revealed after seed-pair rotation. |
| Client Seed | A random value controlled by the player, generated by the browser. Players can change it at any time via the seed rotation UI. |
| Nonce | A counter that rises by 1 per paid spin within a seed pair and starts at 0 for each new server seed. Free spins use the nonce of the spin that started the bonus. |
| Hashed Server Seed | SHA-256(hexDecode(serverSeed)) — the commitment hash shown before betting. After rotation, players verify the revealed seed produces this hash. |
| Seed Pair | A sequence of bets using the same server seed and client seed pair. Ends when the player rotates seeds. |
Cryptographic Functions
| Term | Definition |
|---|---|
| HMAC-SHA256 | Hash-based Message Authentication Code using SHA-256. Duel Groomer's Van uses HMAC-SHA256 with the hex-decoded server seed as key and hex(clientSeed) + ':' + nonce as message. One HMAC call per spin produces the outcome_index. |
| SHA-256 | Secure Hash Algorithm 256-bit. Used for server seed commitment: SHA-256(hexDecode(serverSeed)) = serverSeedHashed. |
| PCG32 | Permuted Congruential Generator producing 32-bit integers. Seeded from the spin's outcome_index, round and cascade number via one SplitMix64 step; drives the weighted draws of every grid cell and multiplier value. |
| Rejection Sampling | Removes modulo bias from a weighted draw: a value at or above the largest whole multiple of the weight total is discarded and drawn again. Step 5 measures it on all 13 weight totals: bias exactly 0. |
Game Mechanics
| Term | Definition |
|---|---|
| Cluster Pays | Payout mechanic where a symbol pays when 8 or more of it appear anywhere on the grid, wilds counting toward it; no adjacency needed. Sizes above 12 pay the 12 tier. |
| Tumbling Reels | After each win, winning cells are removed; remaining cells fall to fill gaps; new cells enter from the top. Repeats until no new clusters form. Also called a cascade or avalanche mechanic. |
| Wild Substitution | The wild counts as any paying symbol (symbol_1 to symbol_9), not as a scatter or multiplier. A wild counts toward every cluster on the grid at once. |
| Free-Spin Bonus | Triggered by 3+ scatters on a regular spin. Awards 8–14 free spins (3 → 8, 4 → 10, 5 → 12, 6+ → 14), with multipliers that are summed per free spin and multiply that spin's win. |
| Multiplier Bomb | A multiplier symbol that lands in a free spin with a value from 2× to 250×. It stays on the grid through that spin's cascades; the values that land are summed and multiply the spin's total cluster win. It doesn't carry to the next free spin. |
| Buy-Bonus | A 125× stake purchase that goes straight to the free spins. The buy spin always shows 4 scatters and awards 10 free spins; Duel generates its grid outside the seeds. The 10 free spins that follow are provably fair. |
| Outcome Index | The 32-bit unsigned integer derived from HMAC-SHA256 output (first 4 bytes, big-endian). Seeds the PCG32 stream for the entire spin's grid and cascade chain. |
| Scaling House Edge | Duel's stake-based edge for play without Zero Edge (config v1.4): 116 spin brackets (0.01% → 1.16%) and 184 bonus brackets (0.01% → 1.84%). Explained from the config, not certified — see S4.5. |
Verification Terms
| Term | Definition |
|---|---|
| Verifier | A tool that reproduces grids and cascades from (serverSeed, clientSeed, nonce). Step 5 runs ProvablyFair.org's verifier code, pinned by SHA-256, on all 5,730 captured base spins. |
| Parity | Degree of matching between verifier and live game results. 100% parity = every grid cell and every cascade matches. This audit: 6,205 / 6,205 spins · 186,150 / 186,150 cells · 4,323 / 4,323 cascade rounds. |
| Anti-Circularity Check | Independent computation of RTP from operator-published weights and paytable alone, with no operator-supplied RTP figure entering the chain. For Groomer's Van: 99.9720%, computed by full 2³² enumeration (a 30M Monte Carlo corroborates at 100.06%). |
| Cherry-Pick Detection | Test for selective seed deployment: the captured return against the reference (z = +0.91), and each of the 115 base-spin seeds replayed for 10,000 nonces against the exact win rate — 4 flagged, within chance (p = 0.83). |
Audit Terms
| Term | Definition |
|---|---|
| Phase A–E | The five capture phases: A baseline (5,000 spins at $0.20), B bracket sampling (30 spins, $1–$50), C buy-bonus (20 buys), D custom client seeds (500 spins on 10 seeds), E edge cases / replay (200 spins). |
| Zero Edge | Duel's account setting under which every bet returns edge_multiplier 1: no edge on top of the game's own return. Active on all 6,225 captured bets. |
Seed, Nonce & Determinism
Can the casino change your outcome after you bet?
Every Groomer's Van spin comes from three inputs: server seed, client seed and nonce. Duel commits to the server seed by showing its SHA-256 hash before you bet, and reveals the seed when you rotate. The whole spin, the first deal, every cascade and any free spins it triggers, follows from those inputs. A hash match shows the records are consistent; the proof of timing is a copy of the hash you saved before playing.
What we verified
- Every revealed server seed hashes to its commitment (116 / 116)
- The seed records link up: each rotation's active hash is the one the previous rotation showed as next (116 / 116)
- That each commitment was shown before its bets rests on the capture's records
- Nonces: 112 / 116 epochs gap-free, no reuse; four nonces missed by our capture script
- Identical inputs always give the same 30-cell grid (6,205 / 6,205)
- Your client seed is a genuine input: a tampered seed changes the outcome index in 623 / 623 cases
What this means for you
- Once a server seed is committed, it can't be swapped without the hash check failing
- Every cell is fixed by the seeds before the reels animate
- Save the hashed server seed before you play: your saved copy is what proves the timing
- Setting your own client seed adds your input to every spin
- Any spin can be recomputed after you rotate your seed
- Every revealed server seed hashes to its commitment (116 / 116)
- The seed records link up: each rotation's active hash is the one the previous rotation showed as next (116 / 116)
- That each commitment was shown before its bets rests on the capture's records
- Nonces: 112 / 116 epochs gap-free, no reuse; four nonces missed by our capture script
- Identical inputs always give the same 30-cell grid (6,205 / 6,205)
- Your client seed is a genuine input: a tampered seed changes the outcome index in 623 / 623 cases
- Once a server seed is committed, it can't be swapped without the hash check failing
- Every cell is fixed by the seeds before the reels animate
- Save the hashed server seed before you play: your saved copy is what proves the timing
- Setting your own client seed adds your input to every spin
- Any spin can be recomputed after you rotate your seed
Seed hash integrityPass
Commitment linkagePass
Hash consistency within epochPass
Nonce sequencingCapture flag
Deterministic outputPass
Client seed participationPass
Client seed originPass
crypto.getRandomValues, and players can set their own (E02). The capture's own seeds are disclosed in S1.4All 116 revealed seeds hash to their commitments and the seed records link up. Every spin recomputes from (server seed, client seed, nonce). When each commitment was shown rests on the capture's records. Step 4 is a capture flag: four nonces our capture script missed, disclosed and verdict-neutral.
| Check | Result | Evidence |
|---|---|---|
| Seed hash integrity | Pass | 116 / 116 revealed seeds hash to their commitments. The 117th record is the seed still active when the capture closed; no bet used it (Step 1) |
| Commitment linkage | Pass | 116 / 116 links consistent (Step 2). A consistency check: the timing rests on the capture's records, and the chain starts at the first captured epoch |
| Hash consistency within epoch | Pass | All 6,225 bets carry the hash and client seed of the rotation active when they were placed, across 116 epochs (Step 3) |
| Nonce sequencing | Capture flag | 112 / 116 epochs gap-free, no reuse. Four nonces were missed on retried requests: limited by our capture script, not a Duel issue (Step 4) |
| Deterministic output | Pass | 6,205 / 6,205 spins and free spins reproduce all 30 cells from (server seed, client seed, nonce, round index) (Step 5) |
| Client seed participation | Pass | 623 / 623 published outcome indexes change under a tampered client seed (Step 6); 500 Phase D bets reproduce under 10 auditor seeds (Step 15) |
| Client seed origin | Pass | Duel's default seed is generated in the browser with crypto.getRandomValues, and players can set their own (E02). The capture's own seeds are disclosed in S1.4 |
Seed hash integrityPass
Commitment linkagePass
Hash consistency within epochPass
Nonce sequencingCapture flag
Deterministic outputPass
Client seed participationPass
Client seed originPass
crypto.getRandomValues, and players can set their own (E02). The capture's own seeds are disclosed in S1.4All 116 revealed seeds hash to their commitments and the seed records link up. Every spin recomputes from (server seed, client seed, nonce). When each commitment was shown rests on the capture's records. Step 4 is a capture flag: four nonces our capture script missed, disclosed and verdict-neutral.
How It Works — Seed, Nonce & Determinism7 sections
1.1Server Seed Commitment
Before any bet, Duel commits to a secret server seed by showing its SHA-256 hash. The server seed is a 64-character hex string (32 bytes), and the commitment is SHA-256(hexDecode(serverSeed)): the hash of the 32 bytes, not of the hex text. When you rotate your seed pair, Duel reveals the seed and anyone can check that it hashes to the commitment. A match shows the two are consistent. The proof that the seed was fixed before you played comes from a copy of the hash you saved before betting.
// §1.2: the commitment is SHA-256 over the decoded seed bytes (not over its ASCII text), as lowercase hex.export function hashServerSeed(serverSeedHex: string): string { return createHash("sha256").update(hexToBytes(serverSeedHex)).digest("hex");}Real seed record:
{ "clientSeed": "pf_ww6Oka8nm8byd", "serverSeedHashed": "1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd", "nextServerSeedHash": "eb088078f74ec417a442f975f3c2249914e07d3c35a0711a5fbe331eafcb82eb", "serverSeed": "38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67"} // SHA-256(hex_decode(serverSeed))// = 1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd matches serverSeedHashed1.2Commitment Linkage
At every rotation Duel shows the hash of the seed it will activate next (nextServerSeedHash). Step 2 checks all 116 links: each rotation record's active serverSeedHashed must equal the nextServerSeedHash the previous record showed. The links show the records agree on the order the seeds were activated in, not when each hash was shown. That rests on the capture's records, each written before its epoch's bets. The capture holds no link from before its first rotation, so the chain starts at the first captured epoch.
for (let i = 1; i < ctx.seeds.length; i++) { const prevNext = ctx.seeds[i - 1].seed.nextServerSeedHash; const currHash = ctx.seeds[i].seed.serverSeedHashed; if (prevNext === currHash) linked++; else if (examples.length < 3) { examples.push(`seeds[${i - 1}].next=${prevNext.slice(0, 16)} ≠ seeds[${i}].active=${currHash.slice(0, 16)}`); }}1.3Hash Consistency Within Epoch
The capture holds 117 seed records, one for every rotation it requested. 116 carry bets; the last, rotate-phase-final, is the closing rotation, with no bet.
Step 3 assigns each bet to an epoch by the capture timeline, not by the bet's own hash, and checks that every bet carries the serverSeedHashed and the client seed of the rotation that was active when it was placed. A mid-epoch seed change would show up as a disagreement.
const vdCs = b.verifyData?.client_seed;if (b.activeAtSpin.client_seed !== w.record.seed.clientSeed || (vdCs !== undefined && vdCs !== null && vdCs !== w.record.seed.clientSeed)) { clientSeedMismatched++; bad++; if (examples.length < 3) examples.push(`bet ${b.spinId}: client seed ${b.activeAtSpin.client_seed}${vdCs ? ` / verify ${vdCs}` : ''} ≠ rotation '${w.record.context}' client seed ${w.record.seed.clientSeed}`); continue;}if (b.activeAtSpin.server_seed_hashed !== w.record.seed.serverSeedHashed) { bad++; if (examples.length < 3) { examples.push(`bet ${b.spinId} placed ${b.startedAt} under rotation '${w.record.context}' (${w.record.at}) records hash ` + `${b.activeAtSpin.server_seed_hashed.slice(0, 16)}… but that rotation committed ${w.record.seed.serverSeedHashed.slice(0, 16)}…`); }}1.4Client Seed Origin & Control
The client seed is the player's input. Duel fills in a default in your browser, and you can replace it with your own before you rotate. Because the server committed to its seed before it sees the client seed you send, it can't pick a server seed to suit yours, as long as you change the client seed when you rotate.
- Duel's default: 16 characters from a 63-character alphabet, drawn with rejection-sampled
crypto.getRandomValuesin your browser, filled in by the seed-rotation panel and sent only when you rotate (E02) - Your own: any client seed you type replaces it; Phase D's 500 bets on 10 auditor-chosen seeds all reproduce (Step 15)
- Our capture's seeds: Phases A, B, C and E used
pf_plus 13 characters from the capture script'sMath.random(); Phase D used the fixed stringspfaudit_groomers_seed00…09. These are choices on our side; they don't change what Duel's server does with a seed
1.5Nonce Audit
The nonce starts at 0 for each server seed and rises by 1 for every paid bet: a base spin or a bonus buy. Free spins don't take a nonce of their own; they use the nonce of the spin that started the bonus. Duel reveals a server seed only when you rotate. Our capture rotated after every 50 regular bets; that 50-bet epoch is our schedule, not Duel's.
Step 4 checks every epoch for gaps, reuse and a single client seed, and every gap must be one src/loader.ts declares by epoch and nonce. In four epochs our capture script retried a request and missed one round each: nonce 47 in epoch d6bebb43, 2 in 22f48a0f, 22 in 77544e55 and 9 in 3052a819. The server used the nonce, so it shows as a gap. The outcome index at each missed nonce follows from the revealed seed, but the round itself wasn't captured, so those four rounds are not verified. In the same four epochs the capture's pre-bet snapshot recorded the next bet one nonce too low (spins 1965523, 1974625, 1976463 and 1987633); Step 5 reproduces each at the nonce it was served at and not at the recorded one. Limited by our capture script, not a Duel issue.
for (const [n, c] of used) { if (c > 1) { bad = true; if (problems.length < 5) problems.push(`epoch ${hash.slice(0, 16)}: nonce ${n} used by ${c} bets`); }} if (!EXPECTED_NONCE_GAPS.some(g => g.epochHash === hash && g.nonce === n)) { bad = true; if (problems.length < 5) problems.push(`epoch ${hash.slice(0, 16)}: undeclared nonce gap at ${n}`);}if (seedPlain && clientSeeds.size === 1) { const oi = computeOutcomeIndex(seedPlain, [...clientSeeds][0], n); gaps.push({ epoch: hash.slice(0, 16), nonce: n, outcomeIndex: oi });} else { bad = true; gaps.push({ epoch: hash.slice(0, 16), nonce: n, outcomeIndex: null }); if (problems.length < 5) { problems.push(`epoch ${hash.slice(0, 16)}: nonce ${n} unused and NOT recomputable ` + (seedPlain ? `(${clientSeeds.size} client seeds in the epoch)` : '(server seed not revealed)')); }}d6bebb43 #47), 4,089,378,259 (22f48a0f #2), 1,679,779,331 (77544e55 #22), 1,737,852,047 (3052a819 #9). Disclosed, verdict-neutral.1.6Deterministic Mapping
The first layer of the RNG is fully deterministic: the same server seed, client seed and nonce always give the same 32-bit outcome_index. Our src/rng.ts was written from the specification (docs/ALGORITHM.md) by an implementer who never opened Duel's code. The server seed is hex-decoded to 32 bytes for the HMAC key, the client seed is hex-encoded into the message, and the message is hex(clientSeed):nonce, with no cursor: one HMAC per spin. The first 4 bytes, read big-endian, are the outcome_index, which seeds every grid of the spin (S2).
// §2.2: outcome_index.export function computeOutcomeIndex(serverSeedHex: string, clientSeed: string, nonce: number): number { assertIndex(nonce, "nonce"); // §2.2 step 1: the HMAC key is the server seed decoded from hex. const key = hexToBytes(serverSeedHex); // §2.2 step 2: the client seed's UTF-8 bytes, each written as two lowercase hex digits. const clientPart = Buffer.from(clientSeed, "utf8").toString("hex"); // §2.2 step 3: that hex text, a colon, then the nonce in plain decimal; ASCII message. const message = `${clientPart}:${nonce.toString(10)}`; // §2.2 step 4: HMAC-SHA256 with the key over the message. const digest = createHmac("sha256", key).update(message, "ascii").digest(); // §2.2 step 5: first 4 digest bytes as an unsigned big-endian 32-bit integer. return digest.readUInt32BE(0);}Worked Example — Real Bet:
// Source: data/groomers-van-smoke-test-1778204681017.json.gz{ "spin_id": 1964586, "serverSeed": "38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67", "serverSeedHashed": "1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd", "clientSeed": "pf_ww6Oka8nm8byd", "nonce": 49, "outcome_index_hex": "1a638947"} // message = hex("pf_ww6Oka8nm8byd") + ":49" = "70665f7777364f6b61386e6d38627964:49"// HMAC-SHA256(hex_decode(serverSeed), message), first 4 bytes = 1a638947 matches the published value1.7Client Seed Influence
To confirm the client seed is a genuine HMAC input, every entry whose verify record publishes an outcome index (623 of them) is recomputed with _PF_TAMPERED appended to its client seed. Every one must change, with no exceptions allowed: a match by chance would need a 32-bit collision. Separately, Phase D placed 500 bets on 10 auditor-chosen client seeds (pfaudit_groomers_seed00 … 09, 50 each), and all 500 reproduce their 30-cell grids (Step 5). The server uses the seed the player sets.
for (const b of eligible) { const vd = b.verifyData!; const tampered = computeOutcomeIndex(vd.server_seed, `${vd.client_seed}_PF_TAMPERED`, vd.nonce); if (tampered !== vd.outcome_index) differ++; else if (same.length < 3) same.push(`bet ${b.spinId}`);}Technical Evidence & Verification5 sections
1.8Evidence Coverage Summary6 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Seed hash integrity (Step 1) | 116 / 116 revealed seeds; the 117th record has no bet | Pass |
| Commitment linkage (Step 2) | 116 / 116 links | Pass |
| Hash consistency (Step 3) | 6,225 bets, 116 epochs, 0 mismatches | Pass |
| Nonce audit (Step 4) | 112 / 116 clean; 4 capture-retry gaps (limited by our capture script) | Capture flag |
| Outcome recomputation (Step 5) | 6,205 / 6,205 spins and free spins, 30 cells each | Pass |
| Client seed influence (Step 6) | 623 / 623 change under a tampered seed | Pass |
1.9Code References7 source files
| File | Purpose |
|---|---|
| tests/verify.ts | 35 scored steps (Steps 1–6 cover S1) and the reproduction gate |
| tests/steps/commitment.ts | Steps 1–4: commitments, links, epochs, nonces |
| tests/steps/determinism.ts | Steps 5–6: grid recomputation and client seed influence |
| src/rng.ts | Commitment, outcome index, tumble seed, PCG32 and the weighted draw, written from docs/ALGORITHM.md |
| docs/ALGORITHM.md | The written specification the RNG code was built from |
| src/loader.ts | Dataset loading, the hash guard, the declared population, nonce gaps and nonce corrections |
| capture/capture.reference.js | Non-runnable reference record of the capture script |
1.10Datasets UsedSource artifacts
| Property | Value |
|---|---|
| Source | Live capture from duel.com, 7–8 May 2026: 6,225 entries across 5 phases (A 5,248 · B 30 · C 223 · D 524 · E 200) |
| Total records | 6,225 entries (5,730 spins, 20 bonus buys, 475 free spins) · 117 seed records (116 revealed) |
| SHA-256 | 3034cb1284bc1a87d82a0d8f914b19d7f1a8f16894ffe601242bd29e3873b967 |
| Pre-flight check | tests/verify.ts stops before any step runs if the loaded file's SHA-256 differs from EXPECTED_HASH in src/loader.ts |
Fields used in S1: activeAtSpin.server_seed_hashed, activeAtSpin.client_seed, nonce, phase, the seed records (seeds[].seed.serverSeedHashed, nextServerSeedHash, serverSeed, clientSeed) and, where present, the verify record (verifyData.*). The plaintext serverSeed on the seed records was attached when the capture was exported, from the post-rotation /verify responses.
1.11Verified Invariants8 invariants
| Invariant | Result |
|---|---|
SHA-256(hexDecode(serverSeed)) = serverSeedHashed for all 116 revealed seeds | Pass |
| Each rotation's active hash equals the previous rotation's next hash, for all 116 links | Pass |
| Every bet carries the hash and client seed of the rotation active when it was placed | Pass |
| No nonce reused in any epoch; one client seed per epoch | Pass |
Nonce gaps only where src/loader.ts declares a capture retry (4) | Capture flag |
| Same inputs give the same 30-cell grid for all 6,205 spins and free spins | Pass |
| A tampered client seed changes the outcome index on all 623 entries that publish one | Pass |
| 117 seed records carry 117 distinct commitments | Pass |
1.12Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 1 — Seed Hash Integrity
[PASS] Step 2 — Commitment Linkage
[PASS] Step 3 — Hash Consistency Within Epoch
[FLAG:capture] Step 4 — Nonce Audit
[PASS] Step 5 — Outcome Recomputation
[PASS] Step 6 — Client Seed InfluenceRNG & Entropy Model
Is the randomness genuinely random, or could it be rigged?
Our RNG is our own implementation, written from the specification without opening Duel's code. It reproduces every one of the 6,205 captured grids and all 4,323 cascades, and Duel's own Verify-tab code, run unmodified, agrees as a cross-check. One HMAC-SHA256 per spin gives an outcome index; each cascade then draws its cells from its own PCG32 stream, and the discard rule makes every weighted draw exactly unbiased.
What we verified
- The RNG is our own implementation, written from the specification, not ported from Duel's code
- It reproduces every captured grid; Duel's Verify-tab code, run unmodified as a second check, agrees on all 6,205
- Only the disclosed inputs reach the grid: server seed, client seed and nonce, plus the round and cascade counters
- Every weighted draw is exactly proportional to its weights: the discard rule leaves zero bias on all 13 weight totals
- 30M simulated spins find no sign of bias in the per-reel symbol counts (0 / 6 reels fail)
- Serial tests on 100,000 simulated payouts find no sign of dependence
What this means for you
- Each cell is a fair weighted draw from its reel's published weights
- No hidden randomness or server-side state enters the grid
- Every cascade starts a fresh stream, so one round can't steer the next
- The algorithm depends only on seeds you can check
- The RNG is our own implementation, written from the specification, not ported from Duel's code
- It reproduces every captured grid; Duel's Verify-tab code, run unmodified as a second check, agrees on all 6,205
- Only the disclosed inputs reach the grid: server seed, client seed and nonce, plus the round and cascade counters
- Every weighted draw is exactly proportional to its weights: the discard rule leaves zero bias on all 13 weight totals
- 30M simulated spins find no sign of bias in the per-reel symbol counts (0 / 6 reels fail)
- Serial tests on 100,000 simulated payouts find no sign of dependence
- Each cell is a fair weighted draw from its reel's published weights
- No hidden randomness or server-side state enters the grid
- Every cascade starts a fresh stream, so one round can't steer the next
- The algorithm depends only on seeds you can check
RNG derived only from disclosed inputsPass
Implementation written from the specPass
src/rng.ts rebuilt from docs/ALGORITHM.md without opening Duel's code; the spec's own vectors and properties pass 166 / 166Operator code cross-checkPass
Modulo biasPass
Key encodingPass
Per-reel symbol distributionPass
Serial independencePass
Client seed influencePass
Our RNG, written from the specification, reproduces every captured grid and cascade, and Duel's own code agrees as a second check. Every weighted draw is exactly unbiased by construction. 30M simulated spins find no sign of bias in the reel weights or of serial dependence.
| Check | Result | Evidence |
|---|---|---|
| RNG derived only from disclosed inputs | Pass | HMAC-SHA256 → outcome index → one PCG32 stream per (round, tumble); every grid and cascade recomputes from these alone (Steps 5, 28) |
| Implementation written from the spec | Pass | src/rng.ts rebuilt from docs/ALGORITHM.md without opening Duel's code; the spec's own vectors and properties pass 166 / 166 |
| Operator code cross-check | Pass | Duel's Verify-tab code, run unmodified: outcome index and grid 6,205 / 6,205; given the published multiplier weights as a list, its first-deal multiplier values match 335 / 335 (Step 5, S3.6) |
| Modulo bias | Pass | Every accepted window is a whole number of totals on all 13 weight totals: bias exactly 0. The capture holds 3 discarded draws, and those spins reproduce only with the discard (Step 5) |
| Key encoding | Pass | Server seed hex-decoded to 32 bytes, client seed hex-encoded into the message; all 6,205 reproduce with it (Step 5) |
| Per-reel symbol distribution | Pass | 30M simulated spins: per-reel χ², 0 / 6 reels fail at Bonferroni α = 0.0017. The 5,730 live base spins also fit the weights on all 6 reels (Steps 17, 35) |
| Serial independence | Pass | 100,000 simulated payouts: lag-1 |z| = 0.57 (threshold 3.14), runs p = 0.9666 (Step 17) |
| Client seed influence | Pass | 623 / 623 published outcome indexes change under a tampered client seed (Step 6) |
RNG derived only from disclosed inputsPass
Implementation written from the specPass
src/rng.ts rebuilt from docs/ALGORITHM.md without opening Duel's code; the spec's own vectors and properties pass 166 / 166Operator code cross-checkPass
Modulo biasPass
Key encodingPass
Per-reel symbol distributionPass
Serial independencePass
Client seed influencePass
Our RNG, written from the specification, reproduces every captured grid and cascade, and Duel's own code agrees as a second check. Every weighted draw is exactly unbiased by construction. 30M simulated spins find no sign of bias in the reel weights or of serial dependence.
How It Works — RNG & Entropy Model7 sections
2.1RNG Function Implementation
Each spin builds its grids in two layers. Layer 1 computes one outcome_index per spin from the seeds and nonce (S1.6). Layer 2 mixes that index with the round index (0 for a base spin; the free-spin number in a bonus) and the tumble index (0 for the initial deal, then 1, 2, … for each cascade) into a 32-bit tumble seed. The tumble seed sets a fresh PCG32 stream, and the stream draws the 30 cells column-major (reel 0 top to bottom, then reel 1, …), each from its reel's published weights, then one value for every multiplier cell.
Our src/rng.ts was written from the specification docs/ALGORITHM.md by an implementer who never opened Duel's code. No public page describes the per-spin seed step (seeds to outcome index, outcome index to PCG32 state, and the discard rule), so that step of the specification was written from Duel's Verify-tab code, in the specification's own words, and it says so. Duel's Verify-tab code is also run unmodified, as a second check only.
| Component | Detail |
|---|---|
| Hash function | HMAC-SHA256 |
| Key | hex_decode(serverSeed): 32 bytes |
| Message | hex(utf8(clientSeed)) + ":" + nonce: no cursor, one HMAC per spin |
| Layer 1 output | First 4 bytes, big-endian → outcome_index (uint32) |
| Layer 2 tumble seed | XOR in low32((round + 1) × 0x9E3779B9) and low32((tumble + 1) × 0x85EBCA6B), then xor-shift 16, × 0xC2B2AE35, xor-shift 16 |
| PRNG | PCG32 (XSH-RR 64/32 output); state from one SplitMix64 step on the tumble seed; multiplier and increment both 0x5851F42D4C957F2D; no warm-up draw |
| Cell draw | Discard u ≥ (2³² − 1) − ((2³² − 1) mod T), then walk the reel's cumulative weights to u mod T |
| Grid order | Column-major: position = reel × 5 + row, reel 0–5, row 0 (top) – 4 |
| Multiplier values | Bonus game only: after the 30 cells, one draw per multiplier cell in position order, from the 200-entry weighted list |
| Cascades | Every tumble starts a fresh stream; emptied top cells take the fresh grid's cells at the same positions |
// §2.4a "Tumble seed": mix outcome_index with round and tumble using 32-bit arithmetic.export function deriveTumbleSeed(outcomeIndex: number, roundIndex: number, tumbleIndex: number): number { assertUint32(outcomeIndex, "outcomeIndex"); assertIndex(roundIndex, "roundIndex"); assertIndex(tumbleIndex, "tumbleIndex"); let x = outcomeIndex >>> 0; // XOR in the low 32 bits of (r + 1) * 0x9E3779B9; Math.imul keeps exactly the low 32 bits. x = (x ^ Math.imul((roundIndex + 1) >>> 0, 0x9e3779b9)) >>> 0; // XOR in the low 32 bits of (t + 1) * 0x85EBCA6B. x = (x ^ Math.imul((tumbleIndex + 1) >>> 0, 0x85ebca6b)) >>> 0; // Final avalanche: xor-shift 16, multiply by 0xC2B2AE35 (low 32 bits), xor-shift 16. x = (x ^ (x >>> 16)) >>> 0; x = Math.imul(x, 0xc2b2ae35) >>> 0; x = (x ^ (x >>> 16)) >>> 0; return x;} // §2.4a "PCG32 step": multiplier and increment are the same 64-bit constant.const PCG_MULT = 0x5851f42d4c957f2dn; // 6364136223846793005const PCG_INC = 0x5851f42d4c957f2dn; export class Pcg32 { state: bigint; constructor(seed32: number) { assertUint32(seed32, "seed32"); // §2.4a "PCG32 state from the tumble seed": widen to 64 bits, then one SplitMix64 output step. let z = (BigInt(seed32 >>> 0) + 0x9e3779b97f4a7c15n) & MASK64; z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & MASK64; z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & MASK64; // No warm-up draw: the first output is produced from this state (§2.4a). this.state = (z ^ (z >> 31n)) & MASK64; } nextUint32(): number { const old = this.state; // §2.4a: XSH-RR output from the current state ... const xorshifted = Number((((old >> 18n) ^ old) >> 27n) & 0xffffffffn); const rot = Number(old >> 59n); const out = ((xorshifted >>> rot) | (xorshifted << ((32 - rot) & 31))) >>> 0; // ... then advance: state = state * multiplier + increment (mod 2^64). this.state = (old * PCG_MULT + PCG_INC) & MASK64; return out; }}2.2Entropy Sources
All randomness comes from HMAC-SHA256 over three disclosed inputs. Two counters then pick the stream:
| Source | Controlled By | Purpose |
|---|---|---|
| Server Seed | Casino | Base randomness (committed by its SHA-256 hash before betting) |
| Client Seed | Player | Player-contributed input |
| Nonce | System | One per paid bet, rising by 1 within each epoch |
| Round index | System | 0 for a base spin; the free-spin number inside a bonus |
| Tumble index | System | 0 for the initial deal, then one per cascade |
How we know: 6,205 / 6,205 spins and free spins, and all 4,323 cascades, recompute from the declared inputs alone. A hidden input would break the recomputation; it doesn't.
No timestamps, no Math.random(), no external APIs, no server-side state. The round and tumble indexes are counters, not entropy: they only keep the streams of different free spins and cascades apart.
2.3Modulo Bias Analysis
Each cell is a weighted draw against its reel's weight total T (13 distinct totals across the base reels, the bonus reels and the multiplier list). A plain u mod T is biased whenever T doesn't divide 2³². The draw rule discards any u at or above limit = (2³² − 1) − ((2³² − 1) mod T) and draws again, so the kept values are a whole number of totals and every outcome lands exactly in proportion to its weight.
limit = 0xFFFFFFFF − (0xFFFFFFFF mod T)
repeat: u = next() until u < limit
result = u mod T → walk the cumulative weights
Base reel 1, T = 545,003 (the largest total):
limit = 4,294,623,640 = 545,003 × 7,880
discarded: 343,656 values, about 8.0 × 10⁻⁵ per draw
Multiplier list, T = 200:
limit = 4,294,967,200 = 200 × 21,474,836
discarded: 96 values, about 2.2 × 10⁻⁸ per draw// §2.4b: keep a draw only if it is below limit = (2^32 - 1) - ((2^32 - 1) mod T); a kept draw maps to u mod T.export function acceptedDraw(value: number, total: number): number | null { assertUint32(value, "value"); if (!Number.isInteger(total) || total < 1 || total > U32_MAX) throw new Error("total must be an integer in [1, 2^32-1]"); const limit = U32_MAX - (U32_MAX % total); return value < limit ? value % total : null;} // One draw below `total` per §2.4b: discard and draw again until a value is kept.function drawBelow(prng: Pcg32, total: number): number { for (;;) { const r = acceptedDraw(prng.nextUint32(), total); if (r !== null) return r; }} // §2.4b "Symbols": T = sum of the weights; the result picks the first index whose running sum exceeds it.export function pickWeighted(prng: Pcg32, weights: number[]): number { if (weights.length === 0) throw new Error("weights must not be empty"); let total = 0; for (const w of weights) { if (!Number.isInteger(w) || w < 0) throw new Error("weights must be non-negative integers"); total += w; } const v = drawBelow(prng, total); let running = 0; for (let i = 0; i < weights.length; i++) { running += weights[i]; if (v < running) return i; } throw new Error("unreachable: draw outside the weight total");}Step 5 measures the rule from src/rng.ts's own acceptedDraw on all 13 totals the draws use: every accepted window is a whole number of totals, worst bias 0. The discard is not just theory here: the capture holds 3 discarded draws, all on base reel 1 (spins 1977498, 1986651 and 1991598), and those 3 spins reproduce only with the discard.
2.4RNG Isolation
Each paid spin uses its own nonce, so its HMAC output is independent of every other spin. Inside a spin, each cascade uses its own tumble index and each free spin its own round index, so every grid comes from its own PCG32 stream. Each seed pair starts with a new server seed. There is no state shared between spins, cascades, seed pairs or players.
The isolation has three layers: per spin (a different nonce gives a different outcome index), per cascade and free spin (a different tumble or round index gives a different tumble seed and a fresh stream) and per seed pair (rotation reveals the old server seed and activates the one committed next). Step 28 replays every cascade from its own stream byte for byte.
2.5Monte Carlo Simulation (30M Rounds)
A 30,000,000-base-spin Monte Carlo run checks that the algorithm produces the published per-reel symbol distribution at scale. src/simulate.ts uses the same Pcg32 class as the verifier, seeded from a pinned master seed, and reads only the published per-reel weights, the paytable and the multiplier weights; no Duel RTP or probability figure goes in. Pass 1 also plays out 132,222 bonus sessions; S2 reports the per-reel χ² and the serial tests, and S4 the RTP cross-check.
| Reel | χ² | df | p-value | Verdict |
|---|---|---|---|---|
| 0 | 8.63 | 10 | 0.5672 | Pass |
| 1 | 7.08 | 10 | 0.7176 | Pass |
| 2 | 5.82 | 10 | 0.8300 | Pass |
| 3 | 9.39 | 10 | 0.4956 | Pass |
| 4 | 10.95 | 10 | 0.3613 | Pass |
| 5 | 4.94 | 10 | 0.8954 | Pass |
| Parameter | Value |
|---|---|
| Base spins (Pass 1) | 30,000,000 |
| Bonus sessions played out | 132,222 |
| Reels × rows | 6 × 5 = 30 cells |
| Symbol classes | 11 (base game) · 12 (bonus game, adds the multiplier) |
| Multiplier values | 14 (2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 25, 50, 100, 250) |
| Master seed | pf-audit-groomers-van-v1 → HMAC-SHA256 → PCG32 seed |
| Bonferroni per-test α | 0.0017 (= 0.01 / 6) |
// Pinned master seed for reproducibility. Same master seed → same PRNG state →// same simulation output. Reviewers running the audit pipeline get bit-for-bit// identical numbers to the published headline.//// The PRNG seed is derived via HMAC-SHA256(masterSeed, "groomers-van-pass1"),// taking the first 4 bytes BE — same HMAC primitive the operator uses for// outcome_index, so no extra crypto dependency.const MASTER_SEED = process.env.GVS_MASTER_SEED ?? 'pf-audit-groomers-van-v1';const PRNG_SEED_HEX = crypto.createHmac('sha256', MASTER_SEED).update('groomers-van-pass1').digest();const PRNG_SEED = PRNG_SEED_HEX.readUInt32BE(0);The Bonferroni-corrected per-test α of 0.0017 comes from a family-wise α of 0.01 across 6 reels (0.01 / 6 ≈ 0.001667). Step 17 recomputes every per-reel p-value from its shipped χ² and degrees of freedom; the symbol counts themselves don't ship, so the χ² values are read as shipped.
2.6Serial Independence
Consecutive payouts should not be correlated: winning or losing on one spin says nothing about the next. Two tests run on 100,000 per-spin payouts from the Pass 1 stream, and the verifier recomputes both thresholds: a lag-1 autocorrelation z-test and a Wald–Wolfowitz runs test. The lag-1 threshold is the Bonferroni critical z of 3.14; the runs p-value must stay above 0.0017.
Lag-1 autocorrelation: ρ = Σ (xᵢ − x̄)(xᵢ₊₁ − x̄) / Σ (xᵢ − x̄)² over the payout stream, standardised as z = ρ · √n under independence.
Wald–Wolfowitz runs test: Counts runs above and below the median and compares them with the count expected under independence.
Bonferroni correction: Per-test α = family α / number of tests: 0.01 / 6 = 0.0017.
export function lag1Autocorrelation(values: number[]): { rho: number; z: number } { const n = values.length; if (n < 3) return { rho: 0, z: 0 }; let sum = 0; for (const v of values) sum += v; const mean = sum / n; let num = 0, den = 0; for (let i = 0; i < n; i++) { const d = values[i] - mean; den += d * d; if (i + 1 < n) num += d * (values[i + 1] - mean); } const rho = den > 0 ? num / den : 0; // Standard error of rho under null: 1/sqrt(n) const z = rho * Math.sqrt(n); return { rho, z };}2.7Worked Example — Full RNG Trace
Real bet from the dataset: spin 1964586 (Phase A, base game, $0.20), traced from the seeds to the 30-cell grid. Cell labels are the symbol indexes in the base-game order Duel publishes at /api/v2/slots:
Symbol index map (base_game):
0 symbol_1 3 symbol_4 6 symbol_7 9 wild
1 symbol_2 4 symbol_5 7 symbol_8 10 bonus
2 symbol_3 5 symbol_6 8 symbol_9| Step | Computation | Result |
|---|---|---|
| Inputs | serverSeed, clientSeed, nonce | 38daabbe…710e67, pf_ww6Oka8nm8byd, 49 |
| 1.a Hex-encode clientSeed | Buffer.from('pf_ww6Oka8nm8byd', 'utf-8').toString('hex') | 70665f7777364f6b61386e6d38627964 |
| 1.b Form HMAC message | hex(clientSeed) + ":" + nonce | 70665f7777364f6b61386e6d38627964:49 |
| 1.c Hex-decode serverSeed | Buffer.from(serverSeed, 'hex') | 32-byte HMAC key |
| 1.d Compute HMAC-SHA256 | crypto.createHmac('sha256', key).update(message).digest() | 32-byte digest |
| 1.e Extract outcome_index | hmac.readUInt32BE(0) | 0x1a638947 = 442,730,823 |
| 2 Derive tumble_seed (round_index=0, tumble_index=0) | deriveTumbleSeed(0x1a638947, 0, 0) | 0x4e0185b3 |
| 3 Seed PCG32 | new Pcg32(0x4e0185b3) — SplitMix64 expansion | 64-bit state |
| 4 Generate 30 cells column-major | For col 0..5 / row 0..4: rejection-sampled against per-reel weights | grid[col][row] = symbol_index |
| Captured grid (round 0) | Reading the view: col 0 = [0,2,4,1,5], col 1 = [3,2,1,7,1], col 2 = [4,6,0,3,1], col 3 = [3,7,1,2,2], col 4 = [8,6,7,4,4], col 5 = [7,6,6,0,4] | 30 cells |
| Reproduction | Our src/rng.ts, written from the specification | All 30 cells match |
outcome_index_hex (1a638947) and all 30 cells reproduce from (server_seed, client_seed, nonce). This is the anchor of the unit tests; Step 5 extends the match to all 6,205 spins and free spins.Technical Evidence & Verification5 sections
2.8Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Outcome index and initial grids (Step 5) | 6,205 / 6,205 spins and free spins, 186,150 cells | Pass |
| Duel's Verify-tab code, second check (Step 5) | 6,205 / 6,205 outcome index and grid; 335 / 335 first-deal multiplier values from the published weights | Pass |
| Cascade streams (Step 28) | 4,323 / 4,323 cascades, 129,690 cells, 146 multiplier values | Pass |
| Draw bias (Step 5) | Exactly 0 on all 13 weight totals | Pass |
| Per-reel χ² (Step 17) | 0 / 6 reels fail at α = 0.0017 (30M spins) | Pass |
| Serial independence (Step 17) | Lag-1 |z| = 0.57 · runs p = 0.9666 | Pass |
| Live symbol frequencies (Step 35, informational) | 6 / 6 reels fit the weights on 5,730 live base spins | Pass |
| Client seed influence (Step 6) | 623 / 623 | Pass |
2.9Code References10 source files
| File | Purpose |
|---|---|
| src/rng.ts | Outcome index, tumble seed, PCG32, the draw rule, grids and multiplier values, written from docs/ALGORITHM.md |
| docs/ALGORITHM.md | The written specification, with each step's source |
| tests/groomers-van/RngSpecTests.ts | The specification's own vectors and properties (166 checks) against src/rng.ts |
| src/operator-verifier.ts | Runs Duel's captured Verify-tab code unmodified, as a second check |
| src/bias.ts | The Step 5 draw-bias bound, measured from acceptedDraw |
| src/simulate.ts | Monte Carlo: 30M base spins and 132,222 bonus sessions on a pinned seed |
| src/stats.ts | χ², lag-1 autocorrelation, runs test, Bonferroni thresholds |
| tests/steps/determinism.ts | Steps 5–6 |
| tests/steps/simulation.ts | Steps 16–18 |
| tests/groomers-van/GroomersVanTests.ts | 20 unit tests, anchored to captured spin 1964586 |
2.10Verified Invariants9 invariants
| Invariant | Result |
|---|---|
computeOutcomeIndex reproduces every outcome index Duel published (623) | Pass |
| The tumble seed changes when the round or tumble index changes (unit tests) | Pass |
| The same seed gives the same PCG32 stream; different seeds give different streams (unit tests) | Pass |
| Every accepted draw window is a whole number of totals on all 13 weight totals | Pass |
| All 30 cells reproduce for the anchor spin 1964586, and a one-byte seed change flips most of them (unit tests) | Pass |
| Every captured cascade cell and multiplier value reproduces from its own stream | Pass |
| Per-reel symbol counts consistent with the published weights (30M spins, α = 0.0017) | Pass |
| Lag-1 |z| below 3.14 and runs p above 0.0017 (100,000 payouts) | Pass |
| Multiplier values drawn with the same rule from the published weights | Pass |
2.11Datasets UsedSource artifacts
2.12Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier (and, optionally, the simulation):
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verifynpm run simulate # optional: re-run the 30M simulation into outputs/run/Expected output, as run at v1.2.1 (lines for this section):
[PASS] Step 5 — Outcome Recomputation
[PASS] Step 6 — Client Seed Influence
[PASS] Step 17 — Simulation Pass 1
[PASS] Step 28 — Cascade RNG Byte-Exact ReplayVerifier Parity
Does the live game actually follow its own rules?
The verifier must produce the exact same grid as the live game, for the first deal and for every cascade after it. Three implementations check the captured spins: ours on all 6,205 entries and 4,323 cascades, Duel's Verify-tab code on all 6,205, and the ProvablyFair.org verifier on all 5,730 base spins.
What we verified
- Every non-buy entry rebuilds its 30-cell grid from the revealed seeds: 6,205 / 6,205 spins and free spins
- Every cascade rebuilds cell for cell from its own stream: 4,323 cascades, 129,690 cells, 146 multiplier values
- Duel's own verify code, run unmodified as a cross-check, agrees on all 6,205
- This site's bet verifier agrees on all 5,730 base spins: outcome index, bonus trigger and payout
- The stake is not an RNG input: 30 / 30 bets from $1 to $50 reproduce
- The server uses the client seed you set: 500 bets on 10 auditor-chosen seeds reproduce
What this means for you
- The verifier isn't a simulation: it rebuilds the exact grids the live game served
- The cascades get the same cell-by-cell check as the first deal
- How much you bet doesn't change the grid you get
- The verifier on this site gives the same result as the audit code on base spins
- Every non-buy entry rebuilds its 30-cell grid from the revealed seeds: 6,205 / 6,205 spins and free spins
- Every cascade rebuilds cell for cell from its own stream: 4,323 cascades, 129,690 cells, 146 multiplier values
- Duel's own verify code, run unmodified as a cross-check, agrees on all 6,205
- This site's bet verifier agrees on all 5,730 base spins: outcome index, bonus trigger and payout
- The stake is not an RNG input: 30 / 30 bets from $1 to $50 reproduce
- The server uses the client seed you set: 500 bets on 10 auditor-chosen seeds reproduce
- The verifier isn't a simulation: it rebuilds the exact grids the live game served
- The cascades get the same cell-by-cell check as the first deal
- How much you bet doesn't change the grid you get
- The verifier on this site gives the same result as the audit code on base spins
Initial-deal recomputationPass
Cascade replayPass
Gravity rulePass
Duel's verify codePass
This site's verifierPass
Bet-size invariancePass
Player client seeds honouredPass
Population bound to the planPass
All 6,205 non-buy entries and all 4,323 cascades recompute exactly from the revealed seeds. Duel's own verify code agrees as a cross-check, and this site's verifier agrees on every base spin. The 20 bonus-buy spins are left out: Duel's help panel says the first spin of a bought bonus is cosmetic, and it isn't generated from the seeds.
| Check | Result | Evidence |
|---|---|---|
| Initial-deal recomputation | Pass | 6,205 / 6,205 non-buy entries reproduce all 30 cells: 5,726 base spins at their recorded nonce, 4 at the nonce declared for a capture retry, 475 free spins at their verify record's nonce and round index (Step 5) |
| Cascade replay | Pass | 4,323 / 4,323 cascades replayed from fresh streams: 129,690 / 129,690 cells and 146 / 146 multiplier values exact (Step 28) |
| Gravity rule | Pass | In all 4,323 cascades the cells left in place sit at the bottom of their column, in the same order (Step 20) |
| Duel's verify code | Pass | Run unmodified as a cross-check on all 6,205 entries: outcome index and initial grid agree on 6,205 / 6,205 (Step 5) |
| This site's verifier | Pass | Our player verifier's code agrees on 5,730 / 5,730 base spins: outcome index, bonus trigger and payout multiple. Free spins and buys aren't compared (Step 5) |
| Bet-size invariance | Pass | 30 / 30 Phase B bets at six stakes from $1 to $50 reproduce at their served nonce; the stake is not an RNG input (Step 9) |
| Player client seeds honoured | Pass | 500 Phase D bets on 10 auditor-chosen client seeds, matching the 10 × 50 plan (Step 15); all 500 reproduce (Step 5) |
| Population bound to the plan | Pass | 6,225 entries in phases A–E match the capture plan written into the code, not the dataset's own header (Step 13) |
Initial-deal recomputationPass
Cascade replayPass
Gravity rulePass
Duel's verify codePass
This site's verifierPass
Bet-size invariancePass
Player client seeds honouredPass
Population bound to the planPass
All 6,205 non-buy entries and all 4,323 cascades recompute exactly from the revealed seeds. Duel's own verify code agrees as a cross-check, and this site's verifier agrees on every base spin. The 20 bonus-buy spins are left out: Duel's help panel says the first spin of a bought bonus is cosmetic, and it isn't generated from the seeds.
How It Works — Verifier Parity9 sections
3.1Why Parity Matters
A verifier is only useful if it gives the same result as the live game. Parity means taking the revealed seeds and rebuilding exactly what the game showed, cell for cell. Groomer's Van has two layers to match: the 30-cell first deal of every spin, and every cascade after it. A game could keep the first deal honest and change the cascades, so both are checked.
3.2Five-Phase Collection Design
The capture ran in five phases on 7–8 May 2026, each aimed at one property. The phase names are the capture script's own.
| Phase | Entries | What was played | Stake | Purpose |
|---|---|---|---|---|
| A — Baseline | 5,248 | 5,000 spins + 248 free spins | $0.20 | The bulk of the RNG and payout checks |
| B — Bracket sampling | 30 | 5 spins at each of 6 stakes | $1, $5, $9.50, $18.50, $27.50, $50 | The stake is not an RNG input (Step 9) |
| C — Buy-bonus | 223 | 20 bonus buys + 203 free spins | $0.20 (a buy costs 125×, $25) | Bonus-buy structure (Steps 24–25); the free spins are recomputed like any other |
| D — Custom client seeds | 524 | 500 spins on 10 auditor-chosen client seeds (50 each) + 24 free spins | $0.20 | The server uses the client seed the player sets (Step 15) |
| E — Edge cases / replay | 200 | 200 spins | $0.20 | More base spins at the standard stake |
src/loader.ts, not against the dataset's own header, so a dataset with bets removed would fail.3.3Initial-Deal Recomputation (Step 5)
For every non-buy entry, the verifier rebuilds the first 30-cell grid from (server seed, client seed, nonce, round index) and compares it cell by cell with the grid Duel served. Each entry is tried at exactly one nonce:
- Base spins: the recorded nonce. 5,726 match there.
- Four capture retries: spins 1965523, 1974625, 1976463 and 1987633 were recorded one nonce too low by our capture script (S1.5). Each must reproduce at the served nonce declared for it in
src/loader.ts, and must not reproduce at the recorded one. All 4 do. - Free spins: the nonce and round index in their verify record, which must be the nonce of the spin that started the bonus and the free-spin number (one less in a bought bonus). 475 / 475 follow that rule and reproduce.
const reproducesAt = ( serverSeed: string, clientSeed: string, n: number, roundIndex: number, weightsPerReel: number[][], symbolCodes: string[], capturedGrid: string[][],): boolean => { if (n < 0) return false; const oi = computeOutcomeIndex(serverSeed, clientSeed, n); const seed = deriveTumbleSeed(oi, roundIndex, 0); const idxGrid = generateGrid(new Pcg32(seed), weightsPerReel); for (let c = 0; c < REELS; c++) { for (let r = 0; r < ROWS; r++) { if (symbolCodes[idxGrid[c][r]] !== capturedGrid[c][r]) return false; } } return true;}; const reproduced = reproducesAt(serverSeed, clientSeed, nonce, roundIndex, tables.weights, tables.codes, captured);if (reproduced && correction) { // The correction must be necessary: the recorded nonce must NOT reproduce this grid. if (reproducesAt(serverSeed, clientSeed, correction.recorded, roundIndex, tables.weights, tables.codes, captured)) { mismatched++; if (fails.length < 3) fails.push(`bet ${b.spinId}: declared nonce correction ${correction.recorded}→${correction.served} is not needed — the recorded nonce reproduces`); } else { okOffByOne++; correctionsProven++; }} else if (reproduced) { if (b.mode === 'free_spin') okFree++; else ok++;}3.4Cascade Replay (Step 28)
Every cascade inside every captured spin is rebuilt from scratch. For cascade n, the cells Duel marked as removed are taken out and the rest fall to the bottom of their column. A fresh PCG32 stream is seeded with deriveTumbleSeed(outcome_index, round_index, n), a full 30-cell grid is drawn from it, and each empty cell takes the fresh grid's cell at the same position. In the bonus game the same stream then draws a value for every multiplier on the fresh grid, and each new multiplier must carry the value Duel served. The result is compared cell by cell with the captured round.
| Reproduction target | Verified count | Verified by |
|---|---|---|
| First-deal cells | 186,150 / 186,150 | Step 5 (S3.3) |
| Cascade cells | 129,690 / 129,690 | Step 28 (this section) |
| All grid cells | 315,840 / 315,840 | Steps 5 + 28 |
| First-deal multiplier values | 335 / 335 | Step 5 |
| New cascade multiplier values | 146 / 146 | Step 28 |
| Multiplier cells with a published value | 935 in the bonus game · 0 in the base game | Step 27 |
const afterGravity: (number | null)[][] = [];for (let col = 0; col < REELS; col++) { const survivors: number[] = []; for (let row = 0; row < ROWS; row++) { if (!removed.has(col * ROWS + row)) survivors.push(prevGrid[col][row]); } const newCount = ROWS - survivors.length; const colArr: (number | null)[] = new Array(ROWS).fill(null); for (let i = 0; i < newCount; i++) colArr[i] = null; for (let i = 0; i < survivors.length; i++) colArr[newCount + i] = survivors[i]; afterGravity.push(colArr);} const tumbleSeed = deriveTumbleSeed(outcomeIndex, roundIndex, n);const cascadePrng = new Pcg32(tumbleSeed);const newGrid = generateGrid(cascadePrng, tables.weights); let newGridMultipliers: { position: number; value: number }[] = [];if (condition === 'bonus_game') { newGridMultipliers = generateMultipliers( newGrid, cascadePrng, tables.multiplierSymbolIndex, ctx.paytable.multiplierValuesList, ctx.paytable.multiplierWeightsList, );}const multByPosition = new Map(newGridMultipliers.map(m => [m.position, m.value])); const replayed: number[][] = afterGravity.map(c => c.slice() as any);for (let col = 0; col < REELS; col++) { for (let row = 0; row < ROWS; row++) { if (replayed[col][row] === null) replayed[col][row] = newGrid[col][row]; }}3.5Tumble Gravity Rule (Step 20)
After the winning cells are removed, the cells left in a column fall to the bottom and new cells enter from the top. Step 20 checks that structure on every cascade: in each column, the cells not marked as removed in the previous round must be the bottom cells of the new round, in the same order, compared by symbol. It doesn't check the new cells at the top; Step 28 does.
let valid = true;for (let col = 0; col < REELS && valid; col++) { // Survivors from prev round: cells NOT marked removed_on_round = tIdx const survivors: string[] = []; for (let row = 0; row < ROWS; row++) { if (prev[col][row].removed_on_round !== tIdx) survivors.push(prev[col][row].symbol); } // Bottom-N of cur should equal survivors (gravity pulls survivors down). const N = survivors.length; for (let i = 0; i < N; i++) { if (cur[col][ROWS - N + i].symbol !== survivors[i]) { valid = false; break; } }}3.6Second Checks: Duel's Code and This Site's Verifier (Step 5)
Two other verifiers are run next to ours. Neither is the source of the result; they only have to agree with it.
Duel's Verify-tab code, captured from duel.com/fairness/verify on 19 May 2026 and pinned by SHA-256, runs unmodified on all 6,205 non-buy entries at the same nonce and round index. Its outcome index must equal ours and its first-deal grid must equal the served one. As captured, the code's list of multiplier values is empty and filled in from outside the code, so it is given the published weights as a 200-entry list (each value repeated by its weight); with that list its multiplier values must equal the served ones. The list Duel's live page supplies isn't in the package and isn't compared.
This site's bet verifier (its derive.js, paytables.js and HMAC library, pinned by SHA-256) runs on all 5,730 base spins. It must return the same outcome index, the served bonus trigger, and the served payout multiple, cascades included, to within one part in 10¹². Free spins and the 20 buys aren't compared by this check.
for (const m of matchedSpins) { const site = sv.deriveGroomersVan({ clientSeed: m.clientSeed, serverSeed: m.serverSeed, nonce: m.nonce }); siteCompared++; const oiOk = site.outcomeIndex === computeOutcomeIndex(m.serverSeed, m.clientSeed, m.nonce); const trigOk = site.triggered === !!m.b.response.feature_triggered; const served = Number(m.b.response.total_multiplier); const got = site.trigger ? site.trigger.payout : NaN; const dev = Math.abs(got - served) / Math.max(Math.abs(served), 1); const payOk = Number.isFinite(served) && Number.isFinite(got) && dev <= SITE_REL_TOL; if (Number.isFinite(dev)) siteWorst = Math.max(siteWorst, dev); if (oiOk) siteOi++; if (trigOk) siteTrig++; if (payOk) sitePay++; if ((!oiOk || !trigOk || !payOk) && siteFails.length < MAX_LISTED) { siteFails.push(`bet ${m.b.spinId}: site oi ${site.outcomeIndex} trig ${site.triggered} x${got} vs served trig ${!!m.b.response.feature_triggered} x${served}`); }}What Duel's code is given:
const op = runOperatorVerifier(opJobs.map(j => j.round), { reelConfigs: { base_game: (ctx.config as any).weights.symbol_distributions_by_condition.base_game, bonus_game: (ctx.config as any).weights.symbol_distributions_by_condition.bonus_game, }, multiplierSymbolIndex: ctx.paytable.multiplierSymbolIndex, multiplierValues: opMultiplierList,});3.7Phase D Auditor Client Seeds (Step 15)
Phase D set 10 auditor-chosen client seeds (pfaudit_groomers_seed00 … 09), 50 spins each, to confirm the server uses whatever seed the player sets. If it swapped in a seed of its own, the grids would not rebuild under the seed we set. Step 15 checks the collection against the plan: 10 distinct seeds and 500 regular bets. The grids themselves are rebuilt in Step 5, Phase D included.
3.8Phase B Stake Bracket Staircase (Step 9)
Phase B placed 30 bets at six stakes ($1, $5, $9.50, $18.50, $27.50 and $50, five each) to confirm the bet amount isn't an input to the RNG. Each bet's first deal is rebuilt at its served nonce; one of them, spin 1987633, is a capture retry and uses its declared nonce. computeOutcomeIndex takes no stake, and neither does anything after it. Six stake levels rather than two would also catch a code path that only switches on at one bracket.
const n = servedNonce(b);let matched = false;if (typeof n === 'number' && n >= 0) { const oi = computeOutcomeIndex(seedPlain, b.activeAtSpin.client_seed, n); const seed = deriveTumbleSeed(oi, 0, 0); const prng = new Pcg32(seed); const idxGrid = generateGrid(prng, cond.weights); let cellsOk = 0; for (let c = 0; c < REELS; c++) for (let r = 0; r < ROWS; r++) if (cond.codes[idxGrid[c][r]] === captured[c][r]) cellsOk++; matched = cellsOk === 30;}3.9Worked Example — Full Parity Verification
A real bet from Phase A: spin 1964425, nonce 2, stake $0.20. The first deal holds 7 symbol_1 cells and a wild, a cluster of 8 that pays 0.4× the stake, $0.08. The 8 winning cells are removed and one cascade follows. It forms no cluster, so the spin settles at $0.08.
serverSeed = 38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67
clientSeed = pf_ww6Oka8nm8byd
nonce = 2
phase = A
stake = $0.20
rounds = 2 (first deal + 1 cascade)
amount_won = $0.08 (cluster of 8 in round 0; no win in the cascade)| Step | Process | Output |
|---|---|---|
| 1 | computeOutcomeIndex(serverSeed, clientSeed, 2) | outcome_index = 0xd6f866a8 |
| 2 | deriveTumbleSeed(0xd6f866a8, 0, 0) | tumble_seed (round 0) = 0x2e64c112 |
| 3 | generateGrid(new Pcg32(0x2e64c112), base-game weights) | 30-cell grid, equal to the served round 0 |
| 4 | Cluster: 7 symbol_1 + 1 wild = 8 | Pays 0.4 × $0.20 = $0.08 |
| 5 | deriveTumbleSeed(0xd6f866a8, 0, 1) | tumble_seed (round 1) = 0x65b74d9c |
| 6 | generateGrid(new Pcg32(0x65b74d9c), base-game weights) | Fresh grid for the cascade |
| 7 | Remove the 8 winning cells, let the rest fall, fill the empty top cells from the fresh grid | Round 1 grid, equal to the served round 1 |
| 8 | No cluster in round 1 | amount_won = $0.08, equal to the served amount |
// spin 1964425 · Phase A · $0.20 · base game · computed with src/rng.tscomputeOutcomeIndex(serverSeed, "pf_ww6Oka8nm8byd", 2) → 0xd6f866a8deriveTumbleSeed(0xd6f866a8, 0, 0) → 0x2e64c112 // first dealgenerateGrid(new Pcg32(0x2e64c112), base-game weights) → 30 cells, equal to the served round 0 reel 0: symbol_3 symbol_4 symbol_7 symbol_6 symbol_1 reel 1: symbol_1 symbol_1 symbol_3 symbol_1 symbol_4 reel 2: symbol_7 symbol_2 symbol_2 wild symbol_7 reel 3: symbol_2 symbol_6 symbol_1 symbol_2 symbol_1 reel 4: symbol_4 symbol_6 symbol_3 symbol_3 symbol_1 reel 5: symbol_3 symbol_4 symbol_4 symbol_5 symbol_7cluster: 7 × symbol_1 + 1 wild = 8 → 0.4× × $0.20 = $0.08the 8 winning cells (the 7 symbol_1 and the wild) are removed; the rest fallderiveTumbleSeed(0xd6f866a8, 0, 1) → 0x65b74d9c // cascade 1generateGrid(new Pcg32(0x65b74d9c), base-game weights) → fresh grid; its cells fill the 8 empty top cellsround 1 grid → equal to the served round 1; no clusteramount_won → $0.08, equal to the served amountTechnical Evidence & Verification5 sections
3.10Evidence Coverage Summary9 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Initial-deal recomputation (Step 5) | 6,205 / 6,205 entries · 186,150 cells | Pass |
| Free-spin inputs (Step 5) | 475 / 475 free spins carry the trigger's nonce and the session's round index | Pass |
| Cascade replay (Step 28) | 4,323 / 4,323 cascades · 129,690 cells · 146 multiplier values | Pass |
| Gravity rule (Step 20) | 4,323 / 4,323 cascades · 0 violations | Pass |
| Duel's verify code, cross-check (Step 5) | 6,205 / 6,205 outcome index and grid · 335 / 335 multiplier values | Pass |
| This site's verifier (Step 5) | 5,730 / 5,730 base spins: outcome index, trigger, payout multiple | Pass |
| Bet-size invariance (Step 9) | 30 / 30 Phase B bets, 6 stakes from $1 to $50 | Pass |
| Auditor client seeds (Step 15) | 500 bets on 10 seeds, as planned | Pass |
| Population and phases (Step 13) | 6,225 entries, phases A–E as planned | Pass |
3.11Code References9 source files
| File | Purpose |
|---|---|
| tests/verify.ts | 35 scored steps (Steps 5, 9, 13, 15, 20 and 28 cover S3) and the reproduction gate |
| tests/steps/determinism.ts | Step 5: grid recomputation, free-spin inputs, the draw-bias bound, this site's verifier and Duel's verify code |
| tests/steps/payouts.ts | Step 9: bet-size invariance |
| tests/steps/dataset.ts | Steps 12–15: epochs, population, dataset hash, Phase D seeds |
| tests/steps/game-specific.ts | Step 20 (gravity rule) and Step 28 (cascade replay) |
| src/rng.ts | computeOutcomeIndex, deriveTumbleSeed, Pcg32, generateGrid, generateMultipliers, written from docs/ALGORITHM.md |
| src/operator-verifier.ts | Runs Duel's captured Verify-tab code unmodified, pinned by SHA-256 |
| src/site-verifier.ts | Loads this site's verifier code, pinned by SHA-256 |
| src/loader.ts | The capture plan, the scored populations and the four nonce corrections |
3.12Datasets UsedSource artifacts
| Phase | Purpose | Entries | Tests |
|---|---|---|---|
| A | Baseline | 5,248: 5,000 spins at $0.20 + 248 free spins | Steps 5, 28 and the payout checks |
| B | Bracket sampling | 30 across 6 stakes ($1–$50) | Step 9: bet-size invariance |
| C | Buy-bonus | 223: 20 buys + 203 free spins | Steps 24–25: bonus-buy structure |
| D | Custom client seeds | 524: 500 spins on 10 seeds + 24 free spins | Step 15: auditor seeds honoured |
| E | Edge cases / replay | 200 spins at $0.20 | Steps 5, 28 and the payout checks |
3.13Verified Invariants10 invariants
| Invariant | Result |
|---|---|
Every non-buy entry's first-deal grid equals generateGrid(new Pcg32(deriveTumbleSeed(outcome_index, round_index, 0))), cell for cell, at exactly one nonce | Pass |
| Each declared nonce correction is needed: the grid reproduces at the served nonce and not at the recorded one | Pass |
| Every free spin's verify record carries the trigger's served nonce and the session's round index | Pass |
| Every cascade equals the previous round with the marked cells removed, the rest fallen, and the gaps filled from a fresh stream seeded with the cascade number | Pass |
| Every new cascade multiplier carries the value drawn from the same stream with the published weights | Pass |
| Cells left in place sit at the bottom of their column, in order | Pass |
| Duel's Verify-tab code, unmodified, gives the same outcome index and first-deal grid on every non-buy entry | Pass |
| This site's verifier gives the same outcome index, trigger and payout multiple on every base spin | Pass |
| The stake doesn't change the grid for the same (server seed, client seed, nonce), across 6 stakes from $1 to $50 | Pass |
| The server uses every auditor-supplied client seed: 500 Phase D bets on 10 seeds | Pass |
3.14Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier:
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 5 — Outcome Recomputation
[PASS] Step 9 — Bet-Size Invariance
[PASS] Step 13 — Population & Phase Labels
[PASS] Step 15 — Phase D Client Seed Variation
[PASS] Step 20 — Tumble Cascade Structural Integrity
[PASS] Step 28 — Cascade RNG Byte-Exact ReplayRTP & Payout Logic
Is the house edge what the casino claims?
The enumerated RTP is 99.9720% with no edge applied, as on every captured bet: all 2³² spin outcomes are evaluated, and the bonus is resolved by exact convolution, from the published weights and paytable alone. Duel's game settings state 100%, and the RTP claim rule finds the figure 0.028 pp below it, inside the ±0.1 pp band: PASS. Payouts are exact on every captured spin. Without Zero Edge the edge scales with stake; that is explained from the config, not certified.
What we verified
- Enumerated RTP is 99.9720% with no edge applied, as on every captured bet: all 2³² spin outcomes, and the bonus by exact convolution
- Derived from first principles: the published reel weights, paytable and multiplier weights, with no casino RTP figure
- RTP claim rule: Duel's game settings state 100%; the figure is 0.028 pp below it, inside ±0.1 pp — PASS
- 30M simulated spins give 100.06%, consistent with it; a wrong trigger rule would be rejected
- Every payout is exact to the cent, and every payline multiplier equals the published paytable
- Pass 2 finds no sign of server-seed cherry-picking (aggregate z = +0.91; 4 / 115 seeds flagged, p = 0.83)
What this means for you
- With no edge applied the house keeps about 0.03% over the long run
- Without Zero Edge, Duel's config adds an edge by stake: 0.01% at $0.20, up to 1.15% on spins and 1.82% on bonus play at the $1,000 maximum. Explained from the config, not certified
- The RTP figure is derived independently, not taken from the casino
- Duel's 100% claim holds within the ±0.1 pp band
- The bonus buy is not certified: its first spin is canned
- Enumerated RTP is 99.9720% with no edge applied, as on every captured bet: all 2³² spin outcomes, and the bonus by exact convolution
- Derived from first principles: the published reel weights, paytable and multiplier weights, with no casino RTP figure
- RTP claim rule: Duel's game settings state 100%; the figure is 0.028 pp below it, inside ±0.1 pp — PASS
- 30M simulated spins give 100.06%, consistent with it; a wrong trigger rule would be rejected
- Every payout is exact to the cent, and every payline multiplier equals the published paytable
- Pass 2 finds no sign of server-seed cherry-picking (aggregate z = +0.91; 4 / 115 seeds flagged, p = 0.83)
- With no edge applied the house keeps about 0.03% over the long run
- Without Zero Edge, Duel's config adds an edge by stake: 0.01% at $0.20, up to 1.15% on spins and 1.82% on bonus play at the $1,000 maximum. Explained from the config, not certified
- The RTP figure is derived independently, not taken from the casino
- Duel's 100% claim holds within the ±0.1 pp band
- The bonus buy is not certified: its first spin is canned
Anti-circularityPass
Enumerated RTPPass
RTP claim (RTP-CLAIM 1.2.0)Pass
"rtp": "100.0000", config v1.4). Scored on Step 32: 0.028 pp below, inside the ±0.1 pp band. A miss would read RTP FIGURE OVERSTATED (exit 5)No edge appliedPass
edge_multiplier 1 (Zero Edge) on all 6,225 captured bets, at 7 stakes from $0.20 to $50 (Step 10)Payout exactnessPass
Game rulesPass
Simulation (Pass 1)Pass
Cherry-pick test (Pass 2)Pass
Max-win capPass
Bonus buyInfo
Stake tiersInfo
The enumerated RTP is 99.9720% with no edge applied, derived from the published weights and paytable alone. Duel's stated 100% holds under the RTP claim rule, 0.028 pp below it and inside the band. Payouts are exact on every captured spin, and the simulation and cherry-pick test find no sign of bias. The scaling edge without Zero Edge is explained from the config, not certified, and the bonus buy is not certified.
Base play plus naturally triggered bonuses, with no edge applied. The bonus buy is not certified: its first spin is canned.
| Check | Result | Evidence |
|---|---|---|
| Anti-circularity | Pass | RTP derived from the published reel weights, paytable and multiplier weights alone; the 30M simulation is scored against it, not against the 100% claim, and 2 / 2 wrong trigger rules are rejected (Steps 16, 29–32) |
| Enumerated RTP | Pass | 99.9720% with no edge applied: base 0.561376× over all 2³² outcomes, plus a 1 in 227.1 trigger × 99.5286× session EV by exact convolution (Step 32) |
| RTP claim (RTP-CLAIM 1.2.0) | Pass | Claim: 100% flat, from Duel's game settings ("rtp": "100.0000", config v1.4). Scored on Step 32: 0.028 pp below, inside the ±0.1 pp band. A miss would read RTP FIGURE OVERSTATED (exit 5) |
| No edge applied | Pass | edge_multiplier 1 (Zero Edge) on all 6,225 captured bets, at 7 stakes from $0.20 to $50 (Step 10) |
| Payout exactness | Pass | 6,205 / 6,205 non-buy entries reconcile to the cent; 4,985 / 4,985 payline multipliers equal the published paytable; 475 / 475 free spins (Steps 7, 8, 26) |
| Game rules | Pass | Clusters pay anywhere (4,982 / 4,982), wilds count for every cluster (410 / 410 rounds), triggers 53 / 53, retrigger cap held, multipliers bonus-only (Steps 19, 21–23, 27) |
| Simulation (Pass 1) | Pass | 30M base spins and 132,222 bonus sessions: 100.06%, each component within 5 standard errors of the exact figure (Steps 16, 17) |
| Cherry-pick test (Pass 2) | Pass | Captured RTP over 5,730 base spins z = +0.91; 115 seeds × 10,000 nonces, 4 flagged, binomial p = 0.83 (Step 18) |
| Max-win cap | Pass | All 6,225 entries and 53 sessions within 5,000×; the largest served win was 630× (647.1× per session), so the cap was never reached (Step 34) |
| Bonus buy | Info | 20 / 20 buys show 4 scatters and award 10 free spins (Steps 24, 25). The buy spin is canned, so the buy is not in the RTP table |
| Stake tiers | Info | Without Zero Edge, Duel's config adds 0.01% at $0.20, up to 1.15% on spins and 1.82% on bonus play at the $1,000 maximum stake. Explained from the config, not certified |
Anti-circularityPass
Enumerated RTPPass
RTP claim (RTP-CLAIM 1.2.0)Pass
"rtp": "100.0000", config v1.4). Scored on Step 32: 0.028 pp below, inside the ±0.1 pp band. A miss would read RTP FIGURE OVERSTATED (exit 5)No edge appliedPass
edge_multiplier 1 (Zero Edge) on all 6,225 captured bets, at 7 stakes from $0.20 to $50 (Step 10)Payout exactnessPass
Game rulesPass
Simulation (Pass 1)Pass
Cherry-pick test (Pass 2)Pass
Max-win capPass
Bonus buyInfo
Stake tiersInfo
The enumerated RTP is 99.9720% with no edge applied, derived from the published weights and paytable alone. Duel's stated 100% holds under the RTP claim rule, 0.028 pp below it and inside the band. Payouts are exact on every captured spin, and the simulation and cherry-pick test find no sign of bias. The scaling edge without Zero Edge is explained from the config, not certified, and the bonus buy is not certified.
How It Works — RTP & Payout Logic18 sections
4.1Anti-Circularity Proof (Steps 16, 29–32)
The game RTP is derived from primitive inputs alone: the per-reel symbol weights, the paytable, the multiplier-value weights, the cascade rules and the 5,000× cap. No RTP figure, trigger probability or session estimate from Duel enters the calculation. Change a weight and the derived RTP changes.
The per-spin return is found by exhaustive enumeration: every one of the 2³² = 4,294,967,296 outcome indexes is run through the cascade rules (S4.2). The bonus session is then resolved by exact convolution over that distribution (S4.3). A 30M-spin simulation is the cross-check (S4.6), and Step 16 scores it against the exact figure, not against Duel's 100%.
| Component | Source | Role |
|---|---|---|
| Per-reel symbol weights | weights.symbols_by_condition (config v1.4) | Every cell's weighted draw, base game and bonus game |
| Paytable | /rules response (paytable-from-rules-endpoint.json) | Cluster pay by symbol and size; scatter pay |
| Multiplier-value weights | multiplier_values (14 values, weights summing to 200) | The value drawn for each multiplier in the bonus |
return [ { name: 'baseRTP', mc: p1.baseRTP, ex: exact.baseRTP, se: se.base, buf: buffer.base }, { name: 'triggerProbability', mc: p1.triggerProbability, ex: exact.pTrig, se: se.trigger, buf: buffer.trigger }, { name: 'sessionPayout', mc: p1.averageBonusSessionPayout, ex: exact.eSessionTriggered, se: se.session, buf: buffer.session }, { name: 'blendedRTP', mc: p1.blendedRTP, ex: exact.totalRtp, se: se.blended, buf: buffer.blended },].map(r => { const dev = Math.abs(r.mc - r.ex); const bound = K_SIGMA * r.se + r.buf; return { ...r, deviation: dev, zScore: dev / r.se, bound, within: dev <= bound };}); export const NEGATIVE_CONTROLS: ReadonlyArray<{ name: string; rules: TriggerRules; required: boolean }> = Object.freeze([ { name: 'trigger threshold 3 → 4 scatters', required: true, rules: { minScatters: 4, spinsByScatters: { ...PUBLISHED_TRIGGER_RULES.spinsByScatters } } }, { name: 'spins-per-scatter table shifted one tier up (3→10, 4→12, 5→14, 6+→14)', required: true, rules: { minScatters: 3, spinsByScatters: { 3: 10, 4: 12, 5: 14, 6: 14 } } }, { name: 'spins-per-scatter table shifted one tier down for 4+ scatters (3→8, 4→8, 5→10, 6+→12) — power probe', required: false, rules: { minScatters: 3, spinsByScatters: { 3: 8, 4: 8, 5: 10, 6: 12 } } },]);Why this is non-circular: the only Duel inputs are the published weights and tables, which every grid in S3 reproduces from. The 30M-spin per-reel χ² (S2.5) and the live symbol counts (S4.16) are both consistent with the weights. Duel's RTP, trigger rate and session figures are outputs of the enumeration, never inputs.
Power: a free-spin table shifted one tier down for 4+ scatters would reach z = 4.35, under the 5σ bound, because those triggers are a small share of all triggers. The headline figure comes from the exact enumeration, which the simulation corroborates.
4.2Per-Spin RTP via 2³² Enumeration (Steps 29–30)
Every spin of Groomer's Van is fixed by one 32-bit outcome_index, so there are exactly 2³² = 4,294,967,296 possible spins per mode. The audit evaluates all of them: each index is run through the deal, the clusters, the cascades and the scatter pay, and its payout recorded. The sum over all indexes divided by 2³² is the per-spin RTP, with no sampling and no confidence interval.
Two enumerators produce it: src/enumerate-mt.ts on the CPU and a CUDA kernel. They agree to 6 decimal places of RTP (they differ by 2.9 × 10⁻⁷ on the base and 4.6 × 10⁻⁷ on the bonus, from floating-point summation order), and the headline is published to 4.
| Mode | Outcomes enumerated | Win rate | Max payout | Per-spin RTP |
|---|---|---|---|---|
| Base game | 4,294,967,296 (2³²) | 45.58% | 112.8× | 0.561376× |
| Bonus game (one free spin) | 4,294,967,296 (2³²) | 73.24% | 5,000× (8,232.8× without the cap) | 12.153351× |
function spinPayout(outcomeIndex: number, paytable: Paytable, condition: Condition, tables: SymbolTables): { payout: number; scatters: number } { const roundIndex = 0; let totalBaseMult = 0; let cumulativeBombs = 0; let tumbleIndex = 0; let tumbleSeed = deriveTumbleSeed(outcomeIndex, roundIndex, tumbleIndex); let cascadePrng = new Pcg32(tumbleSeed); let idxGrid = generateGrid(cascadePrng, tables.weights); let codeGrid: string[][] = idxGrid.map(col => col.map(i => tables.codes[i])); let cumulativeScatters = countScatters(codeGrid); if (condition === 'bonus_game') { const initialMultipliers = generateMultipliers( idxGrid, cascadePrng, tables.multiplierSymbolIndex, tables.multiplierValues, tables.multiplierWeights, ); for (const m of initialMultipliers) cumulativeBombs += m.value; } for (let cascade = 0; cascade < 30; cascade++) { const clusters = findClusters(codeGrid); const removedSet = new Set<number>(); for (const c of clusters) { if (c.size < paytable.minClusterSize) continue; const baseMult = clusterMultiplier(paytable, condition, c.symbol, c.size); if (baseMult <= 0) continue; totalBaseMult += baseMult; for (const p of c.positions) removedSet.add(p); } if (removedSet.size === 0) break; tumbleIndex += 1; tumbleSeed = deriveTumbleSeed(outcomeIndex, roundIndex, tumbleIndex); cascadePrng = new Pcg32(tumbleSeed); const newGrid = generateGrid(cascadePrng, tables.weights); const newMs = condition === 'bonus_game' ? generateMultipliers(newGrid, cascadePrng, tables.multiplierSymbolIndex, tables.multiplierValues, tables.multiplierWeights) : []; const nextIdxGrid: number[][] = []; const nextCodeGrid: string[][] = []; const filledNewPositions = new Set<number>(); for (let col = 0; col < REELS; col++) { const survivors: number[] = []; for (let row = 0; row < ROWS; row++) { const pos = col * ROWS + row; if (!removedSet.has(pos)) survivors.push(idxGrid[col][row]); } const empty = ROWS - survivors.length; const colNext: number[] = []; for (let row = 0; row < empty; row++) { colNext.push(newGrid[col][row]); filledNewPositions.add(col * ROWS + row); } colNext.push(...survivors); nextIdxGrid.push(colNext); nextCodeGrid.push(colNext.map(i => tables.codes[i])); } // Only multipliers landing on top-filled positions contribute bombs (matches simulate.ts) for (const m of newMs) { if (filledNewPositions.has(m.position)) cumulativeBombs += m.value; } idxGrid = nextIdxGrid; codeGrid = nextCodeGrid; cumulativeScatters = countScatters(codeGrid); } let scatterPay = 0; if (condition === 'base_game' && cumulativeScatters >= 3) { scatterPay = scatterMultiplier(paytable, condition, cumulativeScatters); } const bombMult = condition === 'bonus_game' ? Math.max(cumulativeBombs, 1) : 1; let payout = totalBaseMult * bombMult + scatterPay; if (payout > MAX_WIN_X) payout = MAX_WIN_X; return { payout, scatters: cumulativeScatters };}Why enumeration, not simulation, for the headline: a simulated RTP has a confidence interval that narrows only as √N. With every outcome evaluated, the per-spin RTP is the exact population mean. The 30M-spin simulation (S4.6) is kept as an independent cross-check, not as the source of the figure.
4.3Bonus Session EV via Exact Convolution (Step 31)
A bonus session runs several free spins, each of which can pay and can retrigger more spins, up to 3 retriggers and a 5,000× session cap. Its expected value is computed by exact convolution over the enumerated free-spin distribution, not by sampling. The state is a set of lanes keyed by (retriggers used, spins left). Each step convolves a lane's running total with the free-spin payout distribution, split by scatter count so that retriggers are handled exactly; mass past 5,000× goes to the cap. It runs once for each starting count: 8, 10, 12 and 14 spins.
The game RTP is then: base RTP + P(trigger) × E[session | trigger], with the session values weighted by how often 3, 4, 5 and 6+ scatters start the bonus.
| Triggering scatters | Free spins | Exact session EV |
|---|---|---|
| 3 | 8 | 97.5997× |
| 4 | 10 | 121.9996× |
| 5 | 12 | 146.3995× |
| 6+ | 14 | 170.7994× |
| Component | Value | Source |
|---|---|---|
| Base-game per-spin RTP | 0.561376× | S4.2 enumeration |
| P(bonus trigger) | 0.4404% (1 in 227.1) | Scatter counts of the base enumeration |
| E[session | triggered] | 99.5286× | Scatter-weighted exact convolution |
| Bonus contribution per base spin | 0.438344× | P(trigger) × E[session | triggered] |
| Enumerated RTP | 99.9720% | Base + bonus contribution |
function convInto( src: Float64Array, cellsPb: Int32Array, cellsProb: Float64Array, tgt: Float64Array, cap: Float64Array,): void { const N = cellsPb.length; for (let b = 0; b < L; b++) { const sp = src[b]; if (sp === 0) continue; for (let i = 0; i < N; i++) { const newB = b + cellsPb[i]; const m = sp * cellsProb[i]; if (newB >= TOTAL_CAP_COARSE) cap[TOTAL_CAP_COARSE] += m; else tgt[newB] += m; } }} if (r < MAX_RETRIGGERS) { // Cat 0 (scatter < 3, no retrigger) → target (r, s-1) const t0Lane = ensureLane(next, r, s - 1); convInto(src, catPb[0], catProb[0], t0Lane, finalDist); // Cat 1-4 (scatter ≥ 3, retrigger) → target (r+1, s-1+extra) for (let cat = 1; cat <= 4; cat++) { const newR = r + 1; const newS = s - 1 + CAT_EXTRA[cat]; if (newS >= MAX_S) throw new Error(`unexpected newS=${newS} (r=${r}, s=${s}, cat=${cat})`); const tLane = ensureLane(next, newR, newS); convInto(src, catPb[cat], catProb[cat], tLane, finalDist); }} else { // r == MAX_RETRIGGERS — no retrigger possible, merge cats → (r, s-1) const tLane = ensureLane(next, r, s - 1); convInto(src, allPb, allProb, tLane, finalDist);}Headline derivation (Step 32):
// P(scatter ≥ 3 in base spin) → from base scatter_histogramconst sh = base.scatter_histogram;const totalBase = base.range.count;const p3 = sh[3] / totalBase;const p4 = sh[4] / totalBase;const p5 = sh[5] / totalBase;const p6plus = sh.slice(6).reduce((a, b) => a + b, 0) / totalBase;const pTrig = p3 + p4 + p5 + p6plus; // E[session | triggered] = scatter-weighted mean of the EXACT per-spin-count session EVs.const eSessionTriggered = (p3 * evN(INITIAL_SPINS_BY_SCATTERS[3]) + p4 * evN(INITIAL_SPINS_BY_SCATTERS[4]) + p5 * evN(INITIAL_SPINS_BY_SCATTERS[5]) + p6plus * evN(INITIAL_SPINS_BY_SCATTERS[6])) / pTrig; const totalRtp = base.rtp + pTrig * eSessionTriggered;Model and game. The enumeration treats every free spin as an independent draw. In the game, all the free spins of a bonus derive from the trigger spin's outcome index, so a whole session is fixed by one 32-bit value. Averaged over all 2³² indexes, the game's return equals the model's up to the spread of about 19 million triggering indexes, estimated at ±0.02 pp (one standard deviation). The game's own average over the 2³² indexes has not been enumerated.
The cap is not where the gap comes from. With the per-spin cap removed, the bonus RTP per spin rises from 12.153351× to 12.153376×. That lifts the whole game by at most 0.0005 pp, so the headline would still be at most 99.9725%: the 0.028 pp gap to 100% is the paytable itself. What the session-level 5,000× cap removes is not enumerated; a session reaches it with a probability of about 4–8 in 10 million.
4.4RTP Claim Rule (RTP-CLAIM 1.2.0)
Framework 1.1 holds the audited RTP to the figure the casino publishes. The rule looks for the claim in six places: the game page, fairness page, help page, bet panel, rules or game settings. For Groomer's Van, Duel's game settings state "rtp": "100.0000" (config v1.4): a flat 100% claim. The game page also shows "Zero Edge" and "House Edge 0%" labels.
The claim is scored on Step 32 against a ±0.1 pp band. A figure more than 0.1 pp below the claim, on the house side, makes the verdict RTP FIGURE OVERSTATED (exit 5). It never makes it NOT PROVABLY FAIR, because the draws themselves pass. The table has one setting, a paid spin with the bonus it triggers; the stake doesn't change the reels. The bonus buy is left out because its first spin is canned (S4.12).
| Item | Value |
|---|---|
| Claim | 100%, flat |
| Published in | Game settings: "rtp": "100.0000" in Duel's Groomer's Van config v1.4 (data/raw/groomers-van-config-v1.4.json) |
| Scored on | Step 32 (headline RTP derivation) |
| Band | ±0.1 pp |
| Settings tabled | 1 (a paid spin: base game and triggered bonus) |
| House side beyond band | 0 |
| Player-favourable beyond band | 0 |
| Outcome | PASS — minimal fix: none |
| Setting | Audited RTP | Claim | Gap | Result |
|---|---|---|---|---|
| Paid spin (base game + triggered bonus), no edge applied | 99.972000% | 100% | −0.028000 pp, within band | Pass |
rtp-claim: ENFORCED — PASSrtp-claim: claim flat 100.000000% — source: game settings: "rtp": "100.0000" in Duel's Groomer's Van game config v1.4 (data/raw/groomers-van-config-v1.4.json:9; declaration gameModel.edge.claimed 0)rtp-claim: band ±0.10 pp · 1 settings · true min 99.972000% (paid spin (base game + triggered bonus)) · true max 99.972000% (paid spin (base game + triggered bonus))rtp-claim: house side beyond band: 0 · player-favourable beyond band: 0 · worst paid spin (base game + triggered bonus) at -0.028000 pprtp-claim: outcome PASS · minimal fix: none — the claim holds for every setting it states a figure forrtp-claim: committed table outputs/rtp-claim-table.json: equals this run; sha256 58de71cb6dc34e2e… matches the pinThe claim, as the package declares it:
export const RTP_CLAIM: RtpClaim = { kind: 'flat', rtp: '1', source: 'game settings: "rtp": "100.0000" in Duel\'s Groomer\'s Van game config v1.4 (data/raw/groomers-van-config-v1.4.json:9; declaration gameModel.edge.claimed 0)',};4.5House Edge & Stake Tiers (Step 10)
Every captured bet ran with no edge applied: all 6,225 returned edge_multiplier 1, Duel's Zero Edge, at seven stakes from $0.20 to $50 and on $0.20 buys (Step 10). That is the tier this audit certifies, and 99.9720% is its return. Zero Edge is a Duel account setting; a player can see it in the edge_multiplier field of a bet response.
Without Zero Edge, Duel's config v1.4 prices the game in brackets (scaling_edge), each 0.01% above the last. Spins use 116 brackets by stake: 0.01% for stakes up to $9.07, rising to 1.15% at the $1,000 maximum. Bonus play, bought or triggered, uses a separate schedule of 184 brackets whose range is 125× the spin schedule's: 0.01% for a $25 buy, 1.82% for a $125,000 one. Both schedules are contiguous and gap-free (Step 11). No captured bet had an edge applied, so the figures below are explained from the config, not tested.
| Bet | Spin bracket | Spin edge | Buy cost (125×) | Bonus bracket | Bonus edge |
|---|---|---|---|---|---|
| $0.20 | 1 | 0.01% | $25 | 1 | 0.01% |
| $10 | 2 | 0.02% | $1,250 | 2 | 0.02% |
| $50 | 6 | 0.06% | $6,250 | 9 | 0.09% |
| $100 | 12 | 0.12% | $12,500 | 18 | 0.18% |
| $500 | 57 | 0.57% | $62,500 | 90 | 0.90% |
| $1,000 | 115 | 1.15% | $125,000 | 182 | 1.82% |
| Spin | RTP without Zero Edge (analytical) |
|---|---|
| $0.20 | 99.962% |
| $10 | 99.95–99.96% |
| $100 | 99.83–99.90% |
| $1,000 | 98.5–99.3% |
edge_multiplier 1. The certified figure is 99.9720% with no edge applied; the scaling edge is disclosed from the config.4.6Simulation Pass 1 — 30M Spins (Steps 16, 17)
S4.2–4.3 compute the RTP exactly. The simulation checks the same pipeline end to end: 30 million base spins on a pinned seed (pf-audit-groomers-van-v1), each trigger playing out its own bonus session, 132,222 sessions in all. It uses the same Pcg32 class as the verifier and reads only the published weights and tables.
| Component | Simulated | Exact | z |
|---|---|---|---|
| Base RTP per spin | 0.561324× | 0.561376× | 0.29 |
| Trigger probability | 0.44074% | 0.44042% | 0.26 |
| Session payout | 99.66× | 99.53× | 0.30 |
| Blended RTP | 100.06% | 99.9720% | 0.34 |
const r = spinPayout(paytable, 'base_game', baseTables, prng1);baseTotalPayout += r.payout;blockSum += r.payout;if (r.scatters >= paytable.minScattersToTrigger) { baseTriggered++; triggerScatterDist[r.scatters] = (triggerScatterDist[r.scatters] ?? 0) + 1; const initialFS = freeSpinsAwarded(paytable, r.scatters, false); const sessionPayoutVal = sessionPayout(paytable, bonusTables, prng1, initialFS); bonusTotalPayout += sessionPayoutVal; bonusSessionsRun++;} const baseRTP = baseTotalPayout / PASS1_BASE_SPINS;const triggerProb = baseTriggered / PASS1_BASE_SPINS;const avgSessionPayout = bonusSessionsRun > 0 ? bonusTotalPayout / bonusSessionsRun : 0;const blendedRTP = (baseTotalPayout + bonusTotalPayout) / PASS1_BASE_SPINS;The simulated figure sits 0.09 pp above the exact one, z = 0.34: sampling noise from rare large sessions. Every per-reel χ² value and the serial-test figures are in S2.
4.7Cherry-Pick Test — Pass 2 (Step 18)
Could Duel have chosen server seeds that start badly for players? Pass 2 checks two ways. (a) Aggregate: the captured base-game return across 5,730 spins in 115 epochs is compared with the Pass 1 reference; a cherry-picking casino would pull it down. (b) Forward replay: every one of the 115 revealed seeds is replayed for 10,000 nonces. A seed is flagged if its first 50 nonces, the window a player would actually play, depart from the exact win rate (45.58%) at p < 0.05 while the rest don't.
| Test | Result |
|---|---|
| Captured base-game RTP (5,730 spins, 115 epochs) | 56.87% vs the Pass 1 reference 55.71% |
| Aggregate z (must be within ±3) | +0.91 |
| Seeds replayed | 115 × 10,000 nonces |
| Expected win rate | 45.58%, exact, from the 2³² enumeration |
| Early window vs the rest | Nonces 0–49 vs 50–9,999 |
| Seeds flagged | 4 / 115, against about 6 expected by chance |
| Binomial p (must be ≥ 0.01) | 0.83 |
| Seeds above the Pass 1 95th percentile (informational) | 5 / 115 |
const z = (capturedRTP - p2.pass1ReferenceMean) / (p2.pass1PerSpinStd / Math.sqrt(nSpins));if (!numbersAgree(p2.aggregateZScore, z)) issues.push(`simulator's aggregateZScore ≠ recomputed`);const aggOk = Math.abs(z) < 3;if (!aggOk) issues.push(`aggregate |z| ${Math.abs(z).toFixed(3)} ≥ 3`); let flags = 0, rowIssues = 0;for (const r of rows) { const pe = chiSquaredPValue(r.early_chi2, 1), pl = chiSquaredPValue(r.late_chi2, 1); if (!numbersAgree(pe, r.early_p) || !numbersAgree(pl, r.late_p)) rowIssues++; const flag = pe < 0.05 && pl >= 0.05; if (flag !== r.cherry_pick_flag) rowIssues++; if (flag) flags++;}4.8Cluster Pays Anywhere + Wild Substitution (Step 19)
Clusters in Groomer's Van are counted, not connected: a symbol pays when 8 or more of it appear anywhere on the grid, wilds counting toward it, at the tier min(count, 12). Wilds substitute for every paying symbol but not for scatters or multipliers, so one wild can lift several clusters at once (S4.9). Step 19 checks every captured cluster payline: its count must equal the cells of its symbol plus the wilds on that grid. A connected-group rule would give different counts.
export function findClusters(grid: string[][]): Cluster[] { if (grid.length !== REELS) throw new Error(`grid must have ${REELS} columns`); for (const col of grid) if (col.length !== ROWS) throw new Error(`each column must have ${ROWS} rows`); const wildPositions: number[] = []; const symbolPositions = new Map<string, number[]>(); for (let c = 0; c < REELS; c++) { for (let r = 0; r < ROWS; r++) { const sym = grid[c][r]; const pos = c * ROWS + r; if (sym === WILD_CODE) { wildPositions.push(pos); } else if (!NON_PAYABLE.has(sym)) { const list = symbolPositions.get(sym) ?? []; list.push(pos); symbolPositions.set(sym, list); } } } const clusters: Cluster[] = []; for (const [sym, positions] of symbolPositions) { const all = positions.concat(wildPositions).sort((a, b) => a - b); clusters.push({ symbol: sym, positions: all, size: all.length }); } return clusters;}4.9Multi-Cluster Wild Sharing (Step 21)
A wild isn't used up by one cluster: it counts toward every cluster on the grid. Step 21 takes every round where two or more symbols pay at once with at least one wild on the grid, and requires every one of those paylines to count all the wilds. One payline that leaves a wild out would fail the step.
const leftOut: string[] = [];for (const pl of clusters) { let symCount = 0; for (let c = 0; c < REELS; c++) for (let r = 0; r < ROWS; r++) if (round.data.view[c][r].symbol === pl.symbol) symCount++; if (symCount + wilds !== pl.count) leftOut.push(`${pl.symbol} count ${pl.count} ≠ ${symCount} + ${wilds} wild`);}symbol_1 and symbol_7 to 8 (S4.18).4.10Scatter Trigger Rule (Step 22)
Three or more scatters on the grid at the end of a spin's cascade start the bonus: 3 → 8 free spins, 4 → 10, 5 → 12, 6+ → 14 (scatter_rewards in the config). Scatters are never removed, so the final grid holds every scatter that landed. Step 22 checks every captured trigger against the table, and recounts the scatters on the final grid to make sure they equal the count Duel reports in trigger_data.scatter_count. That stops both fields being inflated together.
| Scatters | Free spins | Captured triggers | Result |
|---|---|---|---|
| 3 | 8 | 30 (organic) | All match |
| 4 | 10 | 22 (2 organic + 20 buys) | All match |
| 5 | 12 | 1 (organic) | Match |
| 6+ | 14 | 0 | Not reached; from the published table |
| Total | — | 53 | 53 / 53 match |
const fs = b.response.feature_status;const scatters = fs?.trigger_data?.scatter_count ?? 0;const expectedSpins = freeSpinsAwarded(ctx.paytable, scatters, false);const awardedSpins = fs ? (fs.current_spin || 0) + (fs.remaining_spins || 0) : 0;if (scatters >= 3 && awardedSpins === expectedSpins) { // ok} else { mismatched++; if (fails.length < 3) fails.push(`bet ${b.spinId}: scatters=${scatters}, expected_spins=${expectedSpins}, awarded=${awardedSpins}`);} const rounds = b.response.rounds;if (rounds && rounds.length > 0) { const finalView = rounds[rounds.length - 1].data?.view; let gridScatters = 0; if (finalView) { for (let col = 0; col < REELS; col++) { for (let row = 0; row < ROWS; row++) { if (finalView[col][row]?.symbol === BONUS_CODE) gridScatters++; } } } if (gridScatters !== scatters) { gridScatterMismatched++; if (fails.length < 3) fails.push(`bet ${b.spinId}: trigger_data.scatter_count=${scatters} but grid has ${gridScatters} scatters`); }}4.11Retrigger Behaviour (Step 23)
Inside the bonus, 3 or more scatters on a free spin's final grid retrigger extra spins, up to 3 retriggers per session (retrigger_rewards and max_retriggers in the config):
| Mid-bonus scatters | Extra spins awarded |
|---|---|
| 3 | 3 |
| 4 | 5 |
| 5 | 8 |
| 6 | 10 |
Step 23 counts every retrigger and checks the cap of 3 per session; the exact convolution (S4.3) applies the whole table.
4.12Buy-Bonus Mechanics (Steps 24, 25)
A player can buy straight into the bonus for 125× the stake. Duel's help panel says: "The first spin of a bought bonus game is purely cosmetic and no clusters or wins trigger. It simply shows a guaranteed bonus, thus isn't verifiable through the Provably Fair system." That buy spin is the one part of Groomer's Van not drawn from the seeds. Its grid is chosen by the server, Duel's verify record leaves it out, and the config fixes what it must show: buy_scatter_count 4, so 10 free spins and the 4-scatter pay of 3× the stake. The 10 free spins that follow are drawn from the seeds like any other.
- The buy spin: canned, flagged
_verify_session.is_bonus_buy = true, no cluster paylines; only its 4-scatter pay of 3× is credited. - The session: 10 free spins at the buy's nonce, round index 0–9, recomputed and paid exactly like any other free spin (Steps 5, 26, 28).
- What isn't certified: the buy's RTP. A bought session's exact EV is 121.9996× the stake and the buy spin pays 3×, against a 125× price, but the buy spin isn't generated from the seeds, so the buy is not in the RTP table.
| Check | Coverage | Result |
|---|---|---|
Buy disclosure flag (is_bonus_buy = true) | 20 / 20 buys | Pass |
| No cluster paylines on the buy spin | 20 / 20 buys | Pass |
Exactly 4 scatters (buy_scatter_count 4) | 20 / 20 buys | Pass |
| Exactly 10 free spins awarded | 20 / 20 buys | Pass |
| Free spins from the buys recomputed and paid exactly | 203 / 203 free spins (200 + 3 from one retrigger) | Pass |
| Bonus-buy RTP | Not certified: the buy spin is canned | Not tested |
4.13Payout Reconciliation (Steps 7, 8, 26)
For every captured spin, the payline payouts are summed across all rounds, each as base_payout × max(bomb_multiplier, 1), and compared with the spin's amount_won in integer cents, with no tolerance. In the base game bomb_multiplier is 0, so the factor is 1. Separately, every payline's multiplier is looked up in the published paytable by symbol and min(count, 12). The money fields are checked too: amount_won (USD) against the paylines, and amount_won_coins against the USD credit at the bet's own coins/USD rate.
| Check | Formula | Captured | Result |
|---|---|---|---|
| Step 7 — Payout Math | Σ base_payout × max(bomb, 1) = amount_won, in integer cents | 6,205 / 6,205 non-buy entries | 0 mismatched |
| Step 7 — Coins field | amount_won_coins = round(amount_won × rate, 2 dp) | 6,225 / 6,225 entries | 0 mismatched |
| Step 8 — Multiplier Provenance | payline multiplier = paytable[symbol][min(count, 12)] | 4,985 / 4,985 paylines | 0 mismatched |
| Step 26 — Free-Spin Payout | Σ base_payout × max(bomb, 1) = amount_won, per free spin | 475 / 475 free spins | 0 mismatched |
let summed: bigint | null = 0n;for (const round of b.response.rounds) { for (const pl of round.data.paylines) { const base = centsOf(pl.base_payout_currency || pl.payout_currency || '0'); const bomb = pl.bomb_multiplier ?? 0; if (base === null || summed === null || !Number.isInteger(bomb)) { summed = null; continue; } summed += base * BigInt(Math.max(bomb, 1)); }}const reported = centsOf(b.response.amount_won ?? '0');if (summed !== null && reported !== null && reported === summed) ok++;4.14Bonus Multipliers (Steps 26, 27)
The multiplier symbol exists only in the bonus game's symbol set (12 symbols; the base game has 11). When one lands in a free spin, it takes a value drawn from the published weights (2× to 250×, weights summing to 200), with the same discard rule as the cells. Multipliers never join clusters and are never removed, so they stay through the spin's cascades. When the spin settles, the values that landed on the grid during it are added up into bomb_multiplier, which multiplies that spin's total cluster win. Each free spin starts from a fresh grid, so a multiplier doesn't carry over to the next one.
Example, free spin 1966450 ($0.20): one 7× multiplier on the opening grid; round 0 pays symbol_1 (0.4×) and symbol_2 (0.5×), round 1 pays symbol_4 (0.7×), a base sum of 1.6×; amount_won = $0.20 × 1.6 × 7 = $2.24.
Σ base × max(bomb, 1) exactly, with one bomb value per spin across all its paylines and rounds.4.15Max-Win Cap (Step 34)
Duel's config caps a win at 5,000× the stake (max_multiplier). The enumerations apply it per free spin, and the session convolution per session. Step 34 checks every served entry and every bonus session against it.
| Item | Value |
|---|---|
| Entries within 5,000× | 6,225 / 6,225 |
| Bonus sessions within 5,000× | 53 / 53 |
| Largest served win | 630× on one spin, 647.1× over one session |
| Largest base-game outcome (2³²) | 112.8× |
| Largest free spin without the cap (2³²) | 8,232.8× |
| RTP the per-spin cap removes | At most 0.0005 pp of the whole game |
| Chance a session reaches the cap | 3.9 × 10⁻⁷ (8 spins) to 8.1 × 10⁻⁷ (14 spins) |
4.16Captured Returns & Live Fit (Step 35, informational)
Reported for context. Finite samples show variance, not the RTP: the evidence for the RTP is S4.2–4.3. Step 35 tests the 5,730 live base spins against the exact figures, at a Bonferroni α of 0.01 / 8, and is informational.
| Source | Sample | Result |
|---|---|---|
| Base-game spins (with scatter pays) | 5,730 | 56.87% RTP; Pass 1 reference 55.71%, z = +0.91 |
| Base-game hit rate | 2,619 / 5,730 | Fits the exact 45.58% (p = 0.86) |
| Organic triggers | 33 / 5,730 | 0.576%; fits the exact 1 in 227.1 (p = 0.16) |
| Live symbol frequencies | 5,730 first deals | Fit the published weights on all 6 reels |
| Organic bonus sessions | 33 | Average 104.1× the trigger stake; exact expectation 99.53× |
| Bought bonus sessions | 20 | Average 95.2× the stake with the 3× buy-spin pay; exact expectation 125.0× |
4.17Bet-Size Invariance (Step 9)
S3.8 shows the grid doesn't depend on the stake. From the payout side: every pay is multiplier × stake × max(bomb, 1), so the stake scales the payout linearly and enters nothing else, up to the 5,000× cap. With no edge applied, the paytable is the same at every captured stake. Phase B placed 30 bets at six stakes from $1 to $50.
4.18Worked Example — Payout Reconciliation (Spin 1964428)
A real bet from Phase A: spin 1964428, nonce 3, stake $0.20. The first deal has two clusters at once, symbol_1 and symbol_7, each 7 cells plus the same wild (S4.9). Over 4 rounds, the first deal and 3 cascades, 4 cluster wins pay $0.70. The last cascade forms no cluster and the spin settles.
serverSeed = 38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67
clientSeed = pf_ww6Oka8nm8byd
nonce = 3
phase = A
stake = $0.20
mode = spin (base_game; no bonus trigger)
rounds = 4 (initial deal + 3 cascades; round 3 = no cluster, cascade terminates)
amount_won = $0.70 (sum of 4 cluster payouts)| Round | Cluster | Count | Multiplier | Payout |
|---|---|---|---|---|
| 0 | cluster_symbol_1_8 | 8 (7 symbol_1 + 1 wild) | 0.4× | $0.08 |
| 0 | cluster_symbol_7_8 | 8 (7 symbol_7 + 1 wild, same wild as above) | 1.8× | $0.36 |
| 1 | cluster_symbol_3_8 | 8 (7 symbol_3 + 1 wild) | 0.6× | $0.12 |
| 2 | cluster_symbol_4_8 | 8 (8 symbol_4, no wild on grid this round) | 0.7× | $0.14 |
| 3 | (no cluster — cascade terminates) | — | — | $0.00 |
| Sum | — | — | — | $0.70 |
// spin 1964428 · Phase A · $0.20 · base game · nonce 3 · 4 rounds// Step 7: sum of payline payouts × max(bomb_multiplier, 1), in integer centsround 0 cluster_symbol_1_8 7 symbol_1 + 1 wild 0.4× → 8¢round 0 cluster_symbol_7_8 7 symbol_7 + 1 wild 1.8× → 36¢ (the same wild)round 1 cluster_symbol_3_8 7 symbol_3 + 1 wild 0.6× → 12¢round 2 cluster_symbol_4_8 8 symbol_4 0.7× → 14¢round 3 no cluster: the cascade endsbomb_multiplier = 0 on every payline (base game), so max(0, 1) = 1sum = 8 + 36 + 12 + 14 = 70¢ served amount_won = $0.70 equal // Step 8: each payline's multiplier against the published paytable (tier = min(count, 12))symbol_1 @ 8 = 0.4× symbol_7 @ 8 = 1.8× symbol_3 @ 8 = 0.6× symbol_4 @ 8 = 0.7× // Step 19: count = (cells of the symbol) + (wilds on the grid)round 0: symbol_1 7 + 1 = 8 · symbol_7 7 + 1 = 8 · round 1: symbol_3 7 + 1 = 8 · round 2: symbol_4 8 + 0 = 8Technical Evidence & Verification5 sections
4.19Evidence Coverage Summary13 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Anti-circularity (Step 16) | Simulation scored against the exact figure; 2 / 2 wrong trigger rules rejected | Pass |
| Enumeration integrity (Steps 29–31) | Base and bonus 2³² artifacts and the 4 session artifacts match their pins | Pass |
| Enumerated RTP (Step 32) | 99.9720%, re-derived from the artifacts on every run | Pass |
| RTP claim (Step 32) | 100% claim from game settings; −0.028 pp; ±0.1 pp band | Pass |
| No edge applied (Step 10) | 6,225 / 6,225 edge_multiplier = 1 | Pass |
| Simulation Pass 1 (Steps 16, 17) | 30M spins, 100.06%; 0 / 6 reels fail χ² | Pass |
| Cherry-pick test (Step 18) | z = +0.91; 4 / 115 seeds flagged, p = 0.83 | Pass |
| Payouts (Steps 7, 8, 26) | 6,205 / 6,205 entries; 4,985 / 4,985 multipliers; 475 / 475 free spins | Pass |
| Game rules (Steps 19, 21, 22, 23, 27) | 4,982 clusters; 410 shared-wild rounds; 53 triggers; cap held; 935 multipliers bonus-only | Pass |
| Bonus buy (Steps 24, 25) | 20 / 20 flagged, 4 scatters, 10 free spins | Pass |
| Max-win cap (Step 34) | 6,225 entries and 53 sessions within 5,000× | Pass |
| Live fit (Step 35) | 6 / 6 reels; hit and trigger rates fit | Pass |
| Stake tiers without Zero Edge | From the config: 116 spin and 184 bonus brackets, 0.01% at $0.20 | Info |
4.20Code References14 source files
| File | Purpose |
|---|---|
| src/enumerate-mt.ts | Exhaustive 2³² per-spin enumeration on the CPU (cuda/ holds the GPU kernel) |
| src/session-ev-exact.ts | Exact bonus-session EV by dense-lane convolution |
| src/rtp-claim.ts | The framework's RTP-CLAIM rule 1.2.0 |
| src/rtp-settings.ts | The claim (100% flat, game settings) and the RTP table for this package |
| src/simulate.ts | Monte Carlo: 30M base spins with integrated sessions, Pass 2 forward replay |
| src/paytable.ts | The published paytable, reel weights and multiplier weights |
| src/cluster.ts | findClusters (counted clusters with wilds) and countScatters |
| tests/steps/enumeration.ts | Steps 29–32: artifact pins and the headline RTP derivation |
| tests/steps/payouts.ts | Steps 7–9: exact payouts, paytable provenance, bet-size invariance |
| tests/steps/dataset.ts | Steps 10–11: edge_multiplier, config and paytable coverage |
| tests/steps/simulation.ts | Steps 16–18: anti-circularity, Pass 1, Pass 2 |
| tests/steps/game-specific.ts | Steps 19–27: clusters, wilds, triggers, retriggers, buys, free-spin pay, multipliers |
| tests/steps/max-win.ts | Step 34: the 5,000× cap |
| tests/steps/live-fit.ts | Step 35: live-sample fit |
4.21Datasets UsedSource artifacts
4.22Verified Invariants14 invariants
| Invariant | Result |
|---|---|
| Base RTP over all 2³² outcomes = 0.561376×, equal to the artifact's own sum / count and histogram mean | Pass |
| Base RTP + P(trigger) × E[session | trigger] = 99.9720% | Pass |
| RTP claim holds: −0.028 pp from Duel's stated 100%, inside ±0.1 pp | Pass |
| The simulation is within 5 standard errors of the exact figure on all four components; wrong trigger rules are rejected | Pass |
edge_multiplier = 1 on every captured bet | Pass |
Every non-buy entry's amount_won = Σ base_payout × max(bomb, 1), in integer cents | Pass |
| Every payline multiplier = the published paytable at min(count, 12) | Pass |
| Cluster count = symbol cells + wilds; every wild counts for every cluster | Pass |
| Every trigger awards the published spins; the reported scatter count equals the final grid's | Pass |
| No session exceeds 3 retriggers | Pass |
| Every buy is flagged, cluster-free, shows 4 scatters and awards 10 free spins | Pass |
| Multiplier symbols appear in the bonus game only, with published values | Pass |
| Every served win and session is within 5,000× | Pass |
| Captured return consistent with the reference (z = +0.91); 4 / 115 seeds flagged, within chance | Pass |
4.23Reproduction InstructionsRun locally
Clone the repository at the release tag, install, and run the verifier. The enumerations take hours on a CPU (S7); the verifier re-derives the headline from their pinned artifacts:
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verifycat outputs/rtp-claim-table.jsonExpected output, as run at v1.2.1 (lines for this section):
[PASS] Step 7 — Payout Math
[PASS] Step 8 — Multiplier Provenance
[PASS] Step 9 — Bet-Size Invariance
[PASS] Step 10 — House Edge Audit (Zero Edge consistency)
[PASS] Step 16 — Anti-Circularity
[PASS] Step 17 — Simulation Pass 1
[PASS] Step 18 — Pass 2 Cherry-Pick Detection
[PASS] Step 19 — Cluster Pays Anywhere
[PASS] Step 21 — Wild Substitution Rule
[PASS] Step 22 — Bonus Trigger
[PASS] Step 23 — Retrigger Behaviour
[PASS] Step 24 — Cosmetic Buy-Spin Disclosure
[PASS] Step 25 — Buy-Bonus Structure
[PASS] Step 26 — Free-Spin Payout Reconciliation
[PASS] Step 27 — Bonus Multiplier Symbol
[PASS] Step 29 — Base 2³² artifact integrity
[PASS] Step 30 — Bonus 2³² artifact integrity
[PASS] Step 31 — Session-EV artifact integrity
[PASS] Step 32 — Headline game RTP derivation
[PASS] Step 34 — Max-Win Cap & Payout Bounds (GROOMERS-14)
[PASS] Step 35 — Live-Sample Fit (informational, GROOMERS-22)
rtp-claim: ENFORCED — PASS
rtp-claim: claim flat 100.000000% — source: game settings: "rtp": "100.0000" in Duel's Groomer's Van game config v1.4 (data/raw/groomers-van-config-v1.4.json:9; declaration gameModel.edge.claimed 0)
rtp-claim: band ±0.10 pp · 1 settings · true min 99.972000% (paid spin (base game + triggered bonus)) · true max 99.972000% (paid spin (base game + triggered bonus))
rtp-claim: house side beyond band: 0 · player-favourable beyond band: 0 · worst paid spin (base game + triggered bonus) at -0.028000 pp
rtp-claim: outcome PASS · minimal fix: none — the claim holds for every setting it states a figure for
rtp-claim: committed table outputs/rtp-claim-table.json: equals this run; sha256 58de71cb6dc34e2e… matches the pinnpm run verify re-derives every S4 figure from the pinned artifacts and writes to outputs/run/. npm run test:full also re-runs the 30M simulation and compares it with the pinned results.Fairness Integrity Testing
Does the implementation maintain fairness under non-standard conditions?
Sections 1–4 prove the game is mathematically fair. Section 5 proves the implementation maintains integrity under non-standard conditions. We applied 18 fairness integrity tests covering nonce integrity, seed commitment, outcome determinism, cross-player isolation, payout integrity, and Groomer's Van-specific multi-step game-state checks for the buy-bonus, animation-confirmation, and free-spin-session surfaces. 15 tests pass; 2 are FLAG (server-side input-validation gaps at the /spin and /buy endpoints, disclosed to Duel.com — neither affects the commit-reveal fairness guarantees); 1 is N/A for this game class.
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, payline, or grid values be injected client-side?
- Parameter limits — can invalid bet amounts or feature codes be submitted?
- Groomer's Van-specific — can the
/buyendpoint,/confirm-animationendpoint, or free-spin session state (multiplier values, spins remaining, retriggers) be exploited via invalid inputs, injection, or replay?
What this means for you
- All 18 fairness integrity tests in our matrix completed — 15 pass, 2 flagged input-validation gaps (disclosed to the operator), 1 N/A
- Once a bet is placed, the grid and cascade chain cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player and every other bet you have placed
- The two flagged findings are server-side input-validation gaps — neither lets an attacker change a spin's outcome or affects the commit-reveal fairness guarantees
- 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, payline, or grid values be injected client-side?
- Parameter limits — can invalid bet amounts or feature codes be submitted?
- Groomer's Van-specific — can the
/buyendpoint,/confirm-animationendpoint, or free-spin session state (multiplier values, spins remaining, retriggers) be exploited via invalid inputs, injection, or replay?
- All 18 fairness integrity tests in our matrix completed — 15 pass, 2 flagged input-validation gaps (disclosed to the operator), 1 N/A
- Once a bet is placed, the grid and cascade chain cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player and every other bet you have placed
- The two flagged findings are server-side input-validation gaps — neither lets an attacker change a spin's outcome or affects the commit-reveal fairness guarantees
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityFlag
/spin accepts amount=1001 above the published $1,000 upper cap (disclosed to Duel.com — no fairness break, spin still resolved through commit-reveal RNG). S4 separately verifies 6,205 / 6,205 organic payouts reconcile.Game state integrity (GV-specific)Flag
/confirm-animation enforces ownership / rejects replay; free-spin session injection ignored). 1 / 3 flagged: /buy accepts a request with missing feature_code field — server returns a regular base spin (not a bought feature), no advantageous outcome possible. Disclosed to Duel.com. S4 separately verifies organic determinism (20 / 20 buy-bonuses, 475 / 475 free spins).18 fairness integrity tests: 15 pass, 2 FLAG (server-side input-validation gaps at /spin and /buy — neither breaks fairness), 1 N/A (replay-for-profit on cascade rounds doesn't apply — cascades resolve atomically). Disclosed to Duel.com.
Category Coverage
| Check | Result | Evidence |
|---|---|---|
| Nonce integrity | Pass | Sequential, server-controlled, no duplicates across 116 captured seed pairs; 4 nonces missed on retried requests (capture script, not Duel). Adversarial nonce injection (FI-NONCE-003): 7 invalid values tested, all ignored — server assigned consecutive nonces 11–17. |
| Seed commitment integrity | Pass | Locked at bet acceptance, unique per seed pair — 116 / 116 revealed seeds verified, 117 / 117 seed entries unique. Adversarial probes (FI-SEED-001/004/005): invalid-seed handling, cross-account isolation, and timing analysis all pass. |
| Outcome determinism | Pass | Identical inputs produce identical grids — 6,205 / 6,205 non-buy spins, 4,323 cascade rounds, 129,690 cells, and all 935 captured multiplier symbols across the dataset (146 / 146 newly-generated cascade multiplier cells byte-exact; initial-deal grids covered by Step 5). Replay-for-profit is N/A — no per-cascade endpoint exists |
| Round & player isolation | Pass | Per-user seeds, serial independence confirmed (30M Pass 1: 0/6 reels reject, lag-1 |z|=0.57, runs p=0.97); cross-user isolation follows from seed uniqueness |
| Payout integrity | Flag | 1 / 2 adversarial-injection probes pass (outcome-field injection ignored). 1 / 2 flagged: /spin accepts amount=1001 above the published $1,000 upper cap (disclosed to Duel.com — no fairness break, spin still resolved through commit-reveal RNG). S4 separately verifies 6,205 / 6,205 organic payouts reconcile. |
| Game state integrity (GV-specific) | Flag | 2 / 3 adversarial probes pass (/confirm-animation enforces ownership / rejects replay; free-spin session injection ignored). 1 / 3 flagged: /buy accepts a request with missing feature_code field — server returns a regular base spin (not a bought feature), no advantageous outcome possible. Disclosed to Duel.com. S4 separately verifies organic determinism (20 / 20 buy-bonuses, 475 / 475 free spins). |
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityFlag
/spin accepts amount=1001 above the published $1,000 upper cap (disclosed to Duel.com — no fairness break, spin still resolved through commit-reveal RNG). S4 separately verifies 6,205 / 6,205 organic payouts reconcile.Game state integrity (GV-specific)Flag
/confirm-animation enforces ownership / rejects replay; free-spin session injection ignored). 1 / 3 flagged: /buy accepts a request with missing feature_code field — server returns a regular base spin (not a bought feature), no advantageous outcome possible. Disclosed to Duel.com. S4 separately verifies organic determinism (20 / 20 buy-bonuses, 475 / 475 free spins).18 fairness integrity tests: 15 pass, 2 FLAG (server-side input-validation gaps at /spin and /buy — neither breaks fairness), 1 N/A (replay-for-profit on cascade rounds doesn't apply — cascades resolve atomically). Disclosed to Duel.com.
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 standard categories target specific fairness properties; for Groomer's Van we add a sixth category — Game State Integrity — covering the slot-specific surfaces that don't exist in card or dice games: the /buy endpoint, the /confirm-animation endpoint, and the multi-spin free-spin session with sticky multipliers and retriggers. Scope boundary: S5 tests whether fairness guarantees hold under non-standard API interaction. Platform-level security testing (network protection, account auth, operational controls) falls outside standard certification.
| Category | Tests | What It Catches |
|---|---|---|
| Nonce Integrity | 4 | Sequence gaps, server-side nonce manipulation, invalid-input handling, session continuity |
| Seed Commitment | 5 | Mid-pair seed changes, seed reuse, predictable seed generation, cross-account seed pools, invalid client seed handling |
| Outcome Determinism | 2 | Non-deterministic outputs, outcome replay for duplicate payouts (N/A for single-call games like Groomer's Van) |
| Player Isolation | 2 | Cross-round correlation, cross-user outcome dependence |
| Payout Integrity | 2 | Parameter enforcement at /spin boundary, server-side computation of grid / multipliers / payouts under field injection |
| Game State Integrity (GV-specific) | 3 | Buy-bonus stake/feature-code injection, animation-confirmation cross-account / replay / fake-ID abuse, free-spin session field injection (multiplier values, spins remaining, retrigger forcing) |
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 seed pair | Outcome sequence integrity broken |
| Server seed changed mid-seed-pair | Commit-reveal guarantee broken |
| Grid recomputation mismatch | Undisclosed inputs affecting outcome generation |
| Client seed not used in HMAC | Player has no influence on outcomes |
| Grid changes during a cascade chain | Per-cascade manipulation possible |
| /buy or /confirm-animation accept cross-account spin IDs | Game state isolation broken |
| Free-spin session state mutable via injected fields | Multi-step state corruption |
18 tests · 15 pass · 2 flag · 1 N/A
Nonce Integrity4/4
FI-NONCE-001PassEach bet uses unique, sequential nonce
S1, Step 4 — every paid spin (base spin or bonus buy) has a unique sequential nonce within its seed pair, and free spins use the nonce of the spin that started the bonus (116 seed pairs, 0 duplicates). 112/116 epochs gap-free: 4 nonces missed on capture-script retries (capture flag, not a Duel issue).
FI-NONCE-002PassNonce progression cannot be manipulated by client
S1, Step 4 — server controls nonce assignment; no captured bet shows a client-overridden nonce
FI-NONCE-003PassAn invalid or out-of-sequence nonce sent with a bet is ignored — the server assigns the next nonce itself, so a client cannot choose or skip one
7 adversarial nonces injected (−1, 0, 999999999, 'abc', INT32_MAX, INT32_MAX+1, 9e18); server ignored all and assigned consecutive nonces (11–17). baselineNonce=10, postTestNonce=18, no gaps, no stack traces leaked.
FI-NONCE-004PassNonce does not reset on reconnect
S1, Step 4 — 4 auditor-capture artefacts confirmed nonce continuity across sessions; casino's nonce stream did not reset to 0
Seed Commitment5/5
FI-SEED-001PassInvalid/empty client seeds handled deterministically
7 adversarial seeds tested (empty, 1,001-char ASCII, null, special chars, emoji, non-ASCII Unicode, single space). 6 rejected with HTTP 422; the 1,001-char seed was accepted and stored cut to 255 characters. Game remained functional after every rejection. No stack traces leaked.
FI-SEED-002PassSeed is locked at bet acceptance — no mid-seed-pair mutation
S1, Steps 3 & 6 — server seed hash constant within every seed pair, 0 mutations detected; client seed influence verified at >99% via Step 6
FI-SEED-003PassServer seed unique per session / seed pair
S1, Step 1 — 117 distinct server seed entries captured across audit (116 revealed + 1 active), 0 reuse
FI-SEED-004PassNo shared seed pool across users
20 concurrent seed rotations across two accounts (10 each). All 20 serverSeedHashed values distinct; 0 collisions across 190 pairwise comparisons. Confirms isolated entropy pools.
FI-SEED-005PassSeeds not predictable from timing
10 seed rotations at 5-second intervals over 50 seconds. All 10 SHA-256 hashes distinct, no suspicious hex prefix patterns. No evidence of clock-seeded or time-correlated entropy.
Outcome Determinism2/2
FI-OUTCOME-001PassIdentical inputs produce identical outcomes
S3, Step 5 + Step 28 — 6,205/6,205 spins and free spins independently recomputed from seeds via HMAC-SHA256 → PCG32 → 30-cell grid (the 20 bonus buys are generated by Duel outside the seeds); Step 28 byte-exact cascade replay reproduces 129,690/129,690 cells and 146/146 newly-generated cascade multiplier cells across 4,323 cascade rounds
FI-OUTCOME-002N/AOutcomes cannot be replayed for profit
Architecture review — cascade chain is server-computed atomically within a single /spin response; no per-cascade endpoint exists to interrupt or replay. Nonce increments server-side after each /spin; free-spin sessions advance via /spin in bonus mode.
Player Isolation2/2
FI-ISO-001PassRNG state independent across rounds
S2, Step 17 — 30M Pass 1 simulation: 0/6 reels reject chi-squared at Bonferroni α=0.0017; lag-1 |z|=0.57; runs p=0.97 — no correlation between consecutive outcomes
FI-ISO-002PassNo cross-user outcome correlation
Follows from FI-SEED-004 — if seeds are unique per user, outcomes are isolated by construction. Will be re-confirmed once FI-SEED-004 probe completes.
Payout Integrity1/2
FI-PAYOUT-001FlagGame parameters cannot exceed defined limits
Input validation gap at /spin. (a) amount=1001 accepted, processed as real $1001 stake (spin 2531746, bet_amount_currency=1001.000000) — bypasses published $1,000 upper cap. (b) amount field omitted accepted, server fell back to $0.20 minimum (spin 2531748) — not a high-stake bypass. The other 4 values (negative, zero, non-numeric, below-min) were rejected. The bypass spin resolved through the normal commit-reveal RNG chain (no fairness break). Disclosed to Duel.com.
FI-PAYOUT-002PassMultiplier/payout/outcome fields cannot be injected
5 outcome fields injected at /spin (total_win, total_multiplier, rounds[].win_amount, edge_multiplier, feature_triggered). All 5 injections silently ignored — server returned organically computed outcomes from the seed chain in every case.
Game State Integrity (GV-specific)2/3
FI-GV-BUYBONUS-001Flag/buy endpoint cannot be exploited via invalid stake or feature-code injection
Input validation gap at /buy. feature_code field omitted accepted (HTTP 200, spin 2535750), but server returned spin_type: base_game with bet_amount_currency: 0.2 and a 3× organic base-game payout — server did not deliver a bought feature, just ran a regular base spin. The other 5 inputs (negative amount, zero amount, amount=1001, unknown feature_code, null feature_code) were rejected. Note: /buy does enforce the $1,000 upper cap (request with amount=1001 rejected) — only /spin does not. No advantageous outcome possible from this gap. Disclosed to Duel.com.
FI-GV-CONFIRM-001Pass/confirm-animation endpoint cannot confirm someone else's spin or be replayed
/confirm-animation enforces spin ownership and prevents replay. First confirm accepted (spin 2532728); double-confirm rejected (HTTP 500); non-existent spin ID rejected (HTTP 404); cross-account confirm (Account B attempting Account A's spin) rejected (HTTP 500).
FI-GV-BONUS-001PassFree-spin session state cannot be manipulated by injected request fields
5 injection probes during active bonus session (multiplier_value=250, feature_status.spins_remaining=99, respin_data.scatter_count=4, feature_status.is_completed=false, edge_multiplier='0'). All 5 ignored — spins_remaining, is_completed, and feature_triggered in responses matched server-computed values.
Technical Evidence & Verification4 sections
5.3Coverage Summary18 checks
The full Groomer's Van fairness integrity matrix — 18 tests across 6 categories. Each test ID below corresponds to the same standardised test definition used across every PF.org audit, plus three GV-specific tests for the slot's unique multi-step surfaces.
| 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, Step 5 + Step 28 (data-driven) | Pass |
| FI-OUTCOME-002 | Determinism | Architecture review | N/A |
| FI-ISO-001 | Isolation | S2, Step 17 (data-driven) | Pass |
| FI-ISO-002 | Isolation | Follows from FI-SEED-004 | Pass |
| FI-PAYOUT-001 | Payout | API probe | Flag |
| FI-PAYOUT-002 | Payout | API probe | Pass |
| FI-GV-BUYBONUS-001 | Game State (GV) | API probe | Flag |
| FI-GV-CONFIRM-001 | Game State (GV) | API probe | Pass |
| FI-GV-BONUS-001 | Game State (GV) | API probe | Pass |
/spin, FI-GV-BUYBONUS-001 at /buy — disclosed to Duel.com). 1 test (FI-OUTCOME-002) is N/A for this game class: Groomer's Van resolves all cascade rounds atomically inside a single /spin response, so there is no per-cascade replay surface to test.5.4Additional Integrity Evidence (S1–S4)10 records
Beyond the FI matrix above, Sections 1–4 produce additional evidence relevant to fairness integrity. The most important data-driven findings, with their verification source and what they imply for the integrity question:
| Property | Source | Finding |
|---|---|---|
| 116/116 revealed seeds verified (117 seed entries incl. 1 active) | S1, Step 1 | Commit-reveal chain intact |
| 116/116 next-seed links verified | S1, Step 2 | Seed rotation chain intact |
| 6,205/6,205 byte-equal grid reproductions (all but the 20 bonus buys) | S3, Step 5 | No post-RNG conditional logic, grid fixed at round start |
| 4,323/4,323 cascade rounds byte-equal | S3, Step 28 | Multi-cascade determinism intact (129,690 cells reproduced) |
| Anti-circularity (2³² enumeration) | S4, Step 16 | 99.9720% RTP computed exactly from primitives by full 2³² enumeration |
| Cherry-pick detection (forward-replay) | S4, Step 18 | 115 committed seeds replayed 10,000 nonces each — 4/115 flagged (p = 0.8321), no seed pre-selection |
| 99%+ client seed influence | S1, Step 6 | Player entropy is genuine |
| 475/475 free spin payouts reconciled | S4, Step 26 | Bonus-session payout integrity intact |
| 935/935 multiplier symbols confined to bonus_game | S4, Step 27 | Sticky-multiplier scope honoured — 0 multiplier appearances in base_game |
| 20/20 buy-bonuses honest | S4, Steps 24 & 25 | Buy-bonus structure (4 scatters → 10 free spins) delivered exactly |
5.5Scope
This certification covers the 18 fairness integrity tests listed above — the minimum required to verify that the provably fair implementation holds up under non-standard conditions, including three Groomer's Van-specific multi-step state integrity tests for the buy-bonus, animation-confirmation, and free-spin-session surfaces. This is not a penetration test. It focuses specifically on the provably fair implementation — not the operator's broader platform security.
Standard scope: The 18 tests above are our standard Groomer's Van fairness integrity matrix. The base list (Nonce / Seed / Determinism / Isolation / Payout, 15 tests) is applied to every game we audit. The 3 game-specific tests at the end (Game State Integrity) cover slot-specific multi-step surfaces — buy-bonus economics, animation confirmation, and free-spin session state — that don't exist in card or dice 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 (8 of 18): Fully reproducible from the open-source repo. These tests run against the captured dataset and produce deterministic results.
API probe tests (9 of 18): Verified by issuing live adversarial requests against the running game. Per-test evidence (HTTP status codes, server-assigned nonces, seed hashes, server-computed multipliers, grid / cascade decisions) is retained in PF.org's private adversarial-testing archive. The testing harness itself is kept private so it can't be reused against the game. Operators and regulators can request per-test transcripts.
N/A test (FI-OUTCOME-002): Verified by architectural analysis — Groomer's Van resolves all cascade rounds atomically within a single /spin response. There is no per-cascade endpoint to interrupt or replay, so the "replay-for-profit on cascade rounds" attack surface that this test targets does not exist on this game.
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verifyExpected output, as run at v1.2.1 (S5-related steps, mapping added):
[PASS] Step 1 — Seed Hash Integrity → FI-SEED-003
[PASS] Step 3 — Hash Consistency Within Epoch → FI-SEED-002
[FLAG:capture] Step 4 — Nonce Audit → FI-NONCE-001, 002, 004
[PASS] Step 5 — Outcome Recomputation → FI-OUTCOME-001
[PASS] Step 6 — Client Seed Influence → FI-SEED-002
[PASS] Step 17 — Simulation Pass 1 → FI-ISO-001
[PASS] Step 24 — Cosmetic Buy-Spin Disclosure → FI-GV-BUYBONUS-001 (data component)
[PASS] Step 25 — Buy-Bonus Structure → FI-GV-BUYBONUS-001 (data component)
[PASS] Step 26 — Free-Spin Payout Reconciliation → FI-GV-BONUS-001 (data component)
[PASS] Step 27 — Bonus Multiplier Symbol → FI-GV-BONUS-001 (data component)
[PASS] Step 28 — Cascade RNG Byte-Exact Replay → FI-OUTCOME-001 (cascades)API Probe Tests:
[PASS] FI-NONCE-003 — Invalid nonce handling at /spin → 7 invalid nonces (negative, zero, oversized, non-numeric)[PASS] FI-SEED-001 — Invalid client seed handling at change_seed → 7 cases (empty, null, oversized, special chars, emoji, non-ASCII, single space)[PASS] FI-SEED-004 — Cross-user seed pool check → 2 accounts × 10 rotations, check for hash collisions[PASS] FI-SEED-005 — Seed timing analysis → 10 rotations at 5-second intervals, check prefix patterns[FLAG] FI-PAYOUT-001 — Invalid bet-amount handling at /spin → 6 cases (negative, zero, over-max, non-numeric, below-min, missing)[PASS] FI-PAYOUT-002 — Field-injection handling at /spin → 5 fields (total_win, total_multiplier, rounds, edge_multiplier, feature_triggered)[FLAG] FI-GV-BUYBONUS-001 — /buy endpoint adversarial handling → 6 cases (negative, zero and over-max stake; unknown, null and missing feature_code)[PASS] FI-GV-CONFIRM-001 — /confirm-animation adversarial handling → 4 cases (first confirm, double-confirm, fake ID, cross-account)[PASS] FI-GV-BONUS-001 — Free-spin session field injection → 5 fields (multiplier_value, spins_remaining, scatter_count, is_completed, edge_multiplier)Player Verification
Can a player verify their own bets without trusting anyone?
Every Groomer's Van spin can be checked from public inputs. Save the hashed server seed before you play. After you rotate, compare the revealed seed's hash with your saved copy, then recompute the spin. This section walks through it step by step, with scripts you can run yourself that reproduce all 6,205 recomputable spins, and links the ProvablyFair.org verifier.
Key principles
- Save the hashed server seed before you play: your saved copy is what proves the timing
- Every spin, every cascade and every free spin can be reproduced from the seeds
- If your recomputed grids and payout match the game, the spin was the committed one
- The first spin of a bought bonus is the one exception: Duel says it is cosmetic, a fixed display that always shows 4 scatters
What you need
- Server Seed — revealed after seed rotation (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the spin number in its seed pair (a free spin uses the nonce of the spin that started the bonus)
- Round Index — free spins only: the spin's number in its bonus
- Save the hashed server seed before you play: your saved copy is what proves the timing
- Every spin, every cascade and every free spin can be reproduced from the seeds
- If your recomputed grids and payout match the game, the spin was the committed one
- The first spin of a bought bonus is the one exception: Duel says it is cosmetic, a fixed display that always shows 4 scatters
- Server Seed — revealed after seed rotation (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the spin number in its seed pair (a free spin uses the nonce of the spin that started the bonus)
- Round Index — free spins only: the spin's number in its bonus
Player can access all required inputsPass
Client seed origin transparentPass
crypto.getRandomValues, seen in Duel's live JavaScript (E02); players can set their ownVerification steps documentedPass
SHA-256(hexDecode(serverSeed)), the outcome index, each cascade's stream, the rules and the payoutCasino UI exposes verification panelPass
Independent verifier availablePass
Manual recomputation possiblePass
No hidden or proprietary stepsPass
Only disclosed inputs are used, and identical inputs always give the same grids and payout. Save the hashed seed before you play, so the timing rests on your own record. A bought bonus opens with a fixed spin (always 4 scatters, paying 3×); the free spins that follow verify like any other spin.
- 1
Save the Commitment
Before your first spin on a seed pair, open the Provably Fair panel and copy the hashed server seed. Keep it outside Duel. The panel also shows the next seed's hash before you rotate; save that too and it covers your next seed pair from its first spin.
- 2
Play, Then Rotate
Play your spins. When you're done, rotate the seed pair: that reveals the server seed for every spin you played on it.
- 3
Open a Past Spin
Open the spin from Transactions. Its Verify tab shows the revealed server seed, your client seed and the nonce. A free spin shows the nonce of the spin that started the bonus, and its round index.
- 4
Check and Recompute
Check that SHA-256 of the hex-decoded server seed equals the hash you saved, not one shown after the reveal. Then recompute the spin with the ProvablyFair.org verifier or the scripts below: every cascade grid and the payout.
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
Verify with ProvablyFair.org
Recompute any Groomer's Van spin from its revealed seeds, independently of the casino.
Open independent verifierBuilt-in verification
The operator’s own verification page. This tool is controlled by Duel.com.
Open Duel verifierVerifier Walkthroughstep-by-step
Every spin is fixed by three values before the reels move: your client seed, the server seed and the nonce. The server seed is secret until you rotate, but Duel shows its SHA-256 hash in the Provably Fair panel. Copy that hash before you play and keep it outside Duel: it is your proof the seed was fixed before your spins. The whole spin, the first deal, every cascade and any free spins it triggers, follows from these inputs.
Rotating the seed pair ends it and reveals its server seed. Hash the revealed seed as bytes, not as text: SHA-256(hexDecode(serverSeed)) must equal the hash you saved in Step 1. A match shows the revealed seed is the one behind your saved hash; your saved copy is what shows it came first.
Server Seed (revealed) — the plaintext value committed to before your bet; hash it to confirm it matches the pre-commitment.
Client Seed — your player-controlled entropy input.
Nonce — the sequential bet counter for this seed pair.
With the revealed server seed, your client seed and the nonce, the whole spin is recomputable: one HMAC-SHA256 gives the outcome index, and each cascade draws its 30 cells from its own PCG32 stream. For a free spin, use the nonce of the spin that started the bonus and the round index from its Verify tab (1, 2, 3, … in a triggered bonus; 0, 1, 2, … in a bought one).
If the recomputed grids and payout match what you saw in the game, the spin was the one committed before you played. The ProvablyFair.org verifier does this for you, with no login and no need to trust the casino's tool. The scripts in 6.8 and 6.9 do it on your own machine.
Manual Verification (Advanced)6 sections
6.5Why Manual Verification Matters
True provably fair verification means you don't trust any casino-provided tool. Manual verification allows you to run calculations on your own machine, eliminate any possibility of a tampered verifier, and understand exactly how results are generated.
6.6How the Algorithm Works (Plain English)
Before you play, the server fixes the whole spin with these ingredients:
- The server's secret seed — committed by showing its hash before you bet
- Your client seed — generated in your browser by default, or set by you
- The nonce — a counter that makes each paid spin unique within a seed pair
- The round and cascade numbers — 0 for a base spin's first deal, counting up for each cascade and each free spin
One HMAC-SHA256 over your client seed (hex-encoded) and the nonce, keyed with the server seed's bytes, gives a 32-bit outcome_index. That index is mixed with the round and cascade numbers into a seed for a PCG32 generator, which draws the 30 cells column by column from the published per-reel weights. Any draw that would bias the result is discarded and drawn again. In the bonus, each multiplier on the grid then draws its value from the published weights (2× to 250×). Every cascade starts a fresh stream, and the cells it drops in fill the emptied cells from the top. Because the server committed to its seed before you sent your client seed, it can't change the spin afterwards.
6.7Casino Verifier vs ProvablyFair.org Verifier4 records
Two verification tools are available. Both should give the same result; if they don't, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent (audit codebase) |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| What you enter | Seeds, nonce, round, and each reel's weights as JSON (the page doesn't fill them in) | Seeds and nonce |
| Trust model | Requires trusting the casino | Open-source, version-controlled |
6.8JavaScript Verification Script
Run this in Node.js 18 or later to verify any spin, with no packages. Fill in INPUT from the spin's Verify tab and the hash you saved. It checks the commitment, rebuilds the first deal and every cascade, resolves the clusters, scatters and (in a free spin) multipliers, and prints the total multiplier. We ran it on every non-buy entry in the dataset (6,205): every grid, cascade, multiplier value and total multiplier matches.
// Check one Groomer's Van spin from its seeds. Node.js 18+, no packages needed.// Fill in INPUT from Duel's verify record and the hashed server seed you saved before betting.const crypto = require('crypto'); const INPUT = { savedHash: '1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd', // saved before betting serverSeed: '38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67', // revealed after rotation clientSeed: 'pf_ww6Oka8nm8byd', nonce: 3, // base spin: its nonce. Free spin: the nonce of the spin that started the bonus roundIndex: 0, // base spin: 0. Free spin: round_index from its verify record freeSpin: false, // true for a free spin (bonus-game weights and multipliers)}; // Duel's game config v1.4: per-reel weights, one row per reel, in symbol order.const BASE = { symbols: ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'B'], reels: [[88, 92, 72, 65, 52, 42, 43, 39, 26, 8, 3], [110903, 96200, 62000, 63000, 46000, 42000, 51000, 44000, 17000, 8000, 4900], [734, 839, 520, 540, 460, 230, 470, 310, 351, 122, 55], [64, 77, 52, 41, 31, 29, 42, 45, 27, 8, 5], [82, 72, 74, 51, 52, 42, 63, 28, 31, 8, 5], [480, 412, 360, 300, 265, 135, 320, 276, 62, 80, 18]],};const BONUS = { symbols: ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'M', 'B'], reels: [[143, 72, 79, 86, 33, 45, 50, 31, 20, 5, 14, 3], [4448, 5769, 1840, 3440, 1400, 540, 2960, 1480, 1120, 428, 632, 120], [129, 206, 59, 51, 30, 12, 43, 24, 24, 11, 16, 3], [1349, 1351, 433, 773, 262, 170, 714, 352, 235, 117, 153, 26], [194, 68, 72, 74, 84, 11, 52, 21, 12, 4, 10, 3], [175, 66, 120, 43, 36, 30, 48, 41, 10, 8, 12, 3]],};// Multiplier values: each value repeated by its published weight (200 entries).const MULTS = [[2, 90], [3, 25], [4, 18], [5, 13], [6, 10], [7, 8], [8, 7], [10, 6], [12, 5], [15, 4], [25, 4], [50, 4], [100, 3], [250, 3]].flatMap(([v, w]) => Array(w).fill(v));// Paytable in tenths of the stake for cluster sizes 8, 9, 10, 11, 12+.const PAY = {S1: [4, 4, 6, 7, 20], S2: [5, 6, 7, 10, 25], S3: [6, 7, 9, 12, 30], S4: [7, 9, 12, 15, 40], S5: [10, 12, 15, 20, 50], S6: [15, 16, 22, 28, 70], S7: [18, 22, 28, 35, 90], S8: [25, 35, 45, 55, 140], S9: [50, 60, 80, 100, 250]};const SCATTER_PAY = {4: 30, 5: 50, 6: 1000}; // base game only, tenths of the stakeconst MAX_WIN = 5000; // 1. Commitment: SHA-256 of the 32 seed bytes, not of the hex text.const commitment = seed => crypto.createHash('sha256').update(Buffer.from(seed, 'hex')).digest('hex'); // 2. outcome_index: HMAC-SHA256(key = seed bytes, message = hex(UTF-8 client seed) + ':' + nonce), first 4 bytes.function outcomeIndex(serverSeed, clientSeed, nonce) { const message = Buffer.from(clientSeed, 'utf8').toString('hex') + ':' + nonce; return crypto.createHmac('sha256', Buffer.from(serverSeed, 'hex')).update(message).digest().readUInt32BE(0);} // 3. One PCG32 stream per (round, tumble).function tumbleSeed(oi, round, tumble) { let x = oi >>> 0; x = (x ^ Math.imul(round + 1, 0x9e3779b9)) >>> 0; x = (x ^ Math.imul(tumble + 1, 0x85ebca6b)) >>> 0; x = (x ^ (x >>> 16)) >>> 0; x = Math.imul(x, 0xc2b2ae35) >>> 0; return (x ^ (x >>> 16)) >>> 0;}const M64 = (1n << 64n) - 1n, PCG = 0x5851f42d4c957f2dn;function pcg32(seed32) { let z = (BigInt(seed32) + 0x9e3779b97f4a7c15n) & M64; // SplitMix64 step z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & M64; z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & M64; let state = z ^ (z >> 31n); return () => { const old = state; state = (old * PCG + PCG) & M64; const xs = Number(((old >> 18n) ^ old) >> 27n & 0xffffffffn), rot = Number(old >> 59n); return ((xs >>> rot) | (xs << ((32 - rot) & 31))) >>> 0; };}// 4. A draw below T: discard u >= (2^32 - 1) - ((2^32 - 1) mod T), then u mod T.function draw(next, total) { const limit = 0xffffffff - (0xffffffff % total); let u; do { u = next(); } while (u >= limit); return u % total;}// A fresh 30-cell grid, positions 0-29 column-major (position = reel * 5 + row), then one// value per multiplier cell in position order.function freshGrid(oi, round, tumble, table) { const next = pcg32(tumbleSeed(oi, round, tumble)), cells = []; for (let p = 0; p < 30; p++) { const weights = table.reels[Math.floor(p / 5)]; let v = draw(next, weights.reduce((a, b) => a + b, 0)), i = 0; while (v >= weights[i]) v -= weights[i++]; cells.push({s: table.symbols[i], m: 0}); } for (const c of cells) if (c.s === 'M') c.m = MULTS[draw(next, MULTS.length)]; return cells;} // 5. The spin: clusters pay anywhere (own cells + every wild >= 8, own >= 1). Winning symbols// and all wilds are removed, survivors fall, emptied top cells take the next fresh grid's// cells at the same positions. Stops on the first round with no win.function verifySpin({serverSeed, clientSeed, nonce, roundIndex, freeSpin}) { const table = freeSpin ? BONUS : BASE, oi = outcomeIndex(serverSeed, clientSeed, nonce); let grid = freshGrid(oi, roundIndex, 0, table), tenths = 0; const rounds = []; for (let t = 0; ; t++) { const count = s => grid.filter(c => c.s === s).length, wilds = count('W'); const wins = Object.keys(PAY).filter(s => count(s) >= 1 && count(s) + wilds >= 8) .map(s => ({symbol: s, size: count(s) + wilds, pay: PAY[s][Math.min(count(s) + wilds, 12) - 8]})); rounds.push({grid, wins}); if (!wins.length) break; tenths += wins.reduce((a, w) => a + w.pay, 0); const gone = c => c.s === 'W' || wins.some(w => w.symbol === c.s); const fresh = freshGrid(oi, roundIndex, t + 1, table), next = []; for (let reel = 0; reel < 6; reel++) { const kept = grid.slice(reel * 5, reel * 5 + 5).filter(c => !gone(c)); for (let row = 0; row < 5 - kept.length; row++) next.push(fresh[reel * 5 + row]); next.push(...kept); } grid = next; } const scatters = grid.filter(c => c.s === 'B').length; const bomb = grid.reduce((a, c) => a + c.m, 0); if (freeSpin) tenths = tenths > 0 && bomb > 0 ? tenths * bomb : tenths; else tenths += SCATTER_PAY[Math.min(scatters, 6)] || 0; const awards = freeSpin ? {3: 3, 4: 5, 5: 8, 6: 10} : {3: 8, 4: 10, 5: 12, 6: 14}; return {outcomeIndex: oi, rounds, scatters, bomb, freeSpinsAwarded: awards[Math.min(scatters, 6)] || 0, totalMultiplier: Math.min(tenths / 10, MAX_WIN)};} if (require.main === module) { console.log('Commitment matches saved hash:', commitment(INPUT.serverSeed) === INPUT.savedHash.toLowerCase()); const r = verifySpin(INPUT); console.log('outcome_index:', r.outcomeIndex.toString(16).padStart(8, '0')); r.rounds.forEach(({grid, wins}, t) => { console.log(`\nRound ${t} (rows top to bottom, reels left to right)`); for (let row = 0; row < 5; row++) console.log(' ' + [0, 1, 2, 3, 4, 5].map(reel => { const c = grid[reel * 5 + row]; return (c.s === 'M' ? 'M' + c.m : c.s).padEnd(5); }).join('')); console.log(' ' + (wins.map(w => `${w.symbol} x${w.size} pays ${w.pay / 10}x`).join(', ') || 'no win')); }); console.log(`\nScatters ${r.scatters} · multipliers ${r.bomb} · free spins awarded ${r.freeSpinsAwarded}`); console.log('Total multiplier (x stake):', r.totalMultiplier);} else module.exports = {commitment, outcomeIndex, verifySpin};Output for the example in INPUT, spin 1964428 (served total multiplier 3.5, $0.70 on $0.20):
Commitment matches saved hash: true
outcome_index: f2b48385
Round 0 (rows top to bottom, reels left to right)
S4 S1 S1 S6 S7 S7
S4 S7 S6 S1 S3 S1
S1 S3 S7 W S7 S7
S4 S2 S3 S7 S9 S2
S1 S2 S1 S5 S8 S3
S1 x8 pays 0.4x, S7 x8 pays 1.8x
Round 1 (rows top to bottom, reels left to right)
S3 S8 S3 S8 S1 S5
S6 S1 S3 W S4 S1
S4 S3 S2 S1 S3 S4
S4 S2 S6 S6 S9 S2
S4 S2 S3 S5 S8 S3
S3 x8 pays 0.6x
Round 2 (rows top to bottom, reels left to right)
S1 S4 S6 S3 S8 S4
S6 S8 S4 S8 S1 S5
S4 S1 S7 S1 S4 S1
S4 S2 S2 S6 S9 S4
S4 S2 S6 S5 S8 S2
S4 x8 pays 0.7x
Round 3 (rows top to bottom, reels left to right)
S3 S2 S3 S3 S5 S4
S1 S8 S6 S8 S8 S1
S9 S1 S7 S1 S1 S5
S1 S2 S2 S6 S9 S1
S6 S2 S6 S5 S8 S2
no win
Scatters 0 · multipliers 0 · free spins awarded 0
Total multiplier (x stake): 3.56.9Python Verification Script
The same verification in Python 3 (standard library only). Its output is identical:
# Check one Groomer's Van spin from its seeds. Python 3.8+, standard library only.# Fill in INPUT from Duel's verify record and the hashed server seed you saved before betting.import hashlib, hmac INPUT = { 'saved_hash': '1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd', # saved before betting 'server_seed': '38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67', # revealed after rotation 'client_seed': 'pf_ww6Oka8nm8byd', 'nonce': 3, # base spin: its nonce. Free spin: the nonce of the spin that started the bonus 'round_index': 0, # base spin: 0. Free spin: round_index from its verify record 'free_spin': False, # True for a free spin (bonus-game weights and multipliers)} # Duel's game config v1.4: per-reel weights, one row per reel, in symbol order.BASE = {'symbols': ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'B'], 'reels': [[88, 92, 72, 65, 52, 42, 43, 39, 26, 8, 3], [110903, 96200, 62000, 63000, 46000, 42000, 51000, 44000, 17000, 8000, 4900], [734, 839, 520, 540, 460, 230, 470, 310, 351, 122, 55], [64, 77, 52, 41, 31, 29, 42, 45, 27, 8, 5], [82, 72, 74, 51, 52, 42, 63, 28, 31, 8, 5], [480, 412, 360, 300, 265, 135, 320, 276, 62, 80, 18]]}BONUS = {'symbols': ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'M', 'B'], 'reels': [[143, 72, 79, 86, 33, 45, 50, 31, 20, 5, 14, 3], [4448, 5769, 1840, 3440, 1400, 540, 2960, 1480, 1120, 428, 632, 120], [129, 206, 59, 51, 30, 12, 43, 24, 24, 11, 16, 3], [1349, 1351, 433, 773, 262, 170, 714, 352, 235, 117, 153, 26], [194, 68, 72, 74, 84, 11, 52, 21, 12, 4, 10, 3], [175, 66, 120, 43, 36, 30, 48, 41, 10, 8, 12, 3]]}# Multiplier values: each value repeated by its published weight (200 entries).MULTS = [v for v, w in [(2, 90), (3, 25), (4, 18), (5, 13), (6, 10), (7, 8), (8, 7), (10, 6), (12, 5), (15, 4), (25, 4), (50, 4), (100, 3), (250, 3)] for _ in range(w)]# Paytable in tenths of the stake for cluster sizes 8, 9, 10, 11, 12+.PAY = {'S1': [4, 4, 6, 7, 20], 'S2': [5, 6, 7, 10, 25], 'S3': [6, 7, 9, 12, 30], 'S4': [7, 9, 12, 15, 40], 'S5': [10, 12, 15, 20, 50], 'S6': [15, 16, 22, 28, 70], 'S7': [18, 22, 28, 35, 90], 'S8': [25, 35, 45, 55, 140], 'S9': [50, 60, 80, 100, 250]}SCATTER_PAY = {4: 30, 5: 50, 6: 1000} # base game only, tenths of the stakeMAX_WIN = 5000M32, M64, PCG = 0xFFFFFFFF, (1 << 64) - 1, 0x5851F42D4C957F2D def commitment(seed): """1. SHA-256 of the 32 seed bytes, not of the hex text.""" return hashlib.sha256(bytes.fromhex(seed)).hexdigest() def outcome_index(server_seed, client_seed, nonce): """2. HMAC-SHA256(key = seed bytes, message = hex(UTF-8 client seed) + ':' + nonce), first 4 bytes.""" message = (client_seed.encode('utf-8').hex() + ':' + str(nonce)).encode('ascii') return int.from_bytes(hmac.new(bytes.fromhex(server_seed), message, hashlib.sha256).digest()[:4], 'big') def tumble_seed(oi, rnd, tumble): """3. One PCG32 stream per (round, tumble).""" x = oi ^ (((rnd + 1) * 0x9E3779B9) & M32) x ^= ((tumble + 1) * 0x85EBCA6B) & M32 x ^= x >> 16 x = (x * 0xC2B2AE35) & M32 return x ^ (x >> 16) def pcg32(seed32): z = (seed32 + 0x9E3779B97F4A7C15) & M64 # SplitMix64 step z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & M64 z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & M64 state = z ^ (z >> 31) while True: old, state = state, (state * PCG + PCG) & M64 xs, rot = (((old >> 18) ^ old) >> 27) & M32, old >> 59 yield ((xs >> rot) | (xs << ((32 - rot) & 31))) & M32 def draw(stream, total): """4. A draw below T: discard u >= (2^32 - 1) - ((2^32 - 1) mod T), then u mod T.""" limit = M32 - (M32 % total) u = next(stream) while u >= limit: u = next(stream) return u % total def fresh_grid(oi, rnd, tumble, table): """A fresh 30-cell grid, positions 0-29 column-major (position = reel * 5 + row), then one value per multiplier cell in position order.""" stream, cells = pcg32(tumble_seed(oi, rnd, tumble)), [] for p in range(30): weights = table['reels'][p // 5] v, i = draw(stream, sum(weights)), 0 while v >= weights[i]: v -= weights[i] i += 1 cells.append({'s': table['symbols'][i], 'm': 0}) for c in cells: if c['s'] == 'M': c['m'] = MULTS[draw(stream, len(MULTS))] return cells def verify_spin(server_seed, client_seed, nonce, round_index, free_spin, **_): """5. The spin: clusters pay anywhere (own cells + every wild >= 8, own >= 1). Winning symbols and all wilds are removed, survivors fall, emptied top cells take the next fresh grid's cells at the same positions. Stops on the first round with no win.""" table = BONUS if free_spin else BASE oi = outcome_index(server_seed, client_seed, nonce) grid, tenths, rounds, t = fresh_grid(oi, round_index, 0, table), 0, [], 0 while True: count = {s: sum(c['s'] == s for c in grid) for s in table['symbols']} wins = [{'symbol': s, 'size': count[s] + count['W'], 'pay': PAY[s][min(count[s] + count['W'], 12) - 8]} for s in PAY if count[s] >= 1 and count[s] + count['W'] >= 8] rounds.append({'grid': grid, 'wins': wins}) if not wins: break tenths += sum(w['pay'] for w in wins) gone = {'W'} | {w['symbol'] for w in wins} fresh, nxt = fresh_grid(oi, round_index, t + 1, table), [] for reel in range(6): kept = [c for c in grid[reel * 5:reel * 5 + 5] if c['s'] not in gone] nxt += fresh[reel * 5:reel * 5 + 5 - len(kept)] + kept grid, t = nxt, t + 1 scatters = sum(c['s'] == 'B' for c in grid) bomb = sum(c['m'] for c in grid) if free_spin: tenths = tenths * bomb if tenths > 0 and bomb > 0 else tenths else: tenths += SCATTER_PAY.get(min(scatters, 6), 0) awards = {3: 3, 4: 5, 5: 8, 6: 10} if free_spin else {3: 8, 4: 10, 5: 12, 6: 14} return {'outcome_index': oi, 'rounds': rounds, 'scatters': scatters, 'bomb': bomb, 'free_spins_awarded': awards.get(min(scatters, 6), 0), 'total_multiplier': min(tenths / 10, MAX_WIN)} if __name__ == '__main__': print('Commitment matches saved hash:', str(commitment(INPUT['server_seed']) == INPUT['saved_hash'].lower()).lower()) r = verify_spin(**INPUT) print('outcome_index:', format(r['outcome_index'], '08x')) for t, rnd in enumerate(r['rounds']): print(f'\nRound {t} (rows top to bottom, reels left to right)') for row in range(5): cells = [rnd['grid'][reel * 5 + row] for reel in range(6)] print(' ' + ''.join((f"M{c['m']}" if c['s'] == 'M' else c['s']).ljust(5) for c in cells)) print(' ' + (', '.join(f"{w['symbol']} x{w['size']} pays {w['pay'] / 10}x" for w in rnd['wins']) or 'no win')) print(f"\nScatters {r['scatters']} · multipliers {r['bomb']} · free spins awarded {r['free_spins_awarded']}") print('Total multiplier (x stake):', r['total_multiplier'])6.10Bonus Session Worked Example11 records
A bonus is a run of free spins, each its own spin with its own cascades. Every free spin uses the nonce of the spin that started the bonus and its own round index: 1, 2, 3, … in a triggered bonus (the trigger spin is round 0), 0, 1, 2, … in a bought one. Multipliers that land during a free spin stay through its cascades; when it settles, their values are added up and multiply that spin's cluster win. The next free spin starts from a fresh grid.
Example: spin 1976266 (Phase A, $0.20, nonce 5) landed 4 scatters, paid the 4-scatter 3× ($0.60) and started 10 free spins:
serverSeed = a81baf3e7dee56be7fca67da83a809eabe5423e5b2a44bc66762b3500080b9a8
clientSeed = pf_r3UgUo9TKL8ea
nonce = 5 (every free spin of this bonus)
roundIndex = 1 … 10 (one per free spin)
trigger = 4 scatters → 10 free spins, scatter pay $0.60
free spins = $7.62 in total| Free spin | Spin id | Cascades | Multiplier total | Won |
|---|---|---|---|---|
| 1 | 1976271 | 1 | 3 | $1.02 |
| 2 | 1976276 | 1 | 4 | $0.48 |
| 3 | 1976282 | 0 | 25 (no win) | $0.00 |
| 4 | 1976287 | 2 | 5 | $1.20 |
| 5 | 1976292 | 1 | 0 (counts as 1) | $0.08 |
| 6 | 1976296 | 3 | 6 | $1.92 |
| 7 | 1976298 | 1 | 6 | $0.48 |
| 8 | 1976301 | 2 | 2 | $0.48 |
| 9 | 1976304 | 2 | 4 | $0.88 |
| 10 | 1976305 | 2 | 6 | $1.08 |
| Total | $7.62 |
Σ cluster pay × max(multiplier total, 1), and the totals differ spin to spin: they don't carry over. Across all 53 captured bonuses, 475 / 475 free spins reconcile this way (Step 26), and Step 5 checks each one's nonce and round index. For a bought bonus, the buy spin itself can't be recomputed; its 10 free spins can, at the buy's nonce with round index 0–9.Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
How it works
- 1
Save the Commitment
Before your first spin on a seed pair, open the Provably Fair panel and copy the hashed server seed. Keep it outside Duel. The panel also shows the next seed's hash before you rotate; save that too and it covers your next seed pair from its first spin.
- 2
Play, Then Rotate
Play your spins. When you're done, rotate the seed pair: that reveals the server seed for every spin you played on it.
- 3
Open a Past Spin
Open the spin from Transactions. Its Verify tab shows the revealed server seed, your client seed and the nonce. A free spin shows the nonce of the spin that started the bonus, and its round index.
- 4
Check and Recompute
Check that SHA-256 of the hex-decoded server seed equals the hash you saved, not one shown after the reveal. Then recompute the spin with the ProvablyFair.org verifier or the scripts below: every cascade grid and the payout.
Verifier Walkthroughstep-by-step
Every spin is fixed by three values before the reels move: your client seed, the server seed and the nonce. The server seed is secret until you rotate, but Duel shows its SHA-256 hash in the Provably Fair panel. Copy that hash before you play and keep it outside Duel: it is your proof the seed was fixed before your spins. The whole spin, the first deal, every cascade and any free spins it triggers, follows from these inputs.
Rotating the seed pair ends it and reveals its server seed. Hash the revealed seed as bytes, not as text: SHA-256(hexDecode(serverSeed)) must equal the hash you saved in Step 1. A match shows the revealed seed is the one behind your saved hash; your saved copy is what shows it came first.
Server Seed (revealed) — the plaintext value committed to before your bet; hash it to confirm it matches the pre-commitment.
Client Seed — your player-controlled entropy input.
Nonce — the sequential bet counter for this seed pair.
With the revealed server seed, your client seed and the nonce, the whole spin is recomputable: one HMAC-SHA256 gives the outcome index, and each cascade draws its 30 cells from its own PCG32 stream. For a free spin, use the nonce of the spin that started the bonus and the round index from its Verify tab (1, 2, 3, … in a triggered bonus; 0, 1, 2, … in a bought one).
If the recomputed grids and payout match what you saw in the game, the spin was the one committed before you played. The ProvablyFair.org verifier does this for you, with no login and no need to trust the casino's tool. The scripts in 6.8 and 6.9 do it on your own machine.
Technical evidence
6.5Why Manual Verification Matters
True provably fair verification means you don't trust any casino-provided tool. Manual verification allows you to run calculations on your own machine, eliminate any possibility of a tampered verifier, and understand exactly how results are generated.
6.6How the Algorithm Works (Plain English)
Before you play, the server fixes the whole spin with these ingredients:
- The server's secret seed — committed by showing its hash before you bet
- Your client seed — generated in your browser by default, or set by you
- The nonce — a counter that makes each paid spin unique within a seed pair
- The round and cascade numbers — 0 for a base spin's first deal, counting up for each cascade and each free spin
One HMAC-SHA256 over your client seed (hex-encoded) and the nonce, keyed with the server seed's bytes, gives a 32-bit outcome_index. That index is mixed with the round and cascade numbers into a seed for a PCG32 generator, which draws the 30 cells column by column from the published per-reel weights. Any draw that would bias the result is discarded and drawn again. In the bonus, each multiplier on the grid then draws its value from the published weights (2× to 250×). Every cascade starts a fresh stream, and the cells it drops in fill the emptied cells from the top. Because the server committed to its seed before you sent your client seed, it can't change the spin afterwards.
6.7Casino Verifier vs ProvablyFair.org Verifier4 records
Two verification tools are available. Both should give the same result; if they don't, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | Independent (audit codebase) |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| What you enter | Seeds, nonce, round, and each reel's weights as JSON (the page doesn't fill them in) | Seeds and nonce |
| Trust model | Requires trusting the casino | Open-source, version-controlled |
6.8JavaScript Verification Script
Run this in Node.js 18 or later to verify any spin, with no packages. Fill in INPUT from the spin's Verify tab and the hash you saved. It checks the commitment, rebuilds the first deal and every cascade, resolves the clusters, scatters and (in a free spin) multipliers, and prints the total multiplier. We ran it on every non-buy entry in the dataset (6,205): every grid, cascade, multiplier value and total multiplier matches.
// Check one Groomer's Van spin from its seeds. Node.js 18+, no packages needed.// Fill in INPUT from Duel's verify record and the hashed server seed you saved before betting.const crypto = require('crypto'); const INPUT = { savedHash: '1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd', // saved before betting serverSeed: '38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67', // revealed after rotation clientSeed: 'pf_ww6Oka8nm8byd', nonce: 3, // base spin: its nonce. Free spin: the nonce of the spin that started the bonus roundIndex: 0, // base spin: 0. Free spin: round_index from its verify record freeSpin: false, // true for a free spin (bonus-game weights and multipliers)}; // Duel's game config v1.4: per-reel weights, one row per reel, in symbol order.const BASE = { symbols: ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'B'], reels: [[88, 92, 72, 65, 52, 42, 43, 39, 26, 8, 3], [110903, 96200, 62000, 63000, 46000, 42000, 51000, 44000, 17000, 8000, 4900], [734, 839, 520, 540, 460, 230, 470, 310, 351, 122, 55], [64, 77, 52, 41, 31, 29, 42, 45, 27, 8, 5], [82, 72, 74, 51, 52, 42, 63, 28, 31, 8, 5], [480, 412, 360, 300, 265, 135, 320, 276, 62, 80, 18]],};const BONUS = { symbols: ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'M', 'B'], reels: [[143, 72, 79, 86, 33, 45, 50, 31, 20, 5, 14, 3], [4448, 5769, 1840, 3440, 1400, 540, 2960, 1480, 1120, 428, 632, 120], [129, 206, 59, 51, 30, 12, 43, 24, 24, 11, 16, 3], [1349, 1351, 433, 773, 262, 170, 714, 352, 235, 117, 153, 26], [194, 68, 72, 74, 84, 11, 52, 21, 12, 4, 10, 3], [175, 66, 120, 43, 36, 30, 48, 41, 10, 8, 12, 3]],};// Multiplier values: each value repeated by its published weight (200 entries).const MULTS = [[2, 90], [3, 25], [4, 18], [5, 13], [6, 10], [7, 8], [8, 7], [10, 6], [12, 5], [15, 4], [25, 4], [50, 4], [100, 3], [250, 3]].flatMap(([v, w]) => Array(w).fill(v));// Paytable in tenths of the stake for cluster sizes 8, 9, 10, 11, 12+.const PAY = {S1: [4, 4, 6, 7, 20], S2: [5, 6, 7, 10, 25], S3: [6, 7, 9, 12, 30], S4: [7, 9, 12, 15, 40], S5: [10, 12, 15, 20, 50], S6: [15, 16, 22, 28, 70], S7: [18, 22, 28, 35, 90], S8: [25, 35, 45, 55, 140], S9: [50, 60, 80, 100, 250]};const SCATTER_PAY = {4: 30, 5: 50, 6: 1000}; // base game only, tenths of the stakeconst MAX_WIN = 5000; // 1. Commitment: SHA-256 of the 32 seed bytes, not of the hex text.const commitment = seed => crypto.createHash('sha256').update(Buffer.from(seed, 'hex')).digest('hex'); // 2. outcome_index: HMAC-SHA256(key = seed bytes, message = hex(UTF-8 client seed) + ':' + nonce), first 4 bytes.function outcomeIndex(serverSeed, clientSeed, nonce) { const message = Buffer.from(clientSeed, 'utf8').toString('hex') + ':' + nonce; return crypto.createHmac('sha256', Buffer.from(serverSeed, 'hex')).update(message).digest().readUInt32BE(0);} // 3. One PCG32 stream per (round, tumble).function tumbleSeed(oi, round, tumble) { let x = oi >>> 0; x = (x ^ Math.imul(round + 1, 0x9e3779b9)) >>> 0; x = (x ^ Math.imul(tumble + 1, 0x85ebca6b)) >>> 0; x = (x ^ (x >>> 16)) >>> 0; x = Math.imul(x, 0xc2b2ae35) >>> 0; return (x ^ (x >>> 16)) >>> 0;}const M64 = (1n << 64n) - 1n, PCG = 0x5851f42d4c957f2dn;function pcg32(seed32) { let z = (BigInt(seed32) + 0x9e3779b97f4a7c15n) & M64; // SplitMix64 step z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & M64; z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & M64; let state = z ^ (z >> 31n); return () => { const old = state; state = (old * PCG + PCG) & M64; const xs = Number(((old >> 18n) ^ old) >> 27n & 0xffffffffn), rot = Number(old >> 59n); return ((xs >>> rot) | (xs << ((32 - rot) & 31))) >>> 0; };}// 4. A draw below T: discard u >= (2^32 - 1) - ((2^32 - 1) mod T), then u mod T.function draw(next, total) { const limit = 0xffffffff - (0xffffffff % total); let u; do { u = next(); } while (u >= limit); return u % total;}// A fresh 30-cell grid, positions 0-29 column-major (position = reel * 5 + row), then one// value per multiplier cell in position order.function freshGrid(oi, round, tumble, table) { const next = pcg32(tumbleSeed(oi, round, tumble)), cells = []; for (let p = 0; p < 30; p++) { const weights = table.reels[Math.floor(p / 5)]; let v = draw(next, weights.reduce((a, b) => a + b, 0)), i = 0; while (v >= weights[i]) v -= weights[i++]; cells.push({s: table.symbols[i], m: 0}); } for (const c of cells) if (c.s === 'M') c.m = MULTS[draw(next, MULTS.length)]; return cells;} // 5. The spin: clusters pay anywhere (own cells + every wild >= 8, own >= 1). Winning symbols// and all wilds are removed, survivors fall, emptied top cells take the next fresh grid's// cells at the same positions. Stops on the first round with no win.function verifySpin({serverSeed, clientSeed, nonce, roundIndex, freeSpin}) { const table = freeSpin ? BONUS : BASE, oi = outcomeIndex(serverSeed, clientSeed, nonce); let grid = freshGrid(oi, roundIndex, 0, table), tenths = 0; const rounds = []; for (let t = 0; ; t++) { const count = s => grid.filter(c => c.s === s).length, wilds = count('W'); const wins = Object.keys(PAY).filter(s => count(s) >= 1 && count(s) + wilds >= 8) .map(s => ({symbol: s, size: count(s) + wilds, pay: PAY[s][Math.min(count(s) + wilds, 12) - 8]})); rounds.push({grid, wins}); if (!wins.length) break; tenths += wins.reduce((a, w) => a + w.pay, 0); const gone = c => c.s === 'W' || wins.some(w => w.symbol === c.s); const fresh = freshGrid(oi, roundIndex, t + 1, table), next = []; for (let reel = 0; reel < 6; reel++) { const kept = grid.slice(reel * 5, reel * 5 + 5).filter(c => !gone(c)); for (let row = 0; row < 5 - kept.length; row++) next.push(fresh[reel * 5 + row]); next.push(...kept); } grid = next; } const scatters = grid.filter(c => c.s === 'B').length; const bomb = grid.reduce((a, c) => a + c.m, 0); if (freeSpin) tenths = tenths > 0 && bomb > 0 ? tenths * bomb : tenths; else tenths += SCATTER_PAY[Math.min(scatters, 6)] || 0; const awards = freeSpin ? {3: 3, 4: 5, 5: 8, 6: 10} : {3: 8, 4: 10, 5: 12, 6: 14}; return {outcomeIndex: oi, rounds, scatters, bomb, freeSpinsAwarded: awards[Math.min(scatters, 6)] || 0, totalMultiplier: Math.min(tenths / 10, MAX_WIN)};} if (require.main === module) { console.log('Commitment matches saved hash:', commitment(INPUT.serverSeed) === INPUT.savedHash.toLowerCase()); const r = verifySpin(INPUT); console.log('outcome_index:', r.outcomeIndex.toString(16).padStart(8, '0')); r.rounds.forEach(({grid, wins}, t) => { console.log(`\nRound ${t} (rows top to bottom, reels left to right)`); for (let row = 0; row < 5; row++) console.log(' ' + [0, 1, 2, 3, 4, 5].map(reel => { const c = grid[reel * 5 + row]; return (c.s === 'M' ? 'M' + c.m : c.s).padEnd(5); }).join('')); console.log(' ' + (wins.map(w => `${w.symbol} x${w.size} pays ${w.pay / 10}x`).join(', ') || 'no win')); }); console.log(`\nScatters ${r.scatters} · multipliers ${r.bomb} · free spins awarded ${r.freeSpinsAwarded}`); console.log('Total multiplier (x stake):', r.totalMultiplier);} else module.exports = {commitment, outcomeIndex, verifySpin};Output for the example in INPUT, spin 1964428 (served total multiplier 3.5, $0.70 on $0.20):
Commitment matches saved hash: true
outcome_index: f2b48385
Round 0 (rows top to bottom, reels left to right)
S4 S1 S1 S6 S7 S7
S4 S7 S6 S1 S3 S1
S1 S3 S7 W S7 S7
S4 S2 S3 S7 S9 S2
S1 S2 S1 S5 S8 S3
S1 x8 pays 0.4x, S7 x8 pays 1.8x
Round 1 (rows top to bottom, reels left to right)
S3 S8 S3 S8 S1 S5
S6 S1 S3 W S4 S1
S4 S3 S2 S1 S3 S4
S4 S2 S6 S6 S9 S2
S4 S2 S3 S5 S8 S3
S3 x8 pays 0.6x
Round 2 (rows top to bottom, reels left to right)
S1 S4 S6 S3 S8 S4
S6 S8 S4 S8 S1 S5
S4 S1 S7 S1 S4 S1
S4 S2 S2 S6 S9 S4
S4 S2 S6 S5 S8 S2
S4 x8 pays 0.7x
Round 3 (rows top to bottom, reels left to right)
S3 S2 S3 S3 S5 S4
S1 S8 S6 S8 S8 S1
S9 S1 S7 S1 S1 S5
S1 S2 S2 S6 S9 S1
S6 S2 S6 S5 S8 S2
no win
Scatters 0 · multipliers 0 · free spins awarded 0
Total multiplier (x stake): 3.56.9Python Verification Script
The same verification in Python 3 (standard library only). Its output is identical:
# Check one Groomer's Van spin from its seeds. Python 3.8+, standard library only.# Fill in INPUT from Duel's verify record and the hashed server seed you saved before betting.import hashlib, hmac INPUT = { 'saved_hash': '1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd', # saved before betting 'server_seed': '38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67', # revealed after rotation 'client_seed': 'pf_ww6Oka8nm8byd', 'nonce': 3, # base spin: its nonce. Free spin: the nonce of the spin that started the bonus 'round_index': 0, # base spin: 0. Free spin: round_index from its verify record 'free_spin': False, # True for a free spin (bonus-game weights and multipliers)} # Duel's game config v1.4: per-reel weights, one row per reel, in symbol order.BASE = {'symbols': ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'B'], 'reels': [[88, 92, 72, 65, 52, 42, 43, 39, 26, 8, 3], [110903, 96200, 62000, 63000, 46000, 42000, 51000, 44000, 17000, 8000, 4900], [734, 839, 520, 540, 460, 230, 470, 310, 351, 122, 55], [64, 77, 52, 41, 31, 29, 42, 45, 27, 8, 5], [82, 72, 74, 51, 52, 42, 63, 28, 31, 8, 5], [480, 412, 360, 300, 265, 135, 320, 276, 62, 80, 18]]}BONUS = {'symbols': ['S1', 'S2', 'S3', 'S4', 'S5', 'S6', 'S7', 'S8', 'S9', 'W', 'M', 'B'], 'reels': [[143, 72, 79, 86, 33, 45, 50, 31, 20, 5, 14, 3], [4448, 5769, 1840, 3440, 1400, 540, 2960, 1480, 1120, 428, 632, 120], [129, 206, 59, 51, 30, 12, 43, 24, 24, 11, 16, 3], [1349, 1351, 433, 773, 262, 170, 714, 352, 235, 117, 153, 26], [194, 68, 72, 74, 84, 11, 52, 21, 12, 4, 10, 3], [175, 66, 120, 43, 36, 30, 48, 41, 10, 8, 12, 3]]}# Multiplier values: each value repeated by its published weight (200 entries).MULTS = [v for v, w in [(2, 90), (3, 25), (4, 18), (5, 13), (6, 10), (7, 8), (8, 7), (10, 6), (12, 5), (15, 4), (25, 4), (50, 4), (100, 3), (250, 3)] for _ in range(w)]# Paytable in tenths of the stake for cluster sizes 8, 9, 10, 11, 12+.PAY = {'S1': [4, 4, 6, 7, 20], 'S2': [5, 6, 7, 10, 25], 'S3': [6, 7, 9, 12, 30], 'S4': [7, 9, 12, 15, 40], 'S5': [10, 12, 15, 20, 50], 'S6': [15, 16, 22, 28, 70], 'S7': [18, 22, 28, 35, 90], 'S8': [25, 35, 45, 55, 140], 'S9': [50, 60, 80, 100, 250]}SCATTER_PAY = {4: 30, 5: 50, 6: 1000} # base game only, tenths of the stakeMAX_WIN = 5000M32, M64, PCG = 0xFFFFFFFF, (1 << 64) - 1, 0x5851F42D4C957F2D def commitment(seed): """1. SHA-256 of the 32 seed bytes, not of the hex text.""" return hashlib.sha256(bytes.fromhex(seed)).hexdigest() def outcome_index(server_seed, client_seed, nonce): """2. HMAC-SHA256(key = seed bytes, message = hex(UTF-8 client seed) + ':' + nonce), first 4 bytes.""" message = (client_seed.encode('utf-8').hex() + ':' + str(nonce)).encode('ascii') return int.from_bytes(hmac.new(bytes.fromhex(server_seed), message, hashlib.sha256).digest()[:4], 'big') def tumble_seed(oi, rnd, tumble): """3. One PCG32 stream per (round, tumble).""" x = oi ^ (((rnd + 1) * 0x9E3779B9) & M32) x ^= ((tumble + 1) * 0x85EBCA6B) & M32 x ^= x >> 16 x = (x * 0xC2B2AE35) & M32 return x ^ (x >> 16) def pcg32(seed32): z = (seed32 + 0x9E3779B97F4A7C15) & M64 # SplitMix64 step z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & M64 z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & M64 state = z ^ (z >> 31) while True: old, state = state, (state * PCG + PCG) & M64 xs, rot = (((old >> 18) ^ old) >> 27) & M32, old >> 59 yield ((xs >> rot) | (xs << ((32 - rot) & 31))) & M32 def draw(stream, total): """4. A draw below T: discard u >= (2^32 - 1) - ((2^32 - 1) mod T), then u mod T.""" limit = M32 - (M32 % total) u = next(stream) while u >= limit: u = next(stream) return u % total def fresh_grid(oi, rnd, tumble, table): """A fresh 30-cell grid, positions 0-29 column-major (position = reel * 5 + row), then one value per multiplier cell in position order.""" stream, cells = pcg32(tumble_seed(oi, rnd, tumble)), [] for p in range(30): weights = table['reels'][p // 5] v, i = draw(stream, sum(weights)), 0 while v >= weights[i]: v -= weights[i] i += 1 cells.append({'s': table['symbols'][i], 'm': 0}) for c in cells: if c['s'] == 'M': c['m'] = MULTS[draw(stream, len(MULTS))] return cells def verify_spin(server_seed, client_seed, nonce, round_index, free_spin, **_): """5. The spin: clusters pay anywhere (own cells + every wild >= 8, own >= 1). Winning symbols and all wilds are removed, survivors fall, emptied top cells take the next fresh grid's cells at the same positions. Stops on the first round with no win.""" table = BONUS if free_spin else BASE oi = outcome_index(server_seed, client_seed, nonce) grid, tenths, rounds, t = fresh_grid(oi, round_index, 0, table), 0, [], 0 while True: count = {s: sum(c['s'] == s for c in grid) for s in table['symbols']} wins = [{'symbol': s, 'size': count[s] + count['W'], 'pay': PAY[s][min(count[s] + count['W'], 12) - 8]} for s in PAY if count[s] >= 1 and count[s] + count['W'] >= 8] rounds.append({'grid': grid, 'wins': wins}) if not wins: break tenths += sum(w['pay'] for w in wins) gone = {'W'} | {w['symbol'] for w in wins} fresh, nxt = fresh_grid(oi, round_index, t + 1, table), [] for reel in range(6): kept = [c for c in grid[reel * 5:reel * 5 + 5] if c['s'] not in gone] nxt += fresh[reel * 5:reel * 5 + 5 - len(kept)] + kept grid, t = nxt, t + 1 scatters = sum(c['s'] == 'B' for c in grid) bomb = sum(c['m'] for c in grid) if free_spin: tenths = tenths * bomb if tenths > 0 and bomb > 0 else tenths else: tenths += SCATTER_PAY.get(min(scatters, 6), 0) awards = {3: 3, 4: 5, 5: 8, 6: 10} if free_spin else {3: 8, 4: 10, 5: 12, 6: 14} return {'outcome_index': oi, 'rounds': rounds, 'scatters': scatters, 'bomb': bomb, 'free_spins_awarded': awards.get(min(scatters, 6), 0), 'total_multiplier': min(tenths / 10, MAX_WIN)} if __name__ == '__main__': print('Commitment matches saved hash:', str(commitment(INPUT['server_seed']) == INPUT['saved_hash'].lower()).lower()) r = verify_spin(**INPUT) print('outcome_index:', format(r['outcome_index'], '08x')) for t, rnd in enumerate(r['rounds']): print(f'\nRound {t} (rows top to bottom, reels left to right)') for row in range(5): cells = [rnd['grid'][reel * 5 + row] for reel in range(6)] print(' ' + ''.join((f"M{c['m']}" if c['s'] == 'M' else c['s']).ljust(5) for c in cells)) print(' ' + (', '.join(f"{w['symbol']} x{w['size']} pays {w['pay'] / 10}x" for w in rnd['wins']) or 'no win')) print(f"\nScatters {r['scatters']} · multipliers {r['bomb']} · free spins awarded {r['free_spins_awarded']}") print('Total multiplier (x stake):', r['total_multiplier'])6.10Bonus Session Worked Example11 records
A bonus is a run of free spins, each its own spin with its own cascades. Every free spin uses the nonce of the spin that started the bonus and its own round index: 1, 2, 3, … in a triggered bonus (the trigger spin is round 0), 0, 1, 2, … in a bought one. Multipliers that land during a free spin stay through its cascades; when it settles, their values are added up and multiply that spin's cluster win. The next free spin starts from a fresh grid.
Example: spin 1976266 (Phase A, $0.20, nonce 5) landed 4 scatters, paid the 4-scatter 3× ($0.60) and started 10 free spins:
serverSeed = a81baf3e7dee56be7fca67da83a809eabe5423e5b2a44bc66762b3500080b9a8
clientSeed = pf_r3UgUo9TKL8ea
nonce = 5 (every free spin of this bonus)
roundIndex = 1 … 10 (one per free spin)
trigger = 4 scatters → 10 free spins, scatter pay $0.60
free spins = $7.62 in total| Free spin | Spin id | Cascades | Multiplier total | Won |
|---|---|---|---|---|
| 1 | 1976271 | 1 | 3 | $1.02 |
| 2 | 1976276 | 1 | 4 | $0.48 |
| 3 | 1976282 | 0 | 25 (no win) | $0.00 |
| 4 | 1976287 | 2 | 5 | $1.20 |
| 5 | 1976292 | 1 | 0 (counts as 1) | $0.08 |
| 6 | 1976296 | 3 | 6 | $1.92 |
| 7 | 1976298 | 1 | 6 | $0.48 |
| 8 | 1976301 | 2 | 2 | $0.48 |
| 9 | 1976304 | 2 | 4 | $0.88 |
| 10 | 1976305 | 2 | 6 | $1.08 |
| Total | $7.62 |
Σ cluster pay × max(multiplier total, 1), and the totals differ spin to spin: they don't carry over. Across all 53 captured bonuses, 475 / 475 free spins reconcile this way (Step 26), and Step 5 checks each one's nonce and round index. For a bought bonus, the buy spin itself can't be recomputed; its 10 free spins can, at the buy's nonce with round index 0–9.Only disclosed inputs are used, and identical inputs always give the same grids and payout. Save the hashed seed before you play, so the timing rests on your own record. A bought bonus opens with a fixed spin (always 4 scatters, paying 3×); the free spins that follow verify like any other spin.
Reproducibility & Artifacts
Can anyone independently reproduce every finding in this audit?
This section covers the repository, the release tag, the commands and the reproduction gate. Every finding, statistic and pass/fail result can be reproduced by anyone with a computer. The repository is the credential, not this report.
Repository Details
- GitHub: ProvablyFair-org/duel-groomers-van
- Release: v1.2.1 · Framework 1.1
- Original audit: 6f9bfaf · June 2026
- Public Verifier: provablyfair.org/verify-bets/duel
Prerequisites
- Node.js 22.x (
.nvmrc) - npm
- Git
- GitHub: ProvablyFair-org/duel-groomers-van
- Release: v1.2.1 · Framework 1.1
- Original audit: 6f9bfaf · June 2026
- Public Verifier: provablyfair.org/verify-bets/duel
- Node.js 22.x (
.nvmrc) - npm
- Git
npm test at release v1.2.1 reproduces the committed results: 34 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, exit 0. Runs write to outputs/run/ and never overwrite the evidence of record.
Commands to Reproduce
npm test runs the 21 unit tests, then the 35 scored steps against the captured dataset, then the reproduction gate. It doesn't rerun the simulation; npm run test:full does.
The scored steps on their own; below, the summary line each step prints. Results go to outputs/run/, never over the committed evidence.
30,000,000 base spins with integrated triggers and sessions (132,222 bonus sessions) on the pinned master seed pf-audit-groomers-van-v1, then the Pass 2 forward replay. Tens of minutes. Writes to outputs/run/; npm run test:full compares it with the pinned artifact.
Every one of the 2³² outcome indexes, base and bonus, on the CPU: hours (about 4.4 h on a 20-thread desktop CPU). The CUDA path, npm run enumerate:cuda, produced the committed artifacts in under two minutes on an RTX 5060. Then the exact session convolutions. npm test checks the committed artifacts against their pins either way.
Audit Reproducibility Pinning
- Release
v1.2.1(Framework 1.1)- Original audit
6f9bfaf3e9db8b139378b571a60f1095df9c8d69(4 June 2026)- Node Version
- 22.x (
.nvmrc,package.jsonengines) - Dataset
- data/groomers-van-smoke-test-1778204681017.json.gz (6,225 entries, 117 seed records)
- Dataset Hash (SHA-256)
- 3034cb1284bc1a87d82a0d8f914b19d7f1a8f16894ffe601242bd29e3873b967
- Game Config Hash (SHA-256)
- e08f41da9a1d2ab4a634e3f14dc2d52858520dc9620c327599cac1e5c09c2b87 (config v1.4)
- Paytable Hash (SHA-256)
- c3479bf62ee9ed45896506db8972a9b338b693345db47633687af440b27ffcd1 (/rules)
- Simulation Seed
- pf-audit-groomers-van-v1 (HMAC-SHA256 → PCG32 seed)
- Capture
- 7–8 May 2026
- Audit ID
- PF-2026-DL10
Output ArtifactsCommitted evidence of record
| File | Contents | Size |
|---|---|---|
| verification-results.json | All 35 step results, profile coverage, verdict | ~74KB |
| base-2pow32.json · bonus-2pow32.json | The 2³² per-spin distributions (base and bonus) the headline RTP comes from | ~27KB · ~712KB |
| bonus-2pow32-uncapped.json | The bonus 2³² without the 5,000× per-spin cap (cap check) | ~715KB |
| cpu-base-2pow32.json · cpu-bonus-2pow32.json | The CPU re-enumerations used for the CPU ↔ CUDA parity check | ~27KB · ~712KB |
| bonus-session-ev-exact-{8,10,12,14}.json | Exact session EV for each starting count: 97.5997×, 121.9996×, 146.3995×, 170.7994× | ~2.6MB each |
| rtp-claim-table.json | RTP claim, the one setting and the outcome (PASS) | ~1.6KB |
| simulation-results.json | Pass 1 (30M spins, χ², serial tests, 100.06%) and Pass 2 (aggregate z, forward replay) | ~59KB |
| rtp-convergence.html | Self-contained convergence chart of the 30M Pass 1 run | ~206KB |
| bonus-session-ev.json | An earlier 10M-session Monte Carlo of the bought session, kept for reference | ~103KB |
Repository Structure
duel-groomers-van/ (release v1.2.1) ├── src/ │ ├── rng.ts → HMAC-SHA256 → outcome_index → tumble seed → PCG32 → 30-cell grid, written from docs/ALGORITHM.md │ ├── cluster.ts → Counted clusters with wilds, scatter count │ ├── paytable.ts → Published paytable, reel weights and multiplier weights │ ├── tumble.ts → Cluster resolution for one cascade round │ ├── bias.ts → The Step 5 draw-bias bound │ ├── enumerate-mt.ts → Exhaustive 2³² per-spin enumeration (CPU, multi-threaded) │ ├── session-ev-exact.ts → Exact bonus-session EV by dense-lane convolution │ ├── simulate.ts → Monte Carlo: 30M base spins (Pass 1) and the Pass 2 forward replay │ ├── stats.ts → χ², lag-1 autocorrelation, runs test, Bonferroni │ ├── loader.ts → Dataset loader, SHA-256 guard, capture plan and populations │ ├── rtp-claim.ts → Framework rule RTP-CLAIM 1.2.0 │ ├── rtp-settings.ts → The claim and the RTP table for this package │ ├── operator-verifier.ts → Runs Duel's Verify-tab code unmodified (cross-check) │ ├── site-verifier.ts → Loads the pinned ProvablyFair.org verifier code │ ├── artifact-pins.ts → SHA-256 pins for the artifacts of record │ ├── profile-map.ts → Step → Groomer's Van profile check (GROOMERS-01 … 30) │ └── diff.ts, types.ts, rtp-claim-switch.ts, enumerate.ts, session-ev.ts, theoretical.ts, … ├── tests/ │ ├── verify.ts → 35 scored steps + the reproduction gate │ ├── steps/ → commitment, determinism, payouts, dataset, simulation, │ │ game-specific, enumeration, artifacts, max-win, live-fit │ ├── groomers-van/ → Mocha unit tests (incl. the specification's own 166 checks) │ └── mutations.json → Mutation battery registry ├── docs/ALGORITHM.md, INTERFACE.md → The written specification and module interface ├── data/ │ ├── groomers-van-smoke-test-1778204681017.json.gz → 6,225 entries, 117 seed records │ └── raw/ → Duel's config v1.4, the /rules paytable, the help-panel paytable, 5 Oct 2026 fetch ├── cuda/ → GPU 2³² enumerator ├── evidence/ → Screenshots, Duel's Verify-tab code (E04) ├── verifier-parity/ → Pinned copies of the ProvablyFair.org verifier and the operator runner ├── capture/capture.reference.js → Non-runnable reference record of the capture script ├── outputs/ → Committed evidence of record (runs write to outputs/run/) ├── scripts/ → mutate.mjs, release-manifest.mjs, CUDA build and parity ├── RELEASE-MANIFEST.json → Release identity, artifact hashes, verdict, signature ├── MANIFEST.md → Consolidated audit overview ├── README.md └── package.json, package-lock.json, .nvmrc (Node 22.x), LICENSE (MIT)
Step-to-Section Cross-Reference35 verification steps mapped
| Step | Test Name | Report Section |
|---|---|---|
| 1 | Seed Hash Integrity | S1 |
| 2 | Commitment Linkage | S1 |
| 3 | Hash Consistency Within Epoch | S1 |
| 4 | Nonce Audit (capture flag) | S1, S5 |
| 5 | Outcome Recomputation | S1, S2, S3 |
| 6 | Client Seed Influence | S1, S2, S5 |
| 7 | Payout Math | S4, S5 |
| 8 | Multiplier Provenance | S4, S5 |
| 9 | Bet-Size Invariance | S3, S4, S5 |
| 10 | House Edge Audit (Zero Edge consistency) | S4 |
| 11 | Config Completeness & Paytable Coverage | S4 |
| 12 | Epoch Size | S1 |
| 13 | Population & Phase Labels | S3 |
| 14 | Dataset Hash | S1, S7 |
| 15 | Phase D Client Seed Variation | S1, S3, S5 |
| 16 | Anti-Circularity | S4 |
| 17 | Simulation Pass 1 | S2, S4 |
| 18 | Pass 2 Cherry-Pick Detection | S4, S5 |
| 19 | Cluster Pays Anywhere | S4 |
| 20 | Tumble Cascade Structural Integrity | S3 |
| 21 | Wild Substitution Rule | S4 |
| 22 | Bonus Trigger | S4 |
| 23 | Retrigger Behaviour | S4 |
| 24 | Cosmetic Buy-Spin Disclosure | S4 |
| 25 | Buy-Bonus Structure | S4 |
| 26 | Free-Spin Payout Reconciliation | S4 |
| 27 | Bonus Multiplier Symbol | S3, S4 |
| 28 | Cascade RNG Byte-Exact Replay | S2, S3 |
| 29 | Base 2³² artifact integrity | S4 |
| 30 | Bonus 2³² artifact integrity | S4 |
| 31 | Session-EV artifact integrity | S4 |
| 32 | Headline game RTP derivation | S4 |
| 33 | Artifact Integrity (pinned artifacts of record) | S7 |
| 34 | Max-Win Cap & Payout Bounds (GROOMERS-14) | S4 |
| 35 | Live-Sample Fit (informational, GROOMERS-22) | S2, S4 |
reproduce-audit.sh
npm test at release v1.2.1 reproduces the committed results: 34 PASS + 1 capture-origin FLAG, 0 hard fails, REPRODUCED, exit 0. Runs write to outputs/run/ and never overwrite the evidence of record.
Reproduction Gate & Release5 sections
7.1Exit Codes
The exit code is the verdict:
| Code | Meaning |
|---|---|
0 | PROVABLY FAIR — Full Pass, and this run reproduces the committed artifacts. A capture flag is printed and recorded but exits 0 |
1 | At least one hard fail, or a reproduction difference beyond tolerance |
2 | At least one operator-origin FLAG — PROVABLY FAIR — Conditional Pass |
5 | RTP FIGURE OVERSTATED: no draw check failed, but the RTP claim rule found a published figure beyond the ±0.1 pp band on the house side |
7.2The Reproduction Gate
npm run verify writes this run's results to outputs/run/ (gitignored) and compares them field by field with the committed results in outputs/, at 1e-14 absolute + 1e-12 relative. Two distinct integers never agree. A re-run can't replace the evidence it scores; refreshing the evidence takes PF_EMIT=1 and a re-pin in the same commit.
Outputs written to: outputs/run/verification-results.jsonCommitted artifact NOT modified.Reproduction vs the committed artifact on Node 22.22.0: REPRODUCEDDiff written to: outputs/run/diff.json7.3SHA-256 Pinned Artifacts
Step 14 hashes the dataset and the operator files under data/raw/; Steps 29–31 and 33 hash the 13 artifacts the verifier doesn't produce itself. A missing or altered one is a hard fail. The main ones:
| File | SHA-256 |
|---|---|
| data/groomers-van-smoke-test-1778204681017.json.gz (uncompressed) | 3034cb1284bc1a87d82a0d8f914b19d7f1a8f16894ffe601242bd29e3873b967 |
| data/raw/groomers-van-config-v1.4.json | e08f41da9a1d2ab4a634e3f14dc2d52858520dc9620c327599cac1e5c09c2b87 |
| data/raw/paytable-from-rules-endpoint.json | c3479bf62ee9ed45896506db8972a9b338b693345db47633687af440b27ffcd1 |
| outputs/base-2pow32.json | 0b890eef7153fcdf14c69d8559de8d3f50af558e5464974627db2103ee22d5a1 |
| outputs/bonus-2pow32.json | e878256256cf59edb458d6ec0f5b1cc5ea6e2d45764636676362345d4cdfdb14 |
| outputs/bonus-session-ev-exact-10.json | a03b4e024b1182ad62e64739e47069b2a4d302430f9153a9d1f26d8104072257 |
| outputs/simulation-results.json | 4becfea46f75bb5715343cfad9ee0de64f5438eb6823975c981c7facb930c8cf |
| outputs/rtp-claim-table.json | 58de71cb6dc34e2e758bcc5596813a459cad8657c5c3d7b8a4b584b92895588a |
| outputs/verification-results.json | 629a057e617e6f8c68b184d138442e71238170f15e97b9771869fae297fcefcd |
RELEASE-MANIFEST.json hashes every file of record (28), and npm run release-manifest rewrites it. The dataset row is the hash of the uncompressed bytes, which src/loader.ts checks before any step runs.
7.4Mutation Battery & Runtime
Mutation battery: 51 / 51 mutations killed and all 35 scored steps have a killing mutation, no declared survivors (npm run mutate, 20 October 2026).
Runtime: npm test took 3.7 s on an Apple M2 Max (release manifest, 28 September 2026). The 30M simulation takes tens of minutes, and the full 2³² CPU enumeration hours. Runtime varies by machine.
7.5Release History
| Release | What changed | Verdict |
|---|---|---|
v1.0.0 | The original audit | PROVABLY FAIR — Full Pass |
v1.1.0 | Re-certified under Framework 1.1: RTP claim rule switched on, Step 4 reported as a capture flag, two scored steps added (max-win cap, live-sample fit); dataset unchanged | Unchanged |
v1.2.0 | RNG code rebuilt from a written specification; Duel's Verify-tab code kept as a cross-check only | Unchanged |
v1.2.1 | Adds .gitattributes so a Windows clone stays byte-identical; no audit content changed | Unchanged |
Game Profile Coverage
Is every check in the Groomer's Van profile covered?
The Groomer's Van profile (version 1.0.2) lists 30 checks, GROOMERS-01 to GROOMERS-30. Each one is covered by a scored step, a package check, or marked n/a with a reason. Six are partial, where the package says so.
| Check | Covered by | Coverage | What it covers |
|---|---|---|---|
| GROOMERS-01 | Step 1 | Full | Every revealed seed hashes to its commitment; every epoch with a bet resolves to a revealed seed |
| GROOMERS-02 | Step 2 | Partial | All 116 commitment links. Partial: the capture holds no link from before its first epoch |
| GROOMERS-03 | Step 3 | Full | Epochs keyed by the rotation timeline; every bet carries its rotation's hash and client seed |
| GROOMERS-04 | Step 4 | Full | Nonces from 0, no reuse; every gap must be one of the 4 declared capture retries (capture flag) |
| GROOMERS-05 | Steps 12, 13 | Full | Epoch sizes and the population (phases, modes, seed records) bound to the capture plan |
| GROOMERS-06 | Steps 6, 15 | Partial | Client seed influence and Phase D recomputation. Partial: the tamper runs on the 623 entries that publish an outcome index, and the capture's seeds came from Math.random() and fixed strings |
| GROOMERS-07 | Step 5 | Full | Every non-buy entry recomputes its 30-cell first deal at exactly one nonce |
| GROOMERS-08 | Step 5 | Full | Draw-bias bound exact (0) on all 13 weight totals |
| GROOMERS-09 | Package check | Full | Duel's Verify-tab code run unmodified as a cross-check: outcome index, grid and multiplier values |
| GROOMERS-10 | Steps 19, 20, 21, 28 | Full | Cluster, gravity, wild and cascade rules: Steps 19, 20, 21 and the byte-exact cascade replay |
| GROOMERS-11 | Step 7 | Full | Payouts exact in integer cents; the coins field checked against each bet's rate |
| GROOMERS-12 | Step 9 | Partial | Bet-size invariance on Phase B. Partial: 30 elevated-stake bets against the profile's 100 |
| GROOMERS-13 | Steps 8, 14, 27 | Full | Payline multipliers equal the pinned paytable; multiplier values in the published set |
| GROOMERS-14 | Step 34 | Full | The 5,000× cap from the config, applied by the enumerations; every served win within it |
| GROOMERS-15 | Step 11 | Full | Config completeness; 62 of 96 paytable cells reached live, the rest covered by the enumeration |
| GROOMERS-16 | — | n/a | No response carries a balance amount, so there is no wallet delta to reconcile; the credits are checked instead |
| GROOMERS-17 | Steps 22, 23, 24, 25, 26, 27, 28 | Full | Triggers, retriggers, buy disclosure and structure, free-spin pay and multiplier scope |
| GROOMERS-18 | Step 16 | Full | The 30M simulation scored against the exact enumeration, with negative controls |
| GROOMERS-19 | Steps 10, 32 | Full | edge_multiplier 1 on every bet, and the RTP derivation that carries the RTP claim |
| GROOMERS-20 | Step 17 | Partial | Per-reel χ² and serial tests. Partial: the symbol counts and payout series don't ship |
| GROOMERS-21 | Step 18 | Partial | Pass 2 aggregate and forward replay. Partial: the per-nonce win counts aren't replayed, and no detection power is printed |
| GROOMERS-22 | Step 35 | Full | Live symbol frequencies, hit rate and trigger rate against the exact figures (informational) |
| GROOMERS-23 | Package check | Full | The package’s S5 matrix, each row mapped to the scored steps |
| GROOMERS-24 | Step 5 | Full | The ProvablyFair.org verifier's code (pinned copy) run on every base spin |
| GROOMERS-25 | Package check | Full | Player verification steps in order, with the commitment encoding and the free-spin inputs |
| GROOMERS-26 | Step 14 | Full | Dataset and operator files pinned by SHA-256 |
| GROOMERS-27 | Steps 29, 30, 31, 33 | Partial | The 13 artifacts of record pinned by SHA-256. Partial: the five 2³² enumeration files carry run metadata (elapsed_sec), and no value domains are declared |
| GROOMERS-28 | Package check | Full | Fresh-clone reproduction record |
| GROOMERS-29 | Package check | Full | Mutation battery: every scored step has a killing mutation |
| GROOMERS-30 | Package check | Full | Limitations register, load-bearing premises and numbered evidence |