Skip to main content
Audits
Duel.com/Groomer's Van
Duel: Groomer's Van Audit

Groomer's Van

Certified · Active

Independent verification, backed by open-source code.

PF-2026-DL10Audited May 2026 · Updated October 2026May 2026 · Updated Oct 2026Framework 1.1Release v1.2.1Original audit 6f9bfaf, June 2026, Jun 2026
AUDIT RESULTPassedPROVABLY FAIR — Full Pass34 / 35 steps passed
PROVABLY FAIR — Full Pass
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
34 / 35Verification steps passed

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.

DUEL GROOMER'S VAN$0.20 · Base spin · 1 cascade
Initial grid · 1 / 2
6× 102.2×
Bet #1975512Nonce 0 · Phase A
50 real bets · Phase ABet 1 of 50
✓ Initial grid matches
2.20×

Recorded spin · Initial grid reproduced.

Casino outcome
Initial grid · 30 cells
Our reproduction
30 / 30 cells match
Recorded payout
$0.44
Open source

Run this audit yourself

Open GitHub ↗

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.

npm test
Needs git and Node.js 22View reproduction commands ↓
Groomer's Van Overview

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.

Results at a glance

Audit Verdict

CheckResultEvidence
Overall StatusPassPROVABLY 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 RTPPass99.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 ParityPass6,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 SystemPass116 / 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 AuditCapture flag112 / 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 SeedPassA 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 AnalysisPassOur 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 LogicPass6,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 BuyInfoThe 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 EdgeInfoWithout 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-CircularityPassRTP 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 IntegrityPass18 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
DeterminismPassEvery grid, cascade and free spin recomputes from (serverSeed, clientSeed, nonce, round index)
ReproducibilityPassnpm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results
Overall StatusPass
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 RTPPass
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 ParityPass
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 SystemPass
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 AuditCapture 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 SeedPass
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 AnalysisPass
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 LogicPass
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 BuyInfo
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 EdgeInfo
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-CircularityPass
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 IntegrityPass
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
DeterminismPass
Every grid, cascade and free spin recomputes from (serverSeed, clientSeed, nonce, round index)
ReproducibilityPass
npm test at v1.2.1: REPRODUCED, exit 0. Runs write to outputs/run/ and are compared with the committed results
Audit scope & reference

What 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
2 columns
AreaDescription
Commit-Reveal SystemSHA-256 server-seed hashing, the commitment links, reveal on rotation
Client Seed OriginBrowser-generated default, player-customisable; the capture's own seeds disclosed
Seed HandlingClient seed control, nonce lifecycle, seed pair rotation, free-spin nonce and round index
RNG AnalysisHMAC-SHA256 outcome index, tumble seed, PCG32 written from the specification, the discard rule and its bias bound
Cascade MechanicsA fresh stream per cascade, gravity, fill from the fresh grid; all 4,323 captured cascades replayed
Payout LogicCounted clusters with wilds, scatter pays, free-spin multipliers per spin, exact settlement, bet-size invariance
Buy-Bonus MechanicsThe disclosed canned buy spin, its 4 scatters and 10 free spins; the free spins recomputed
Live ParityOur recomputation, Duel's Verify-tab code (cross-check) and the ProvablyFair.org verifier against the live game
RTP ValidationAnti-circularity, 2³² enumeration, exact session convolution, RTP claim rule, 30M simulation, cherry-pick test (Pass 2)
Fairness Integrity18-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 CoverageAll 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.

Every grid is computed cryptographically before the reel animation plays. The visual spin is cosmetic — the result is fixed at the moment the bet is placed.
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_1 cluster and a symbol_7 cluster 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
A grid can pay several symbols at once; every wild on the grid counts toward each of them.
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
Every multiplier value is drawn from the same seeds as the grid: 335 / 335 on first deals and 146 / 146 in cascades reproduce exactly, and 475 / 475 free spins reconcile to the cent.
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
The buy spin's grid isn't drawn from the seeds, but what it pays is fixed (4 scatters → 3× and 10 free spins). The bonus session that follows is provably fair and was verified end to end.
Seed Formats

Every Groomer's Van spin uses three cryptographic inputs to generate the result.

4 columns
Seed TypeFormatExamplePurpose
Server Seed64-char hex (32 bytes)38daabbe1a0a8e47…Casino-provided randomness
Client SeedAlphanumeric stringpf_ww6Oka8nm8bydPlayer-contributed entropy
NonceInteger (0, 1, 2…)23One per paid spin in a seed pair; free spins use the nonce of the spin that started the bonus
The server seed is hex-decoded to 32 raw bytes before use as the HMAC key. The client seed is hex-encoded into the HMAC message body. This is confirmed by 6,205-bet recomputation across the full capture.
Parameters
3 columns
ParameterValueNotes
Grid Size5 rows × 6 columns30 cells per grid
Minimum Cluster Size8 symbolsAnywhere on the grid, wilds included; 12+ pays the 12 tier
Symbols9 paying symbols (4 common + 3 rare + 1 epic + 1 premium) + wild + scatter; the multiplier in free spins only11 in the base game, 12 in the bonus
Bonus Trigger3+ scattersAwards 8–14 free spins (3 scatters → 8, 4 → 10, 5 → 12, 6 → 14)
Buy-Bonus Cost125× stakeOperator-disclosed guaranteed trigger
Max Win5,000×Duel's max_multiplier; never reached in the capture
Min / Max Bet$0.20 / $1,000Per regular paid spin — UI-enforced at the input level
House Edge0% with Zero Edge (every captured bet)Without Zero Edge, 0.01% and up by stake (S4.5)
Enumerated RTP99.9720%By full 2³² enumeration; 30M simulation at 100.06%
RNG AlgorithmHMAC-SHA256 → PCG32One HMAC per spin → fresh PCG32 stream per cascade round
RTP Claim100% (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

2 columns
TestDescription
Server seed commit exists before playSHA-256 hash shown to player before betting
Server seed reveal matches commitSHA-256(hexDecode(revealed)) = committed hash — 116 / 116 revealed seeds verified
Client seed controlPlayer can set/change client seed via rotation UI
Nonce increments correctlyStarts at 0 and rises by 1 per paid spin in each seed pair; 4 gaps from our capture script's retries (capture flag)
Full determinismSame (serverSeed, clientSeed, nonce) → same grid and same cascade chain

2. Randomness & Entropy Model

2 columns
TestDescription
RNG depends only on seeds + nonceNo external inputs — no drand, no timestamps, no server-side state
No mixed entropy sourcesAudit independently verifies the two-layer pipeline: HMAC-SHA256 → outcome_index → PCG32
Unbiased weighted drawThe discard rule leaves bias exactly 0 on all 13 weight totals
No state leakageEach cascade and free spin draws from its own PCG32 stream — rounds are independent

3. Verifier ↔ Live Parity

2 columns
TestDescription
Live outcomes match verifier6,205 / 6,205 non-buy entries reproduced across 186,150 grid cells
Cascade reproduction4,323 / 4,323 cascade rounds reproduce byte-exact — 129,690 cells
Multi-phase verificationPhases A–E: baseline, bracket sampling ($1–$50), buy-bonus, custom client seeds, edge cases; counts bound to the plan
Bet-size invarianceSame grid from the same seeds at any stake — 30 Phase B bets from $1 to $50

4. Game Logic & RTP Validation

2 columns
TestDescription
Anti-circularity check99.9720% RTP computed by full 2³² enumeration from per-reel weights + paytable alone
House edge auditedge_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 correctnessAll 6,205 non-buy entries reconcile exactly in integer cents, cascades and free spins included
Monte Carlo cross-check30M base spins + 132,222 bonus sessions corroborate the enumerated RTP at 100.06%
Cherry-pick detectionAggregate 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

2 columns
TestDescription
Player can reproduce results offlineUsing (serverSeed, clientSeed, nonce) inputs — every grid, cascade, and bonus session
Verifier logic matches live logicOur RNG (written from the spec), Duel's Verify-tab code and the ProvablyFair.org verifier agree
Verifier publicly accessibleProvablyFair.org verifier — no login required
No reliance on private APIsFully client-side verification using only published seeds
Fairness integrity testsCommit-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

High-Level Flow — illustrated flow
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-Reveal Model — illustrated flow

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
nonce-lifecycle
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:

determinism
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 payout
Technical Glossary7 categories▶
Framework 1.1
2 columns
TermDefinition
Framework 1.1The 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 flagA 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 ruleRTP-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 tierThe 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
2 columns
TermDefinition
Provably FairA cryptographic system that allows players to mathematically verify that game outcomes were not altered. Relies on commit-reveal schemes and deterministic algorithms.
Commit-Reveal ProtocolA 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.
DeterminismThe 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 OriginThe 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
2 columns
TermDefinition
Server SeedA 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 SeedA random value controlled by the player, generated by the browser. Players can change it at any time via the seed rotation UI.
NonceA 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 SeedSHA-256(hexDecode(serverSeed)) — the commitment hash shown before betting. After rotation, players verify the revealed seed produces this hash.
Seed PairA sequence of bets using the same server seed and client seed pair. Ends when the player rotates seeds.
Cryptographic Functions
2 columns
TermDefinition
HMAC-SHA256Hash-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-256Secure Hash Algorithm 256-bit. Used for server seed commitment: SHA-256(hexDecode(serverSeed)) = serverSeedHashed.
PCG32Permuted 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 SamplingRemoves 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
2 columns
TermDefinition
Cluster PaysPayout 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 ReelsAfter 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 SubstitutionThe 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 BonusTriggered 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 BombA 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-BonusA 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 IndexThe 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 EdgeDuel'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
2 columns
TermDefinition
VerifierA 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.
ParityDegree 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 CheckIndependent 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 DetectionTest 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
2 columns
TermDefinition
Phase A–EThe 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 EdgeDuel'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.
01

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.

Commit-Reveal Consistency

116 / 116revealed seeds match

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
116 / 116revealed seeds match
  • 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
HMAC-SHA256 Pipeline — seed inputs through the outcome index to each cascade's PCG32 stream — illustrated flow
CheckResultEvidence
Seed hash integrityPass116 / 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 linkagePass116 / 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 epochPassAll 6,225 bets carry the hash and client seed of the rotation active when they were placed, across 116 epochs (Step 3)
Nonce sequencingCapture flag112 / 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 outputPass6,205 / 6,205 spins and free spins reproduce all 30 cells from (server seed, client seed, nonce, round index) (Step 5)
Client seed participationPass623 / 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 originPassDuel'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
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 linkagePass
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 epochPass
All 6,225 bets carry the hash and client seed of the rotation active when they were placed, across 116 epochs (Step 3)
Nonce sequencingCapture 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 outputPass
6,205 / 6,205 spins and free spins reproduce all 30 cells from (server seed, client seed, nonce, round index) (Step 5)
Client seed participationPass
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 originPass
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
✓  Commit-reveal consistent

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

Server Seed Commitment — illustrated flow
src/rng.ts · hashServerSeed · Verified
// §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");}
Result: 116 / 116 revealed seeds hash to their commitments, and every epoch a captured bet was played in resolves to a revealed seed. 0 mismatches.

Real seed record:

data/groomers-van-smoke-test-1778204681017.json.gz · seeds[0] · Verified
{  "clientSeed":         "pf_ww6Oka8nm8byd",  "serverSeedHashed":   "1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd",  "nextServerSeedHash": "eb088078f74ec417a442f975f3c2249914e07d3c35a0711a5fbe331eafcb82eb",  "serverSeed":         "38daabbe1a0a8e472690d8359f05bd5ad44dee3f60902dc14eeed66bdb710e67"} // SHA-256(hex_decode(serverSeed))//   = 1966b35c0357323c0e3f5f7150805522bfb6d7db386dab31340e7bc9c4d9a3dd   matches serverSeedHashed
1.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.

tests/steps/commitment.ts · Step 2: Commitment Linkage · Verified
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)}`);  }}
Result: 116 / 116 links match. 0 broken.
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.

tests/steps/commitment.ts · Step 3: Hash Consistency Within Epoch · Verified
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)}…`);  }}
Result: 6,225 bets across 116 epochs: 0 hash mismatches, 0 client-seed mismatches, 0 bets outside an epoch.
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.getRandomValues in 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's Math.random(); Phase D used the fixed strings pfaudit_groomers_seed00 … 09. These are choices on our side; they don't change what Duel's server does with a seed
Result: 116 distinct client seeds, one per epoch (A 100, B 1, C 1, D 10, E 4). Every captured spin recomputes with the client seed the player set, so the server uses it rather than a substitute.
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.

Nonce Audit — illustrated flow
tests/steps/commitment.ts · Step 4: Nonce Audit · Verified
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)'));  }}
Capture flag: 112 / 116 epochs gap-free, no reuse, one client seed each. The four gaps match the declared list exactly; a gap more or fewer, a reused nonce or a gap under an unrevealed seed would fail. Outcome indexes at the missed nonces: 2,213,331,201 (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).

Deterministic Mapping — illustrated flow
src/rng.ts · computeOutcomeIndex · Verified
// §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);}
Result: 6,205 / 6,205 spins and free spins reproduce their grids from the revealed inputs, and every outcome index Duel published (623) matches. Duel's own Verify-tab code, run unmodified as a second check, gives the same outcome index and grid on all 6,205. No other input reaches the result.

Worked Example — Real Bet:

bet 1964586 (Phase A, $0.20, base game) · Verified
// 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 value
1.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.

tests/steps/determinism.ts · Step 6: Client Seed Influence · Verified
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}`);}
Result: 623 / 623 outcome indexes change under a tampered client seed. All 500 Phase D bets reproduce under the auditor seeds.
Technical Evidence & Verification5 sections
1.8Evidence Coverage Summary6 checks
3 columns
Verification AreaCoverageResult
Seed hash integrity (Step 1)116 / 116 revealed seeds; the 117th record has no betPass
Commitment linkage (Step 2)116 / 116 linksPass
Hash consistency (Step 3)6,225 bets, 116 epochs, 0 mismatchesPass
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 eachPass
Client seed influence (Step 6)623 / 623 change under a tampered seedPass
1.9Code References7 source files
2 columns
FilePurpose
tests/verify.ts35 scored steps (Steps 1–6 cover S1) and the reproduction gate
tests/steps/commitment.tsSteps 1–4: commitments, links, epochs, nonces
tests/steps/determinism.tsSteps 5–6: grid recomputation and client seed influence
src/rng.tsCommitment, outcome index, tumble seed, PCG32 and the weighted draw, written from docs/ALGORITHM.md
docs/ALGORITHM.mdThe written specification the RNG code was built from
src/loader.tsDataset loading, the hash guard, the declared population, nonce gaps and nonce corrections
capture/capture.reference.jsNon-runnable reference record of the capture script
1.10Datasets UsedSource artifacts
Primary: data/groomers-van-smoke-test-1778204681017.json.gz
2 columns
PropertyValue
SourceLive 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 records6,225 entries (5,730 spins, 20 bonus buys, 475 free spins) · 117 seed records (116 revealed)
SHA-2563034cb1284bc1a87d82a0d8f914b19d7f1a8f16894ffe601242bd29e3873b967
Pre-flight checktests/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
2 columns
InvariantResult
SHA-256(hexDecode(serverSeed)) = serverSeedHashed for all 116 revealed seedsPass
Each rotation's active hash equals the previous rotation's next hash, for all 116 linksPass
Every bet carries the hash and client seed of the rotation active when it was placedPass
No nonce reused in any epoch; one client seed per epochPass
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 spinsPass
A tampered client seed changes the outcome index on all 623 entries that publish onePass
117 seed records carry 117 distinct commitmentsPass
1.12Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier:

reproduce-s1.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verify
Expected 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 Influence
02

RNG & 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.

Randomness Written From the Spec

6,205 / 6,205grids reproduced

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
6,205 / 6,205grids reproduced
  • 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
Two-Layer RNG Pipeline — HMAC-SHA256 → outcome_index → tumble seed → PCG32 → 30-cell grid — illustrated flow
CheckResultEvidence
RNG derived only from disclosed inputsPassHMAC-SHA256 → outcome index → one PCG32 stream per (round, tumble); every grid and cascade recomputes from these alone (Steps 5, 28)
Implementation written from the specPasssrc/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-checkPassDuel'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 biasPassEvery 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 encodingPassServer seed hex-decoded to 32 bytes, client seed hex-encoded into the message; all 6,205 reproduce with it (Step 5)
Per-reel symbol distributionPass30M 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 independencePass100,000 simulated payouts: lag-1 |z| = 0.57 (threshold 3.14), runs p = 0.9666 (Step 17)
Client seed influencePass623 / 623 published outcome indexes change under a tampered client seed (Step 6)
RNG derived only from disclosed inputsPass
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 specPass
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-checkPass
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 biasPass
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 encodingPass
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 distributionPass
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 independencePass
100,000 simulated payouts: lag-1 |z| = 0.57 (threshold 3.14), runs p = 0.9666 (Step 17)
Client seed influencePass
623 / 623 published outcome indexes change under a tampered client seed (Step 6)
✓  Written from the spec, consistent with uniform

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.

RNG Function Implementation — illustrated flow
2 columns
ComponentDetail
Hash functionHMAC-SHA256
Keyhex_decode(serverSeed): 32 bytes
Messagehex(utf8(clientSeed)) + ":" + nonce: no cursor, one HMAC per spin
Layer 1 outputFirst 4 bytes, big-endian → outcome_index (uint32)
Layer 2 tumble seedXOR in low32((round + 1) × 0x9E3779B9) and low32((tumble + 1) × 0x85EBCA6B), then xor-shift 16, × 0xC2B2AE35, xor-shift 16
PRNGPCG32 (XSH-RR 64/32 output); state from one SplitMix64 step on the tumble seed; multiplier and increment both 0x5851F42D4C957F2D; no warm-up draw
Cell drawDiscard u ≥ (2³² − 1) − ((2³² − 1) mod T), then walk the reel's cumulative weights to u mod T
Grid orderColumn-major: position = reel × 5 + row, reel 0–5, row 0 (top) – 4
Multiplier valuesBonus game only: after the 30 cells, one draw per multiplier cell in position order, from the 200-entry weighted list
CascadesEvery tumble starts a fresh stream; emptied top cells take the fresh grid's cells at the same positions
src/rng.ts · deriveTumbleSeed + Pcg32 · Verified
// §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;  }}
Result: 6,205 / 6,205 grids reproduce (186,150 cells), and all 4,323 captured cascades reproduce byte for byte (129,690 cells, 146 multiplier values). Duel's Verify-tab code gives the same outcome index and grid on all 6,205; the specification's own vectors and properties pass 166 / 166.
2.2Entropy Sources

All randomness comes from HMAC-SHA256 over three disclosed inputs. Two counters then pick the stream:

Entropy Sources — illustrated flow
3 columns
SourceControlled ByPurpose
Server SeedCasinoBase randomness (committed by its SHA-256 hash before betting)
Client SeedPlayerPlayer-contributed input
NonceSystemOne per paid bet, rising by 1 within each epoch
Round indexSystem0 for a base spin; the free-spin number inside a bonus
Tumble indexSystem0 for the initial deal, then one per cascade
No mixed entropy sources detected. The same inputs always give the same grids. 6,205 / 6,205 confirmed.

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
src/rng.ts · acceptedDraw + pickWeighted · Verified
// §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");}
Result: Bias exactly 0 on all 13 weight totals, for grid cells and multiplier values alike.

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.

RNG Isolation — illustrated flow
Result: Every stream is seeded from its own (outcome index, round, tumble); nothing carries over from the last one.

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.

5 columns
Reelχ²dfp-valueVerdict
08.63100.5672Pass
17.08100.7176Pass
25.82100.8300Pass
39.39100.4956Pass
410.95100.3613Pass
54.94100.8954Pass
2 columns
ParameterValue
Base spins (Pass 1)30,000,000
Bonus sessions played out132,222
Reels × rows6 × 5 = 30 cells
Symbol classes11 (base game) · 12 (bonus game, adds the multiplier)
Multiplier values14 (2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 25, 50, 100, 250)
Master seedpf-audit-groomers-van-v1 → HMAC-SHA256 → PCG32 seed
Bonferroni per-test α0.0017 (= 0.01 / 6)
src/simulate.ts · pinned master seed · Verified
// 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);
Result: 0 / 6 reels fail the per-reel χ² at α = 0.0017: consistent with the published weights.

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.

src/stats.ts · lag1Autocorrelation · Verified
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 };}
Result: Lag-1 |z| = 0.57 (threshold 3.14); runs p = 0.9666 (threshold 0.0017). No sign of serial dependence.
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
3 columns
StepComputationResult
InputsserverSeed, clientSeed, nonce38daabbe…710e67, pf_ww6Oka8nm8byd, 49
1.a Hex-encode clientSeedBuffer.from('pf_ww6Oka8nm8byd', 'utf-8').toString('hex')70665f7777364f6b61386e6d38627964
1.b Form HMAC messagehex(clientSeed) + ":" + nonce70665f7777364f6b61386e6d38627964:49
1.c Hex-decode serverSeedBuffer.from(serverSeed, 'hex')32-byte HMAC key
1.d Compute HMAC-SHA256crypto.createHmac('sha256', key).update(message).digest()32-byte digest
1.e Extract outcome_indexhmac.readUInt32BE(0)0x1a638947 = 442,730,823
2 Derive tumble_seed (round_index=0, tumble_index=0)deriveTumbleSeed(0x1a638947, 0, 0)0x4e0185b3
3 Seed PCG32new Pcg32(0x4e0185b3) — SplitMix64 expansion64-bit state
4 Generate 30 cells column-majorFor col 0..5 / row 0..4: rejection-sampled against per-reel weightsgrid[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
ReproductionOur src/rng.ts, written from the specificationAll 30 cells match
Result: Spin 1964586: Duel's published 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.
Live Gameoutcome_index_hex = 1a638947 · grid = [[0,2,4,1,5],[3,2,1,7,1],[4,6,0,3,1],[3,7,1,2,2],[8,6,7,4,4],[7,6,6,0,4]]
Verifieroutcome_index_hex = 1a638947 · grid = [[0,2,4,1,5],[3,2,1,7,1],[4,6,0,3,1],[3,7,1,2,2],[8,6,7,4,4],[7,6,6,0,4]]
Technical Evidence & Verification5 sections
2.8Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Outcome index and initial grids (Step 5)6,205 / 6,205 spins and free spins, 186,150 cellsPass
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 weightsPass
Cascade streams (Step 28)4,323 / 4,323 cascades, 129,690 cells, 146 multiplier valuesPass
Draw bias (Step 5)Exactly 0 on all 13 weight totalsPass
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.9666Pass
Live symbol frequencies (Step 35, informational)6 / 6 reels fit the weights on 5,730 live base spinsPass
Client seed influence (Step 6)623 / 623Pass
2.9Code References10 source files
2 columns
FilePurpose
src/rng.tsOutcome index, tumble seed, PCG32, the draw rule, grids and multiplier values, written from docs/ALGORITHM.md
docs/ALGORITHM.mdThe written specification, with each step's source
tests/groomers-van/RngSpecTests.tsThe specification's own vectors and properties (166 checks) against src/rng.ts
src/operator-verifier.tsRuns Duel's captured Verify-tab code unmodified, as a second check
src/bias.tsThe Step 5 draw-bias bound, measured from acceptedDraw
src/simulate.tsMonte 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.tsSteps 5–6
tests/steps/simulation.tsSteps 16–18
tests/groomers-van/GroomersVanTests.ts20 unit tests, anchored to captured spin 1964586
2.10Verified Invariants9 invariants
2 columns
InvariantResult
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 totalsPass
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 streamPass
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 weightsPass
2.11Datasets UsedSource artifacts
Primary: data/groomers-van-smoke-test-1778204681017.json.gz · Simulation: outputs/simulation-results.json (pinned)
Captured dataset: 6,225 entries from duel.com: 5,730 spins, 20 bonus buys and 475 free spins · 117 seed records (116 revealed) · SHA-256 3034cb12…b967, checked before any step runs.
Pass 1 simulation: 30,000,000 base spins and 132,222 bonus sessions from src/simulate.ts, on the same Pcg32 class as the verifier. Committed as outputs/simulation-results.json and outputs/rtp-convergence.html, both pinned.
Per-reel weights: The six reel tables in Duel's config (weights.symbols_by_condition, base_game with 11 symbols and bonus_game with 12), pinned by SHA-256 with the rest of data/raw/.
Multiplier weights: 14 values from 2× to 250× with weights summing to 200; bonus game only.
2.12Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier (and, optionally, the simulation):

reproduce-s2.sh · 5 lines · Verified
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 Replay
03

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

Live ↔︎ Verifier Parity

6,205 / 6,205entries recomputed

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
6,205 / 6,205entries recomputed
  • 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
Live-vs-Verifier Parity Flow — seeds → outcome_index → PCG32 → grid → clusters → cascade re-seed → compare to the capture — illustrated flow
CheckResultEvidence
Initial-deal recomputationPass6,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 replayPass4,323 / 4,323 cascades replayed from fresh streams: 129,690 / 129,690 cells and 146 / 146 multiplier values exact (Step 28)
Gravity rulePassIn 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 codePassRun 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 verifierPassOur 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 invariancePass30 / 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 honouredPass500 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 planPass6,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
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 replayPass
4,323 / 4,323 cascades replayed from fresh streams: 129,690 / 129,690 cells and 146 / 146 multiplier values exact (Step 28)
Gravity rulePass
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 codePass
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 verifierPass
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 invariancePass
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 honouredPass
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 planPass
6,225 entries in phases A–E match the capture plan written into the code, not the dataset's own header (Step 13)
✓  Live game and verifier agree

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.

Why Parity Matters — illustrated flow
Why this matters: Each cascade draws its new cells from its own stream, seeded from the same outcome index and the cascade number. Step 28 replays every captured cascade from that stream, so the cascades get the same exact check as the first deal.
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.

5 columns
PhaseEntriesWhat was playedStakePurpose
A — Baseline5,2485,000 spins + 248 free spins$0.20The bulk of the RNG and payout checks
B — Bracket sampling305 spins at each of 6 stakes$1, $5, $9.50, $18.50, $27.50, $50The stake is not an RNG input (Step 9)
C — Buy-bonus22320 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 seeds524500 spins on 10 auditor-chosen client seeds (50 each) + 24 free spins$0.20The server uses the client seed the player sets (Step 15)
E — Edge cases / replay200200 spins$0.20More base spins at the standard stake
Result: 6,225 entries: 5,730 spins, 20 bonus buys and 475 free spins. Step 13 checks the counts against the capture plan written into 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:

Initial-Deal Recomputation (Step 5) — illustrated flow
  • 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.
tests/steps/determinism.ts · Step 5: Outcome Recomputation · Verified
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++;}
Result: 6,205 / 6,205 non-buy entries reproduce all 30 cells (186,150 cells). 0 unverifiable. The 20 bonus buys are the only entries skipped, and the step fails if any other entry is.
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.

Cascade Replay (Step 28) — illustrated flow
3 columns
Reproduction targetVerified countVerified by
First-deal cells186,150 / 186,150Step 5 (S3.3)
Cascade cells129,690 / 129,690Step 28 (this section)
All grid cells315,840 / 315,840Steps 5 + 28
First-deal multiplier values335 / 335Step 5
New cascade multiplier values146 / 146Step 28
Multiplier cells with a published value935 in the bonus game · 0 in the base gameStep 27
tests/steps/game-specific.ts · Step 28: Cascade RNG Byte-Exact Replay · Verified
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];  }}
Result: 4,323 / 4,323 captured cascades replayed: 129,690 / 129,690 cells and 146 / 146 new multiplier values reproduce exactly, across 2,974 spins with cascades. The first-deal multiplier values (335) are recomputed in Step 5, and all 935 multipliers in the capture carry a published value (Step 27).
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.

Tumble Gravity Rule (Step 20) — illustrated flow
tests/steps/game-specific.ts · Step 20: Tumble Cascade Structural Integrity · Verified
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; }  }}
Result: 4,323 / 4,323 cascades keep the remaining cells at the bottom of their column, in order. 0 violations, 0 missing grids.
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.

tests/steps/determinism.ts · Step 5: this site's verifier · Verified
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}`);  }}
Result: Duel's code: outcome index 6,205 / 6,205, first-deal grid 6,205 / 6,205, multiplier values 335 / 335. This site's verifier: outcome index, trigger and payout multiple 5,730 / 5,730, largest relative difference 2.1 × 10⁻¹⁶.

What Duel's code is given:

tests/steps/determinism.ts · Step 5: Duel's Verify-tab code · Verified
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.

Result: 524 Phase D entries: 500 regular bets across 10 distinct seeds, as planned, plus 24 free spins. All reproduce in Step 5. The server uses the client seed the player sets.
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.

tests/steps/payouts.ts · Step 9: Bet-Size Invariance · Verified
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;}
Result: 30 / 30 Phase B bets rebuild all 30 cells. Stakes spanned: $1, $5, $9.50, $18.50, $27.50, $50. The same seeds give the same grid at any stake.
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)
Worked Example — Full Parity Verification — illustrated flow
3 columns
StepProcessOutput
1computeOutcomeIndex(serverSeed, clientSeed, 2)outcome_index = 0xd6f866a8
2deriveTumbleSeed(0xd6f866a8, 0, 0)tumble_seed (round 0) = 0x2e64c112
3generateGrid(new Pcg32(0x2e64c112), base-game weights)30-cell grid, equal to the served round 0
4Cluster: 7 symbol_1 + 1 wild = 8Pays 0.4 × $0.20 = $0.08
5deriveTumbleSeed(0xd6f866a8, 0, 1)tumble_seed (round 1) = 0x65b74d9c
6generateGrid(new Pcg32(0x65b74d9c), base-game weights)Fresh grid for the cascade
7Remove the 8 winning cells, let the rest fall, fill the empty top cells from the fresh gridRound 1 grid, equal to the served round 1
8No cluster in round 1amount_won = $0.08, equal to the served amount
Trace · spin 1964425 · 2 rounds · Verified
// 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 amount
Result: Spin 1964425: the first deal, the cluster, the cascade grid and the final amount all rebuild from (server seed, client seed, nonce). Step 5 extends the first-deal check to all 6,205 entries, and Step 28 the cascade check to all 4,323 cascades.
Live Gameoutcome_index = 0xd6f866a8 · cluster of 8 (7 symbol_1 + 1 wild) → $0.08 · cascade: no win · amount_won = $0.08
Verifieroutcome_index = 0xd6f866a8 · cluster of 8 (7 symbol_1 + 1 wild) → $0.08 · cascade: no win · expected = $0.08
Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary9 checks
3 columns
Verification AreaCoverageResult
Initial-deal recomputation (Step 5)6,205 / 6,205 entries · 186,150 cellsPass
Free-spin inputs (Step 5)475 / 475 free spins carry the trigger's nonce and the session's round indexPass
Cascade replay (Step 28)4,323 / 4,323 cascades · 129,690 cells · 146 multiplier valuesPass
Gravity rule (Step 20)4,323 / 4,323 cascades · 0 violationsPass
Duel's verify code, cross-check (Step 5)6,205 / 6,205 outcome index and grid · 335 / 335 multiplier valuesPass
This site's verifier (Step 5)5,730 / 5,730 base spins: outcome index, trigger, payout multiplePass
Bet-size invariance (Step 9)30 / 30 Phase B bets, 6 stakes from $1 to $50Pass
Auditor client seeds (Step 15)500 bets on 10 seeds, as plannedPass
Population and phases (Step 13)6,225 entries, phases A–E as plannedPass
3.11Code References9 source files
2 columns
FilePurpose
tests/verify.ts35 scored steps (Steps 5, 9, 13, 15, 20 and 28 cover S3) and the reproduction gate
tests/steps/determinism.tsStep 5: grid recomputation, free-spin inputs, the draw-bias bound, this site's verifier and Duel's verify code
tests/steps/payouts.tsStep 9: bet-size invariance
tests/steps/dataset.tsSteps 12–15: epochs, population, dataset hash, Phase D seeds
tests/steps/game-specific.tsStep 20 (gravity rule) and Step 28 (cascade replay)
src/rng.tscomputeOutcomeIndex, deriveTumbleSeed, Pcg32, generateGrid, generateMultipliers, written from docs/ALGORITHM.md
src/operator-verifier.tsRuns Duel's captured Verify-tab code unmodified, pinned by SHA-256
src/site-verifier.tsLoads this site's verifier code, pinned by SHA-256
src/loader.tsThe capture plan, the scored populations and the four nonce corrections
3.12Datasets UsedSource artifacts
Primary dataset: data/groomers-van-smoke-test-1778204681017.json.gz: 6,225 entries from duel.com across 5 phases · 117 seed records (116 revealed) · SHA-256 3034cb12…b967.
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.
4 columns
PhasePurposeEntriesTests
ABaseline5,248: 5,000 spins at $0.20 + 248 free spinsSteps 5, 28 and the payout checks
BBracket sampling30 across 6 stakes ($1–$50)Step 9: bet-size invariance
CBuy-bonus223: 20 buys + 203 free spinsSteps 24–25: bonus-buy structure
DCustom client seeds524: 500 spins on 10 seeds + 24 free spinsStep 15: auditor seeds honoured
EEdge cases / replay200 spins at $0.20Steps 5, 28 and the payout checks
3.13Verified Invariants10 invariants
2 columns
InvariantResult
Every non-buy entry's first-deal grid equals generateGrid(new Pcg32(deriveTumbleSeed(outcome_index, round_index, 0))), cell for cell, at exactly one noncePass
Each declared nonce correction is needed: the grid reproduces at the served nonce and not at the recorded onePass
Every free spin's verify record carries the trigger's served nonce and the session's round indexPass
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 numberPass
Every new cascade multiplier carries the value drawn from the same stream with the published weightsPass
Cells left in place sit at the bottom of their column, in orderPass
Duel's Verify-tab code, unmodified, gives the same outcome index and first-deal grid on every non-buy entryPass
This site's verifier gives the same outcome index, trigger and payout multiple on every base spinPass
The stake doesn't change the grid for the same (server seed, client seed, nonce), across 6 stakes from $1 to $50Pass
The server uses every auditor-supplied client seed: 500 Phase D bets on 10 seedsPass
3.14Reproduction InstructionsRun locally

Clone the repository at the release tag, install, and run the verifier:

reproduce-s3.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verify
Expected 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 Replay
04

RTP & 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.

Return to Player Verification

99.9720%enumerated RTP · no edge applied

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
99.9720%enumerated RTP · no edge applied
  • 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)
INDEPENDENT DERIVATION
RTP(base) + P(trigger) × EV(bonus)= 0.999720
Full 2³² per-spin enumeration · Exact bonus-session convolution · Published weights and paytable

Base play plus naturally triggered bonuses, with no edge applied. The bonus buy is not certified: its first spin is canned.

99.9720%Enumerated RTP · no edge applied
PASSRTP claim 100% · −0.028 pp
100.06%MC cross-check (30M)
0.561376×Base per-spin RTP
1 in 227.1Bonus trigger rate
CheckResultEvidence
Anti-circularityPassRTP 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 RTPPass99.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)PassClaim: 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 appliedPassedge_multiplier 1 (Zero Edge) on all 6,225 captured bets, at 7 stakes from $0.20 to $50 (Step 10)
Payout exactnessPass6,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 rulesPassClusters 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)Pass30M 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)PassCaptured RTP over 5,730 base spins z = +0.91; 115 seeds × 10,000 nonces, 4 flagged, binomial p = 0.83 (Step 18)
Max-win capPassAll 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 buyInfo20 / 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 tiersInfoWithout 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
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 RTPPass
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 appliedPass
edge_multiplier 1 (Zero Edge) on all 6,225 captured bets, at 7 stakes from $0.20 to $50 (Step 10)
Payout exactnessPass
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 rulesPass
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 capPass
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 buyInfo
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 tiersInfo
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
✓  RTP proven with no edge applied, claim holds

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

Anti-Circularity Proof (Steps 16, 29–32) — illustrated flow
3 columns
ComponentSourceRole
Per-reel symbol weightsweights.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 weightsmultiplier_values (14 values, weights summing to 200)The value drawn for each multiplier in the bonus
tests/steps/simulation.ts · Step 16: the simulation scored against the exact figure · Verified
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 } } },]);
Result: Enumerated RTP 99.9720%. The simulation's base RTP, trigger probability, session payout and blended RTP all sit within 5 standard errors of it (z = 0.29, 0.26, 0.30, 0.34). Two wrong models are rejected: a trigger threshold of 4 scatters (z up to 1,233) and the free-spin table shifted one tier up (z up to 47.8).

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.

5 columns
ModeOutcomes enumeratedWin rateMax payoutPer-spin RTP
Base game4,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×
src/enumerate-mt.ts · spinPayout, run on every outcome index · Verified
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 };}
Result: Base-game per-spin RTP 0.561376× and bonus-game per-spin RTP 12.153351×, both over all 2³² outcomes. The bonus figure is the return of one free spin, where the multipliers apply; it is weighted by how rarely the bonus triggers in S4.3.

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.

Bonus Session EV via Exact Convolution (Step 31) — illustrated flow
3 columns
Triggering scattersFree spinsExact session EV
3897.5997×
410121.9996×
512146.3995×
6+14170.7994×
3 columns
ComponentValueSource
Base-game per-spin RTP0.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 spin0.438344×P(trigger) × E[session | triggered]
Enumerated RTP99.9720%Base + bonus contribution
src/session-ev-exact.ts · the convolution kernel and one spin step · Verified
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);}
Result: Scatter-weighted session EV 99.5286×, with the bonus triggering about 1 spin in 227.1. With the base game's 0.561376×, the enumerated RTP is 99.9720%.

Headline derivation (Step 32):

tests/steps/enumeration.ts · Step 32 · Verified
// 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).

2 columns
ItemValue
Claim100%, flat
Published inGame settings: "rtp": "100.0000" in Duel's Groomer's Van config v1.4 (data/raw/groomers-van-config-v1.4.json)
Scored onStep 32 (headline RTP derivation)
Band±0.1 pp
Settings tabled1 (a paid spin: base game and triggered bonus)
House side beyond band0
Player-favourable beyond band0
OutcomePASS — minimal fix: none
5 columns
SettingAudited RTPClaimGapResult
Paid spin (base game + triggered bonus), no edge applied99.972000%100%−0.028000 pp, within bandPass
Verifier output, as run at v1.2.1 · Verified
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 pin
Result: PASS. The audited 99.972000% (exact value 1125584657215581 / 1125899906842624) is 0.028 pp below Duel's stated 100%, inside the ±0.1 pp band.

The claim, as the package declares it:

src/rtp-settings.ts · RTP_CLAIM · Verified
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.

6 columns
BetSpin bracketSpin edgeBuy cost (125×)Bonus bracketBonus edge
$0.2010.01%$2510.01%
$1020.02%$1,25020.02%
$5060.06%$6,25090.09%
$100120.12%$12,500180.18%
$500570.57%$62,500900.90%
$1,0001151.15%$125,0001821.82%
2 columns
SpinRTP without Zero Edge (analytical)
$0.2099.962%
$1099.95–99.96%
$10099.83–99.90%
$1,00098.5–99.3%
Result: All 6,225 captured bets show 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.

Simulation Pass 1 — 30M Spins (Steps 16, 17) — illustrated flow
4 columns
ComponentSimulatedExactz
Base RTP per spin0.561324×0.561376×0.29
Trigger probability0.44074%0.44042%0.26
Session payout99.66×99.53×0.30
Blended RTP100.06%99.9720%0.34
src/simulate.ts · Pass 1, integrated trigger and session · Verified
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;
Result: Blended RTP 100.06% over 30M spins, consistent with the enumerated 99.9720%: every component is within 5 standard errors, taken from the exact variances. Per-reel χ² 0 / 6 fail and the serial tests pass (S2.5–2.6).

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.

2 columns
TestResult
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 replayed115 × 10,000 nonces
Expected win rate45.58%, exact, from the 2³² enumeration
Early window vs the restNonces 0–49 vs 50–9,999
Seeds flagged4 / 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
tests/steps/simulation.ts · Step 18, both parts recomputed · Verified
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++;}
Result: Aggregate z = +0.91 and 4 / 115 seeds flagged (p = 0.83): no sign of server-seed cherry-picking.
Power and the structural defence: One seed's 50 bets are too few to judge it (standard error about 18% per seed), so the decision rests on the aggregate and the forward replay. The structural defence is the player-set client seed: Duel commits to the next server seed before it sees the client seed you send at rotation, so it can't evaluate a seed against a client seed it doesn't know. A client seed it can predict, such as one reused across rotations, removes that protection.
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.

Cluster Pays Anywhere + Wild Substitution (Step 19) — illustrated flow
src/cluster.ts · findClusters · Verified
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;}
Result: 4,982 / 4,982 captured cluster paylines have count = (cells of the symbol) + (wilds on the grid). 0 mismatches.
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.

tests/steps/game-specific.ts · Step 21: Wild Substitution Rule · Verified
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`);}
Result: 410 / 410 such rounds credit every wild to every cluster, matching the help-panel rule "wilds contribute to every cluster win". Example: spin 1964428, where one wild lifts both 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.

4 columns
ScattersFree spinsCaptured triggersResult
3830 (organic)All match
41022 (2 organic + 20 buys)All match
5121 (organic)Match
6+140Not reached; from the published table
Total—5353 / 53 match
tests/steps/game-specific.ts · Step 22: Bonus Trigger · Verified
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`);  }}
Result: 53 / 53 triggers award the published number of free spins, and 53 / 53 final grids hold the scatter count Duel reports.
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):

2 columns
Mid-bonus scattersExtra spins awarded
33
45
58
610
Result: 53 sessions and 475 free spins examined. 1 retrigger: free spin 1987998 landed 3 scatters, and its bought session ran 13 spins, 10 + 3. 0 sessions exceeded the cap of 3. With one retrigger in the capture, the other rows of the table rest on the config and the enumeration.

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.
3 columns
CheckCoverageResult
Buy disclosure flag (is_bonus_buy = true)20 / 20 buysPass
No cluster paylines on the buy spin20 / 20 buysPass
Exactly 4 scatters (buy_scatter_count 4)20 / 20 buysPass
Exactly 10 free spins awarded20 / 20 buysPass
Free spins from the buys recomputed and paid exactly203 / 203 free spins (200 + 3 from one retrigger)Pass
Bonus-buy RTPNot certified: the buy spin is cannedNot tested
Result: All 20 captured buys delivered the disclosed structure: 4 scatters, the 3× scatter pay and 10 free spins. Their 203 free spins reconcile through the seed chain. The player still trusts that the canned spin pays its 4-scatter award; all 20 did.
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.

Payout Reconciliation (Steps 7, 8, 26) — illustrated flow
4 columns
CheckFormulaCapturedResult
Step 7 — Payout MathΣ base_payout × max(bomb, 1) = amount_won, in integer cents6,205 / 6,205 non-buy entries0 mismatched
Step 7 — Coins fieldamount_won_coins = round(amount_won × rate, 2 dp)6,225 / 6,225 entries0 mismatched
Step 8 — Multiplier Provenancepayline multiplier = paytable[symbol][min(count, 12)]4,985 / 4,985 paylines0 mismatched
Step 26 — Free-Spin PayoutΣ base_payout × max(bomb, 1) = amount_won, per free spin475 / 475 free spins0 mismatched
tests/steps/payouts.ts · Step 7: Payout Math · Verified
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++;
Result: Every captured spin was paid exactly what the rules give, to the cent: 6,205 non-buy entries, 4,985 payline multipliers and 475 free spins, with 0 discrepancies.
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.

Bonus Multipliers (Steps 26, 27) — illustrated flow
Result: Multiplier symbols: 935 in the bonus game, 0 in the base game. All 14 published values were seen, none outside the set. 475 / 475 free spins pay Σ 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.

2 columns
ItemValue
Entries within 5,000×6,225 / 6,225
Bonus sessions within 5,000×53 / 53
Largest served win630× 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 removesAt most 0.0005 pp of the whole game
Chance a session reaches the cap3.9 × 10⁻⁷ (8 spins) to 8.1 × 10⁻⁷ (14 spins)
Note: The cap was never reached in the capture, so how Duel settles a win at the cap is not observed. What the session cap removes from the RTP is not enumerated.
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.

3 columns
SourceSampleResult
Base-game spins (with scatter pays)5,73056.87% RTP; Pass 1 reference 55.71%, z = +0.91
Base-game hit rate2,619 / 5,730Fits the exact 45.58% (p = 0.86)
Organic triggers33 / 5,7300.576%; fits the exact 1 in 227.1 (p = 0.16)
Live symbol frequencies5,730 first dealsFit the published weights on all 6 reels
Organic bonus sessions33Average 104.1× the trigger stake; exact expectation 99.53×
Bought bonus sessions20Average 95.2× the stake with the 3× buy-spin pay; exact expectation 125.0×
Variance note: Both session averages are within 1.6 standard errors of their exact expectations (organic z = +0.20, buy z = −1.53).
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.

Result: 30 / 30 Phase B bets reproduce their grids and are paid exactly from the same paytable. No stake-dependent payout adjustment at the captured stakes.
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)
5 columns
RoundClusterCountMultiplierPayout
0cluster_symbol_1_88 (7 symbol_1 + 1 wild)0.4×$0.08
0cluster_symbol_7_88 (7 symbol_7 + 1 wild, same wild as above)1.8×$0.36
1cluster_symbol_3_88 (7 symbol_3 + 1 wild)0.6×$0.12
2cluster_symbol_4_88 (8 symbol_4, no wild on grid this round)0.7×$0.14
3(no cluster — cascade terminates)——$0.00
Sum———$0.70
Trace · spin 1964428 · Verified
// 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 = 8
Result: Spin 1964428 exercises the payout sum (Step 7), the paytable lookup (Step 8), the cluster count (Step 19) and wild sharing (Step 21) in one bet, and all its rounds reproduce from (server seed, client seed, nonce).
Live Game4 cluster wins: $0.08 + $0.36 + $0.12 + $0.14 = $0.70 · amount_won = $0.70
Verifier4 cluster wins: $0.08 + $0.36 + $0.12 + $0.14 = $0.70 · expected = $0.70
Technical Evidence & Verification5 sections
4.19Evidence Coverage Summary13 checks
3 columns
Verification AreaCoverageResult
Anti-circularity (Step 16)Simulation scored against the exact figure; 2 / 2 wrong trigger rules rejectedPass
Enumeration integrity (Steps 29–31)Base and bonus 2³² artifacts and the 4 session artifacts match their pinsPass
Enumerated RTP (Step 32)99.9720%, re-derived from the artifacts on every runPass
RTP claim (Step 32)100% claim from game settings; −0.028 pp; ±0.1 pp bandPass
No edge applied (Step 10)6,225 / 6,225 edge_multiplier = 1Pass
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.83Pass
Payouts (Steps 7, 8, 26)6,205 / 6,205 entries; 4,985 / 4,985 multipliers; 475 / 475 free spinsPass
Game rules (Steps 19, 21, 22, 23, 27)4,982 clusters; 410 shared-wild rounds; 53 triggers; cap held; 935 multipliers bonus-onlyPass
Bonus buy (Steps 24, 25)20 / 20 flagged, 4 scatters, 10 free spinsPass
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 fitPass
Stake tiers without Zero EdgeFrom the config: 116 spin and 184 bonus brackets, 0.01% at $0.20Info
4.20Code References14 source files
2 columns
FilePurpose
src/enumerate-mt.tsExhaustive 2³² per-spin enumeration on the CPU (cuda/ holds the GPU kernel)
src/session-ev-exact.tsExact bonus-session EV by dense-lane convolution
src/rtp-claim.tsThe framework's RTP-CLAIM rule 1.2.0
src/rtp-settings.tsThe claim (100% flat, game settings) and the RTP table for this package
src/simulate.tsMonte Carlo: 30M base spins with integrated sessions, Pass 2 forward replay
src/paytable.tsThe published paytable, reel weights and multiplier weights
src/cluster.tsfindClusters (counted clusters with wilds) and countScatters
tests/steps/enumeration.tsSteps 29–32: artifact pins and the headline RTP derivation
tests/steps/payouts.tsSteps 7–9: exact payouts, paytable provenance, bet-size invariance
tests/steps/dataset.tsSteps 10–11: edge_multiplier, config and paytable coverage
tests/steps/simulation.tsSteps 16–18: anti-circularity, Pass 1, Pass 2
tests/steps/game-specific.tsSteps 19–27: clusters, wilds, triggers, retriggers, buys, free-spin pay, multipliers
tests/steps/max-win.tsStep 34: the 5,000× cap
tests/steps/live-fit.tsStep 35: live-sample fit
4.21Datasets UsedSource artifacts
Primary dataset: data/groomers-van-smoke-test-1778204681017.json.gz: 6,225 entries across 5 phases · 117 seed records (116 revealed) · SHA-256 3034cb12…b967, checked before any step runs.
Enumeration artifacts: outputs/base-2pow32.json and outputs/bonus-2pow32.json (full 2³² distributions), outputs/bonus-session-ev-exact-{8,10,12,14}.json (session EVs) and outputs/bonus-2pow32-uncapped.json (the cap check). Pinned by SHA-256 and checked by Steps 29–31 and 33.
RTP claim table: outputs/rtp-claim-table.json: the claim, the one setting and the outcome, pinned by SHA-256.
Simulation output: outputs/simulation-results.json and outputs/rtp-convergence.html: Pass 1 and Pass 2, pinned.
Paytable and weights: The /rules paytable (data/raw/paytable-from-rules-endpoint.json, matching the in-game help panel) and the config's per-reel and multiplier weights (data/raw/groomers-van-config-v1.4.json), pinned.
Stake-tier schedule: scaling_edge in config v1.4: 116 spin brackets and 184 bonus brackets, read by S4.5 only.
4.22Verified Invariants14 invariants
2 columns
InvariantResult
Base RTP over all 2³² outcomes = 0.561376×, equal to the artifact's own sum / count and histogram meanPass
Base RTP + P(trigger) × E[session | trigger] = 99.9720%Pass
RTP claim holds: −0.028 pp from Duel's stated 100%, inside ±0.1 ppPass
The simulation is within 5 standard errors of the exact figure on all four components; wrong trigger rules are rejectedPass
edge_multiplier = 1 on every captured betPass
Every non-buy entry's amount_won = Σ base_payout × max(bomb, 1), in integer centsPass
Every payline multiplier = the published paytable at min(count, 12)Pass
Cluster count = symbol cells + wilds; every wild counts for every clusterPass
Every trigger awards the published spins; the reported scatter count equals the final grid'sPass
No session exceeds 3 retriggersPass
Every buy is flagged, cluster-free, shows 4 scatters and awards 10 free spinsPass
Multiplier symbols appear in the bonus game only, with published valuesPass
Every served win and session is within 5,000×Pass
Captured return consistent with the reference (z = +0.91); 4 / 115 seeds flagged, within chancePass
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:

reproduce-s4.sh · 5 lines · Verified
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.json
Expected 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 pin
Reproduction: npm 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.
05

Fairness Integrity Testing

Does the implementation maintain fairness under non-standard conditions?

Sections 1–4 prove the game is mathematically fair. Section 5 proves the implementation maintains integrity under non-standard conditions. We applied 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.

Fairness Integrity Testing

15pass2FLAG1N/A

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 /buy endpoint, /confirm-animation endpoint, 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
15pass2FLAG1N/A
  • 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 /buy endpoint, /confirm-animation endpoint, or free-spin session state (multiplier values, spins remaining, retriggers) be exploited via invalid inputs, injection, or replay?
4 / 4Nonce Integrity
5 / 5Seed Commitment
1 / 1Outcome Determinism
2 / 2Player Isolation
2 / 2Payout Integrity
3 / 3Game State Integrity (GV-specific)

Category Coverage

Nonce Integrity4/4
Seed Commitment5/5
Outcome Determinism1/1
Player Isolation2/2
Payout Integrity2/2
Game State Integrity (GV-specific)3/3
CheckResultEvidence
Nonce integrityPassSequential, 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 integrityPassLocked 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 determinismPassIdentical 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 isolationPassPer-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 integrityFlag1 / 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)Flag2 / 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
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 integrityPass
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 determinismPass
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 isolationPass
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 integrityFlag
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).
✓  Fairness Guarantees Verified · 2 Flags Disclosed

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.

3 columns
CategoryTestsWhat It Catches
Nonce Integrity4Sequence gaps, server-side nonce manipulation, invalid-input handling, session continuity
Seed Commitment5Mid-pair seed changes, seed reuse, predictable seed generation, cross-account seed pools, invalid client seed handling
Outcome Determinism2Non-deterministic outputs, outcome replay for duplicate payouts (N/A for single-call games like Groomer's Van)
Player Isolation2Cross-round correlation, cross-user outcome dependence
Payout Integrity2Parameter enforcement at /spin boundary, server-side computation of grid / multipliers / payouts under field injection
Game State Integrity (GV-specific)3Buy-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.

3 columns
SeverityMeaningAction
PASSTest passed — no issue detectedNone
N/ATest not applicable to this game typeNone
FLAGAnomaly detected, documented for transparencyDisclosed
HARD FAILFairness guarantee cannot be confirmedCertification blocked until remediated
2 columns
ConditionConsequence
Nonce gap or duplicate within seed pairOutcome sequence integrity broken
Server seed changed mid-seed-pairCommit-reveal guarantee broken
Grid recomputation mismatchUndisclosed inputs affecting outcome generation
Client seed not used in HMACPlayer has no influence on outcomes
Grid changes during a cascade chainPer-cascade manipulation possible
/buy or /confirm-animation accept cross-account spin IDsGame state isolation broken
Free-spin session state mutable via injected fieldsMulti-step state corruption
Hard fail criteria: Any single hard fail = NOT PROVABLY FAIR. The audit cannot proceed past a hard fail without operator remediation and re-verification.

18 tests · 15 pass · 2 flag · 1 N/A

Nonce Integrity4/4
FI-NONCE-001Pass

Each 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-002Pass

Nonce progression cannot be manipulated by client

S1, Step 4 — server controls nonce assignment; no captured bet shows a client-overridden nonce

FI-NONCE-003Pass

An 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-004Pass

Nonce 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-001Pass

Invalid/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-002Pass

Seed 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-003Pass

Server 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-004Pass

No 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-005Pass

Seeds 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-001Pass

Identical 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/A

Outcomes 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-001Pass

RNG 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-002Pass

No 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-001Flag

Game 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-002Pass

Multiplier/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-001Pass

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

4 columns
Test IDCategoryVerification SourceStatus
FI-NONCE-001NonceS1, Step 4 (data-driven)Pass
FI-NONCE-002NonceS1, Step 4 (data-driven)Pass
FI-NONCE-003NonceAPI probePass
FI-NONCE-004NonceS1, Step 4 (data-driven)Pass
FI-SEED-001SeedAPI probePass
FI-SEED-002SeedS1, Steps 3 & 6 (data-driven)Pass
FI-SEED-003SeedS1, Step 1 (data-driven)Pass
FI-SEED-004SeedAPI probePass
FI-SEED-005SeedAPI probePass
FI-OUTCOME-001DeterminismS3, Step 5 + Step 28 (data-driven)Pass
FI-OUTCOME-002DeterminismArchitecture reviewN/A
FI-ISO-001IsolationS2, Step 17 (data-driven)Pass
FI-ISO-002IsolationFollows from FI-SEED-004Pass
FI-PAYOUT-001PayoutAPI probeFlag
FI-PAYOUT-002PayoutAPI probePass
FI-GV-BUYBONUS-001Game State (GV)API probeFlag
FI-GV-CONFIRM-001Game State (GV)API probePass
FI-GV-BONUS-001Game State (GV)API probePass
Method breakdown: 8 tests confirmed via the data-driven verification suite (S1–S4 evidence) and architectural analysis. 9 tests verified via live API probes against the running game: 7 pass, 2 are flagged input-validation gaps (FI-PAYOUT-001 at /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:

3 columns
PropertySourceFinding
116/116 revealed seeds verified (117 seed entries incl. 1 active)S1, Step 1Commit-reveal chain intact
116/116 next-seed links verifiedS1, Step 2Seed rotation chain intact
6,205/6,205 byte-equal grid reproductions (all but the 20 bonus buys)S3, Step 5No post-RNG conditional logic, grid fixed at round start
4,323/4,323 cascade rounds byte-equalS3, Step 28Multi-cascade determinism intact (129,690 cells reproduced)
Anti-circularity (2³² enumeration)S4, Step 1699.9720% RTP computed exactly from primitives by full 2³² enumeration
Cherry-pick detection (forward-replay)S4, Step 18115 committed seeds replayed 10,000 nonces each — 4/115 flagged (p = 0.8321), no seed pre-selection
99%+ client seed influenceS1, Step 6Player entropy is genuine
475/475 free spin payouts reconciledS4, Step 26Bonus-session payout integrity intact
935/935 multiplier symbols confined to bonus_gameS4, Step 27Sticky-multiplier scope honoured — 0 multiplier appearances in base_game
20/20 buy-bonuses honestS4, Steps 24 & 25Buy-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.

reproduce-s5-data.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-van && git checkout v1.2.1npm cinpm run verify

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

fi-api-probes.sh (private testing harness)
[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)
API probes: All 9 API probe tests completed. Per-test evidence — HTTP request/response bodies, server-assigned spin IDs, accepted/rejected classifications, and observed-vs-expected behaviour — is retained in PF.org's private adversarial-testing archive and summarised in the integrity test review document. The testing harness itself is kept private. Two findings (FI-PAYOUT-001, FI-GV-BUYBONUS-001) are disclosed to Duel.com — both are input-validation gaps, neither affects fairness.
06

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.

Independent Result Verification

4 Stepsto verify any spin

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
4 Stepsto verify any spin
  • 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
From Bet to Independent Verification — 4-step flow for Groomer's Van — illustrated flow
Server SeedRevealed after rotation
Client SeedPlayer-controlled input
NonceRecorded bet sequence
Round Indexfree spins only: the spin's number in its bonus
  1. 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. 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. 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. 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
6.1Step 1: Save the commitment

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.

6.2Step 2: Rotate and check the reveal

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.

6.3Step 3: Recompute the spin

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

6.4Step 4: Confirm it matches

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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent (audit codebase)
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
What you enterSeeds, nonce, round, and each reel's weights as JSON (the page doesn't fill them in)Seeds and nonce
Trust modelRequires trusting the casinoOpen-source, version-controlled
Checked by this audit: Duel's Verify-tab code, run unmodified as a second check on all 6,205 recomputable entries: 0 differ. ProvablyFair.org's verifier code, pinned by SHA-256, agrees on all 5,730 base spins (Step 5).
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.

verify-groomers-van.js · Standalone Node.js
// 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.5
6.9Python Verification Script

The same verification in Python 3 (standard library only). Its output is identical:

verify_groomers_van.py · Standalone Python
# 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
5 columns
Free spinSpin idCascadesMultiplier totalWon
1197627113$1.02
2197627614$0.48
31976282025 (no win)$0.00
4197628725$1.20
5197629210 (counts as 1)$0.08
6197629636$1.92
7197629816$0.48
8197630122$0.48
9197630424$0.88
10197630526$1.08
Total$7.62
Result: Each free spin's win is Σ 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.
From Bet to Independent Verification — 4-step flow for Groomer's Van — illustrated flow
How it works
  1. 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. 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. 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. 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
6.1Step 1: Save the commitment

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.

6.2Step 2: Rotate and check the reveal

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.

6.3Step 3: Recompute the spin

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

6.4Step 4: Confirm it matches

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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledIndependent (audit codebase)
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
What you enterSeeds, nonce, round, and each reel's weights as JSON (the page doesn't fill them in)Seeds and nonce
Trust modelRequires trusting the casinoOpen-source, version-controlled
Checked by this audit: Duel's Verify-tab code, run unmodified as a second check on all 6,205 recomputable entries: 0 differ. ProvablyFair.org's verifier code, pinned by SHA-256, agrees on all 5,730 base spins (Step 5).
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.

verify-groomers-van.js · Standalone Node.js
// 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.5
6.9Python Verification Script

The same verification in Python 3 (standard library only). Its output is identical:

verify_groomers_van.py · Standalone Python
# 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
5 columns
Free spinSpin idCascadesMultiplier totalWon
1197627113$1.02
2197627614$0.48
31976282025 (no win)$0.00
4197628725$1.20
5197629210 (counts as 1)$0.08
6197629636$1.92
7197629816$0.48
8197630122$0.48
9197630424$0.88
10197630526$1.08
Total$7.62
Result: Each free spin's win is Σ 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.
✓  Any Player Can Reproduce Groomer's Van Results

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.

07

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.

Open-Source Audit Repository

v1.2.1release tag

Repository Details

Prerequisites

  • Node.js 22.x (.nvmrc)
  • npm
  • Git
v1.2.1release tag
github.com/ProvablyFair-org/duel-groomers-vanRelease v1.2.1 · original audit 6f9bfaf

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.

sh
git clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-vangit checkout v1.2.1npm ci npm test
Expected output
Passed:     34/35Hard fails: 0Flags:      1 (0 verdict-affecting, 1 capture-origin) CAPTURE-ORIGIN LIMITATIONS (disclosed, verdict-neutral):⚑ Step 4: Nonce Audit VERDICT: PROVABLY FAIR — Full Pass 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.json

Audit Reproducibility Pinning

Release
v1.2.1 (Framework 1.1)
Original audit
6f9bfaf3e9db8b139378b571a60f1095df9c8d69 (4 June 2026)
Node Version
22.x (.nvmrc, package.json engines)
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
3 columns
FileContentsSize
verification-results.jsonAll 35 step results, profile coverage, verdict~74KB
base-2pow32.json · bonus-2pow32.jsonThe 2³² per-spin distributions (base and bonus) the headline RTP comes from~27KB · ~712KB
bonus-2pow32-uncapped.jsonThe bonus 2³² without the 5,000× per-spin cap (cap check)~715KB
cpu-base-2pow32.json · cpu-bonus-2pow32.jsonThe CPU re-enumerations used for the CPU ↔ CUDA parity check~27KB · ~712KB
bonus-session-ev-exact-{8,10,12,14}.jsonExact session EV for each starting count: 97.5997×, 121.9996×, 146.3995×, 170.7994×~2.6MB each
rtp-claim-table.jsonRTP claim, the one setting and the outcome (PASS)~1.6KB
simulation-results.jsonPass 1 (30M spins, χ², serial tests, 100.06%) and Pass 2 (aggregate z, forward replay)~59KB
rtp-convergence.htmlSelf-contained convergence chart of the 30M Pass 1 run~206KB
bonus-session-ev.jsonAn 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
3 columns
StepTest NameReport Section
1Seed Hash IntegrityS1
2Commitment LinkageS1
3Hash Consistency Within EpochS1
4Nonce Audit (capture flag)S1, S5
5Outcome RecomputationS1, S2, S3
6Client Seed InfluenceS1, S2, S5
7Payout MathS4, S5
8Multiplier ProvenanceS4, S5
9Bet-Size InvarianceS3, S4, S5
10House Edge Audit (Zero Edge consistency)S4
11Config Completeness & Paytable CoverageS4
12Epoch SizeS1
13Population & Phase LabelsS3
14Dataset HashS1, S7
15Phase D Client Seed VariationS1, S3, S5
16Anti-CircularityS4
17Simulation Pass 1S2, S4
18Pass 2 Cherry-Pick DetectionS4, S5
19Cluster Pays AnywhereS4
20Tumble Cascade Structural IntegrityS3
21Wild Substitution RuleS4
22Bonus TriggerS4
23Retrigger BehaviourS4
24Cosmetic Buy-Spin DisclosureS4
25Buy-Bonus StructureS4
26Free-Spin Payout ReconciliationS4
27Bonus Multiplier SymbolS3, S4
28Cascade RNG Byte-Exact ReplayS2, S3
29Base 2³² artifact integrityS4
30Bonus 2³² artifact integrityS4
31Session-EV artifact integrityS4
32Headline game RTP derivationS4
33Artifact Integrity (pinned artifacts of record)S7
34Max-Win Cap & Payout Bounds (GROOMERS-14)S4
35Live-Sample Fit (informational, GROOMERS-22)S2, S4
reproduce-audit.sh
reproduce-audit.sh
# Clone the releasegit clone https://github.com/ProvablyFair-org/duel-groomers-van.gitcd duel-groomers-vangit checkout v1.2.1npm ci   # Node 22.x, as pinned in .nvmrc # Unit tests, the 35 scored steps and the reproduction gatenpm test # Optional: also re-run the 30M simulation and compare it with the pinned resultsnpm run test:full # This run's results (the committed evidence is never overwritten)cat outputs/run/verification-results.jsoncat outputs/run/diff.json
provablyfair.org/verify-bets/duel
This is an open-source audit. Every finding, dataset, and line of verification code is publicly accessible. Clone the repo at the release tag, run the tests, and check every claim yourself.
✓  Reproduced at v1.2.1

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:

2 columns
CodeMeaning
0PROVABLY FAIR — Full Pass, and this run reproduces the committed artifacts. A capture flag is printed and recorded but exits 0
1At least one hard fail, or a reproduction difference beyond tolerance
2At least one operator-origin FLAG — PROVABLY FAIR — Conditional Pass
5RTP 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
This run: exit 0 — PROVABLY FAIR — Full Pass, REPRODUCED.
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.

Verifier output, as run at v1.2.1 (Node 22.22.0) · Verified
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.json
7.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:

2 columns
FileSHA-256
data/groomers-van-smoke-test-1778204681017.json.gz (uncompressed)3034cb1284bc1a87d82a0d8f914b19d7f1a8f16894ffe601242bd29e3873b967
data/raw/groomers-van-config-v1.4.jsone08f41da9a1d2ab4a634e3f14dc2d52858520dc9620c327599cac1e5c09c2b87
data/raw/paytable-from-rules-endpoint.jsonc3479bf62ee9ed45896506db8972a9b338b693345db47633687af440b27ffcd1
outputs/base-2pow32.json0b890eef7153fcdf14c69d8559de8d3f50af558e5464974627db2103ee22d5a1
outputs/bonus-2pow32.jsone878256256cf59edb458d6ec0f5b1cc5ea6e2d45764636676362345d4cdfdb14
outputs/bonus-session-ev-exact-10.jsona03b4e024b1182ad62e64739e47069b2a4d302430f9153a9d1f26d8104072257
outputs/simulation-results.json4becfea46f75bb5715343cfad9ee0de64f5438eb6823975c981c7facb930c8cf
outputs/rtp-claim-table.json58de71cb6dc34e2e758bcc5596813a459cad8657c5c3d7b8a4b584b92895588a
outputs/verification-results.json629a057e617e6f8c68b184d138442e71238170f15e97b9771869fae297fcefcd

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
3 columns
ReleaseWhat changedVerdict
v1.0.0The original auditPROVABLY FAIR — Full Pass
v1.1.0Re-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 unchangedUnchanged
v1.2.0RNG code rebuilt from a written specification; Duel's Verify-tab code kept as a cross-check onlyUnchanged
v1.2.1Adds .gitattributes so a Windows clone stays byte-identical; no audit content changedUnchanged
Framework 1.1

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.

30Profile checks
23By scored steps
6By package checks
1 n/a · 6 partialMarked as such
4 columns
CheckCovered byCoverageWhat it covers
GROOMERS-01Step 1FullEvery revealed seed hashes to its commitment; every epoch with a bet resolves to a revealed seed
GROOMERS-02Step 2PartialAll 116 commitment links. Partial: the capture holds no link from before its first epoch
GROOMERS-03Step 3FullEpochs keyed by the rotation timeline; every bet carries its rotation's hash and client seed
GROOMERS-04Step 4FullNonces from 0, no reuse; every gap must be one of the 4 declared capture retries (capture flag)
GROOMERS-05Steps 12, 13FullEpoch sizes and the population (phases, modes, seed records) bound to the capture plan
GROOMERS-06Steps 6, 15PartialClient 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-07Step 5FullEvery non-buy entry recomputes its 30-cell first deal at exactly one nonce
GROOMERS-08Step 5FullDraw-bias bound exact (0) on all 13 weight totals
GROOMERS-09Package checkFullDuel's Verify-tab code run unmodified as a cross-check: outcome index, grid and multiplier values
GROOMERS-10Steps 19, 20, 21, 28FullCluster, gravity, wild and cascade rules: Steps 19, 20, 21 and the byte-exact cascade replay
GROOMERS-11Step 7FullPayouts exact in integer cents; the coins field checked against each bet's rate
GROOMERS-12Step 9PartialBet-size invariance on Phase B. Partial: 30 elevated-stake bets against the profile's 100
GROOMERS-13Steps 8, 14, 27FullPayline multipliers equal the pinned paytable; multiplier values in the published set
GROOMERS-14Step 34FullThe 5,000× cap from the config, applied by the enumerations; every served win within it
GROOMERS-15Step 11FullConfig completeness; 62 of 96 paytable cells reached live, the rest covered by the enumeration
GROOMERS-16—n/aNo response carries a balance amount, so there is no wallet delta to reconcile; the credits are checked instead
GROOMERS-17Steps 22, 23, 24, 25, 26, 27, 28FullTriggers, retriggers, buy disclosure and structure, free-spin pay and multiplier scope
GROOMERS-18Step 16FullThe 30M simulation scored against the exact enumeration, with negative controls
GROOMERS-19Steps 10, 32Fulledge_multiplier 1 on every bet, and the RTP derivation that carries the RTP claim
GROOMERS-20Step 17PartialPer-reel χ² and serial tests. Partial: the symbol counts and payout series don't ship
GROOMERS-21Step 18PartialPass 2 aggregate and forward replay. Partial: the per-nonce win counts aren't replayed, and no detection power is printed
GROOMERS-22Step 35FullLive symbol frequencies, hit rate and trigger rate against the exact figures (informational)
GROOMERS-23Package checkFullThe package’s S5 matrix, each row mapped to the scored steps
GROOMERS-24Step 5FullThe ProvablyFair.org verifier's code (pinned copy) run on every base spin
GROOMERS-25Package checkFullPlayer verification steps in order, with the commitment encoding and the free-spin inputs
GROOMERS-26Step 14FullDataset and operator files pinned by SHA-256
GROOMERS-27Steps 29, 30, 31, 33PartialThe 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-28Package checkFullFresh-clone reproduction record
GROOMERS-29Package checkFullMutation battery: every scored step has a killing mutation
GROOMERS-30Package checkFullLimitations register, load-bearing premises and numbered evidence
Partial coverage: GROOMERS-02, 06 and 12 are partial because the capture (7–8 May 2026) predates the September 2026 standard, and the client-seed tamper runs only on the 623 entries that publish an outcome index. GROOMERS-20 and 21 are partial because some simulation statistics are read as shipped and Pass 2 prints no detection power, and GROOMERS-27 because the enumeration files carry run metadata and no value domains are declared. GROOMERS-16 is n/a: no response carries a balance amount.