
Beef
Independent verification, backed by open-source code.
- Live bets verified
- 6,450
- 131 seed pairs · 6,000 + 450 rounds
- Verifier parity
- 100%
- 0 mismatched death-point sets
- Simulation roundsSimulated RTP 99.147%
- 4M
- Simulated RTP 99.147% · 4 difficulty configurations
- Proven RTP
- 99.2%
- All 61 settings · 0.8% house edge
Verification pipeline
Real bets. Independently reproduced.
Placed at Duel.com on 16 and 21 April 2026. Our own RNG code, rebuilt from the written spec, reproduces all 6,450 recorded outcomes.
Positions 0–19 · Cashed out after the recorded step
The casino result, reproduced.
- Casino outcome
- 5 safe steps · Cashed out
- Our reproduction
- 5 safe steps · Cashed out
- Recorded payout
- $0.0512
- Seed Hash IntegrityPass
- Commitment LinkagePass
- Hash ConsistencyPass
- Death-Point RecomputationPass
- Client Seed InfluencePass
- Payout MathPass
- Multiplier FormulaPass
- Win ConditionPass
- Phase C Bet-Size InvariancePass
- Config CompletenessPass
- House Edge AuditPass
- Phase LabelsPass
- Dataset HashPass
- Epoch SizePass
- Anti-CircularityPass
- Phase D Client-Seed VariationPass
- Simulation Pass 1Pass
- Cherry-Pick DetectionPass
- Multi-Step Multiplier ChainPass
- Phase E Death-Point RecomputePass
- Cash-Out Payout CorrectnessPass
- Artifact IntegrityPass
- Multiplier MonotonicityPass
- Live-Sample FitPass
The repo is the credential. You don’t have to take our word for it: the audit ships as code. Check out release v1.2.1 and run npm test to re-run it: 25 unit tests, 25 scored steps, 6,450 live rounds re-verified, and the results compared with the committed ones.
This audit independently validates the Beef game operated by Duel.com under ProvablyFair.org Framework 1.1. We placed 6,450 real bets in April 2026, 6,000 single-step rounds and 450 multi-step rounds, and recomputed every outcome with our own code, rebuilt from a written spec. Release v1.2.1 re-runs that evidence: 24 of 25 scored steps pass, and one carries a capture flag (Step 4).
Audit Verdict
| Check | Result | Evidence |
|---|---|---|
| Overall Status | Pass | |
| Proven RTP | Pass | 99.2% on all 61 difficulty and cash-out settings · RTP claim rule: 0 of 61 outside ±0.1 pp of the published 99.2% · 99.1468% simulated (4M rounds) |
| Live ↔︎ Verifier Parity | Pass | 6,450 / 6,450 death-point sets recomputed, 0 mismatches · ProvablyFair.org’s verifier code and Duel’s own Verify-tab code agree on every round |
| Commit-Reveal System | Pass | All 131 bet-bearing seeds match the commitments their bets were served under · 125 / 125 and 14 / 14 next-seed promotions link up · a consistency check; each commitment was recorded before its epoch’s first bet |
| Nonce Audit | Capture flag | Nonces count from 0 with no repeat in all 131 epochs. Two rounds our capture missed were reconstructed from the revealed seeds: limited by our capture script, not a Duel issue (Step 4) |
| Client Seed | Pass | Generated in the browser and submitted at rotation · a wrong client seed changes the full 20-tile shuffle on 6,000 / 6,000 bets |
| RNG Analysis | Pass | HMAC-SHA256 backward Fisher-Yates on 20 tiles, rebuilt from the written spec · rejection sampling, bias exactly 0 on all 19 ranges · no hidden inputs |
| Payout Logic | Pass | Every win pays C(20,k) / C(20−m,k) × 0.992 to relative 1e-12: 4,337 single-step wins and 202 multi-step cash-outs · all 1,085 ladder rungs match the raw ratio · every loss credits 0 |
| House Edge | Pass | effective_edge 0.8 on all 6,000 primary bets · $10 bets pay the same formula as $0.01 bets · the Beef config carries no stake tiers |
| Anti-Circularity | Pass | Theoretical RTP from first principles: survival × paid multiplier = 0.992 at all 61 settings, checked by counting all 2^20 death-point sets · no operator probability used |
| Fairness Integrity | Pass | 16 fairness integrity tests — all 16 pass (includes one Beef-specific multi-step state test) |
| Determinism | Pass | Same inputs, same death points on 6,450 / 6,450 rounds · npm test reproduces the committed results (exit 0) |
Overall StatusPass
Proven RTPPass
Live ↔︎ Verifier ParityPass
Commit-Reveal SystemPass
Nonce AuditCapture flag
Client SeedPass
RNG AnalysisPass
Payout LogicPass
House EdgePass
Anti-CircularityPass
Fairness IntegrityPass
DeterminismPass
What Was Audited
✓ Audited
- The RNG algorithm is deterministic and verifiable
- Revealed server seeds match the SHA-256 commitments their bets were served under
- Client seed is generated in the browser and players can change it at any time
- Nonces count up from 0 under each commitment with no repeat
- Death points are computed with HMAC-SHA256 and a backward Fisher-Yates shuffle with rejection sampling
- Outcomes are reproducible from server seed, client seed, nonce and difficulty
- Single-step and multi-step cash-outs pay C(20,k) / C(20−m,k) × 0.992 on all 4 difficulty levels
- The death-point set is fixed at round start; steps and cash-out timing do not change it
- Theoretical RTP is 99.2% on all 61 difficulty and cash-out settings, and the published 99.2% holds on every one
- Bet amount does not enter the RNG, and $10 bets pay by the same formula as $0.01 bets
- Players can independently verify every bet
What Audit Excludes
- Stakes other than the captured $0.01 and $10 — the same edge applies at every stake in the config (S4.3)
- Max win
- Rakeback, Zero Edge and promotions — 99.2% is the proven RTP; Duel’s 0.8% rakeback, added after the capture, is operator-side
- Seed rotation during an open round — no captured round spans a rotation
- Cross-account sampling
- Duel’s server code and seed generation — outcomes are verified from the captured rounds and their commitments
- Infrastructure or server security
- Wallet, payments, or operational systems outside game logic
What Audit Covers
| Area | Description |
|---|---|
| Commit-Reveal System | SHA-256 commitments, next-seed promotion, reveal on rotation; commitment timing from the capture records |
| Client Seed Origin | Browser-generated, player-controlled, submitted at rotation and echoed by the server |
| Seed Handling | Client seed control, nonce lifecycle, seed pair rotation |
| RNG Analysis | HMAC-SHA256 backward Fisher-Yates, rebuilt from the written spec; draw-bias bound; Duel’s Verify-tab code run as a second check |
| Payout Logic | Multiplier formula and config table, single-step and multi-step cash-outs at k = 2, 3 and 5, losses, bet-size invariance at $0.01 and $10 |
| Live Parity | Independent death-point recomputation of all 6,450 live rounds; ProvablyFair.org’s verifier code executed on every round |
| RTP Validation | Theoretical RTP from first principles, the RTP claim rule, 4M simulated rounds, cherry-pick screening (Pass 2) |
| Fairness Integrity | Standard integrity matrix — tests across commit-reveal, determinism, payout, isolation, and parameter enforcement |
What Audit Guarantees
- Every guarantee below applies at Beef’s single 0.8% edge: its config has no stake tiers, and every captured bet was placed at it
- Outcomes are deterministic and reproducible from the recorded inputs
- Live game results match independent recomputation for every captured round (6,450 / 6,450)
- The death-point positions of 4M simulated rounds are consistent with a uniform shuffle on all 4 difficulty levels
- Theoretical RTP is 99.2% on all 61 settings, derived from first principles: survival × payout multiplier = 0.992
- The published 99.2% RTP holds on all 61 settings within the ±0.1 pp band of the RTP claim rule
- The death-point set is fixed at round start and does not depend on how far the player walks
- The client seed is a genuine input: a wrong client seed changes the full shuffle on every bet
- The house edge is a flat 0.8% on every captured bet
- Multi-step cash-outs at k = 2, 3 and 5 pay the formula: 202 / 202 checked, 0 errors
- All scored steps pass apart from the Step 4 capture flag
References
Beef — Game Rules6 sections▶
Beef is a step-by-step survival game (commonly called Cross the Road). You choose a difficulty level — EASY, MEDIUM, HARD or EXPERT — which sets how many hidden death points lie on the 20-tile road ahead: 1, 3, 5 or 10. You walk the road one tile at a time; each safe step grows your multiplier, and stepping on a death point ends the round. You can cash out after any safe step. During a round you only learn where a death point is by stepping on it, but all of them were fixed before your first step. Higher difficulty is harder because more hidden death points means a bigger chance the next tile is one of them.
How to Play
1. Choose difficulty — Select EASY (1 death point), MEDIUM (3), HARD (5), or EXPERT (10). More death points means higher reward per safe step but a higher chance of hitting one.
2. Enter bet amount — Choose how much to wager.
3. Step forward — Each step moves you one tile along the road: tile 0, then 1, then 2. Each safe step grows the running multiplier.
4. Cash out or continue — After any safe step, choose to cash out at the current multiplier or push on for more.
5. Outcome — If you step onto a death point, the round ends and the bet is lost. If you cash out, payout = bet × multiplier at the current step count.
Win Conditions
The win condition in Beef depends on whether every stepped tile avoided the death-point set.
| Outcome | Condition | Example (difficulty=MEDIUM, k=3) |
|---|---|---|
| Safe step | Stepped tile is not in death-point set | Multiplier grows; player may cash out or continue |
| Cash out | Player stops after k safe steps | k=3 → stake × 1.6631 |
| Loss | Stepped tile is in death-point set | Round ends, bet is lost |
Risk vs Reward
The core mechanic of Beef is the tradeoff between difficulty level and safe-step risk.
- Difficulty controls risk per step — more death points means fewer safe tiles, higher multiplier growth per step, and a higher chance the next step ends the round
- Step count controls total multiplier — each additional safe step multiplies your running payout by the ratio
(20−k) / (20−m−k) - RTP is constant — every difficulty level and every cash-out point has the same theoretical RTP, 99.2%
Parameters
| Parameter | Value | Notes |
|---|---|---|
| Grid Size | 20 tiles | Fixed; all difficulty levels use this layout |
| Difficulty Levels | 4 (EASY, MEDIUM, HARD, EXPERT) | Player-selected; sets death-point count |
| Death Points by Difficulty | EASY=1, MEDIUM=3, HARD=5, EXPERT=10 | Determines risk and multiplier curve |
| House Edge | 0.8% flat | The same at every difficulty and cash-out point; the config has no stake tiers |
| Theoretical RTP | 99.2% | Derived for all 61 difficulty and cash-out settings |
| RNG Algorithm | HMAC-SHA256 | Backward Fisher-Yates with bias-free rejection sampling; key = hex-decoded server seed |
Seed Formats
Every Beef bet uses three cryptographic inputs to generate the death-point layout.
| Seed Type | Format | Example | Purpose |
|---|---|---|---|
| Server Seed | 64-char hex (32 bytes) | fcf0584a… | Casino-provided randomness |
| Client Seed | Alphanumeric string | 8AgNlaGR1fxeiy93 | Player-contributed entropy |
| Nonce | Integer ≥ 0 | 0 | Per-round counter within the active seed pair |
serverSeedHashed (SHA-256 of the raw hex bytes) before play and revealed only on seed rotation. The HMAC key is the hex-decoded bytes of the server seed, not its UTF-8 text.Multiplier & Payout
The payout multiplier after k safe steps with m death points on a 20-tile grid is the combinatorial ratio of unrevealed configurations multiplied by the house-edge factor.
multiplier(k, m) = C(20, k) / C(20−m, k) × 0.992| Steps (k) | Death Points (m) | Raw multiplier | With 0.8% edge |
|---|---|---|---|
| 1 | 1 | 1.0526× | 1.0442× |
| 1 | 3 | 1.1765× | 1.1671× |
| 1 | 5 | 1.3333× | 1.3227× |
| 1 | 10 | 2.0000× | 1.9840× |
| 5 | 3 | 2.5055× | 2.4855× |
| 10 | 3 | 9.5000× | 9.4240× |
| 5 | 5 | 5.1628× | 5.1215× |
multiplier as the raw combinatorial ratio C(20,k)/C(20−m,k) without the edge, and no_house_edge_multiplier as the actual paid multiplier with the 0.992 factor applied. Payout is amount_won = amount × no_house_edge_multiplier. The naming is counter-intuitive: the field labelled no_house_edge_multiplier is the one that includes the house edge, and we verify against it throughout. Duel’s /api/v2/cross-road/config also publishes the table, 61 cells across the 4 difficulties, and every cell matches C(20,k)/C(20−m,k) × 0.992 (worst relative deviation 3.0 × 10⁻¹⁹).Why Provably Fair Matters▶
Traditional online casinos ask you to trust them. Provably fair cryptography replaces much of that trust with checks anyone can run. Every Beef round can be reconstructed from three inputs — the server seed, your client seed and the nonce — and the result you played should match the result anyone else computes from them.
- Outcomes are committed — the server seed’s SHA-256 hash is published before you play. A seed changed after your round would not match it.
- Your seed matters — the client seed is set in your browser, not by the casino. Changing it produces a different outcome for the same server seed and nonce, which shows your input is genuinely part of the computation.
- Verifiable by anyone — once the server seed is revealed on rotation, anyone with the inputs can recompute the result in a few lines of code. A tampered outcome would not recompute.
- Mathematically bounded — the published multiplier formula sets every payout. We derive from first principles that survival × payout multiplier equals 99.2% at every setting, so a changed edge would show.
High-Level Overview7 sections▶
This section walks through how a Beef bet moves through the system end-to-end — from the server seed commitment, through the bet and step flow, to the post-rotation verification step that closes the loop.
Checklist Reference
Commit-Reveal
| Check | What it shows |
|---|---|
| Server seed committed before play | A seed changed after the bet would not match the commitment |
| SHA-256 of revealed seed matches committed hash | Revealed seed is the one that was actually committed |
| Hash identical across all bets in an epoch | All bets within a seed pair share the same commitment |
Seed System
| Check | What it shows |
|---|---|
| Nonces are sequential within an epoch | No nonce skipping or reuse |
| Single client seed per epoch | Client seed cannot be silently rotated mid-epoch |
| Next-seed hash published before rotation | Each rotation activates the seed already published as next |
RNG & Parity
| Check | What it shows |
|---|---|
| Death-point positions recompute from seeds + nonce | Outcome is deterministic and verifiable |
| Independent verifier matches live API for every bet | No hidden inputs to the RNG |
| Death-point set invariant across step sequence | Layout fixed at round start, not rewritten per step |
Payout & RTP
| Check | What it shows |
|---|---|
| Multiplier matches C(20,k)/C(20−m,k) × 0.992 | Payout formula matches published rules |
| amount_won = amount × no_house_edge_multiplier | Payout arithmetic holds to relative 1e-12 |
| survival × payout multiplier = 0.992 at all 61 settings | RTP is fixed at 99.2% by construction, not observation |
Integrity
| Check | What it shows |
|---|---|
| Wrong client seed produces different death points | Client seed genuinely influences outcome |
| Bet size does not influence outcome | Phase C $10 bets pay by the same formula as $0.01 bets |
| Seed-selection screening (Pass 2) | No sign that the casino chose seeds to run cold |
High-Level Flow
A Beef round runs through five stages — from the casino committing to a server seed before you play, through the bet and steps, to the post-rotation verification that anyone can run.
1. Commit — Server generates server seed, publishes SHA-256 hash as serverSeedHashed. Player sees only the hash.
2. Seed pair activated — Client seed is browser-generated (or player-set). Nonce starts at 0. Next server seed is pre-committed.
3. Bet — Player selects difficulty and stake. The platform computes the death points with HMAC-SHA256 and a backward Fisher-Yates shuffle over the active seed pair and nonce.
4. Steps — Player walks the road one tile at a time. The multiplier grows with each safe step; the player may cash out at any point.
5. Rotate — On rotation the active server seed is revealed, and the seed already published as next becomes active.
6. Verify — Anyone with the server seed, client seed, nonce and difficulty can recompute the exact death-point set.
Provably Fair Model
Beef is a commit-reveal provably fair game. The casino commits to a server seed by publishing its SHA-256 hash before the bets it covers. When the seed pair is rotated, the casino reveals the server seed. Anyone can then check two things: that the revealed seed hashes to the published commitment, and that every round in that epoch recomputes from the seeds and nonce. With SHA-256 and HMAC-SHA256 sound, a changed seed or outcome is detectable. Two things remain outside the model: when a commitment was first shown, which rests on records such as this audit’s capture, and how the casino chose its seeds, which no commitment can show (S4.6).
Commit-Reveal Model
Beef uses a four-phase commit-reveal cycle. Each phase has a single, well-defined purpose, and every phase produces artefacts that can be verified after the fact.
Commit phase
Server generates a 32-byte random server seed, computes SHA-256(hex_bytes(serverSeed)) and publishes the hash as serverSeedHashed. The raw seed is kept secret. The hash of the next seed is published too.
Bet phase
Player places bets against the active seed pair. For each round the death points come from a backward Fisher-Yates shuffle of the 20 tiles, one HMAC-SHA256(key=hex_bytes(serverSeed), msg=clientSeed:nonce:t) per draw t. The nonce increments per round.
Reveal phase
The player rotates the seed pair, often while setting a new client seed. The previously active server seed is revealed, and the published next-seed hash becomes the active serverSeedHashed.
Verify phase
Anyone with the inputs can run HMAC-SHA256 and the shuffle independently and confirm the death points match the values the live API returned. The chain holds when each revealed seed hashes to its commitment.
Player-Controlled Client Seed
The client seed is the player’s lever into the RNG. It is generated in the browser, not on the server, and can be replaced at any time through a seed rotation.
- Browser-generated — Duel’s page draws a 16-character default from a 63-character alphabet with
crypto.getRandomValues - Player-editable — the player can replace it with their own value; rotating the pair reveals the server seed in use
- Materially influences outcome — a different client seed changes the full 20-tile shuffle on 6,000 / 6,000 tested bets
- Set after the commitment — the next server seed’s hash is published before the player submits a new client seed, so that server seed is fixed before the client seed is set
Nonce Lifecycle
The nonce is a per-round counter within the active seed pair. It starts at 0, increments by 1 per round and resets only on seed rotation. A round uses one nonce however many steps it takes: the death points are computed once, at the start, and the steps do not change them.
- Starts at 0 on every new seed pair
- Increments sequentially — no skipping, no reuse within an epoch
- Resets on rotation — every rotation produces a fresh nonce=0 sequence
- Shared across steps — all steps in a round use the same nonce; the death-point set is fixed at
noncetime
// Per seed pair, nonce sequence:// bet 1 → nonce=0// bet 2 → nonce=1// bet 3 → nonce=2// ...// On client seed change:// serverSeed revealed, new pair activated, nonce resets to 0Determinism Guarantee
Given serverSeed, clientSeed, nonce and the death-point count set by the difficulty, the death-point set is fully determined: no other randomness, no hidden input, no dependence on stake, timestamp or any other variable. The pipeline, as the package specifies it:
key = hexDecode(serverSeed)a = [0, 1, ..., 19]for t from 0 to 18: # draw index i = 19 - t r = i + 1 # ranges 20, 19, ..., 2 LIMIT = floor(2^32 / r) * r digest = HMAC-SHA256(key, clientSeed + ":" + nonce + ":" + t) j = (first 4-byte big-endian chunk v of digest with v < LIMIT) mod r swap a[i] <-> a[j]deathPoints = a[0 .. N-1], sorted ascendingTechnical Glossary7 categories▶
Terms and definitions used throughout this audit report, grouped by category.
Core Concepts
| Term | Definition |
|---|---|
| Provably Fair | A system where every game outcome can be independently verified from disclosed cryptographic inputs, with limited trust in the operator. |
| Commit-Reveal | A two-phase protocol: a party publishes a hash of a secret before play (commit) and reveals the secret afterwards (reveal). A matching hash shows the revealed secret is the committed one; when the hash was published must be recorded separately. |
| Determinism | A property where the same inputs always produce the same output. Beef is deterministic: (serverSeed, clientSeed, nonce, deathPointsCount) uniquely determines the death-point set. |
| Epoch | The set of bets placed under a single active seed pair, from activation to rotation. Also called a seed pair lifecycle. |
Seed System
| Term | Definition |
|---|---|
| Server Seed | A 32-byte random value generated by the casino. Represented as a 64-character hex string. Used as the HMAC key (hex-decoded). |
| Server Seed Hashed | SHA-256(hex_bytes(serverSeed)). The commitment published before play. |
| Client Seed | A player-controlled alphanumeric string, browser-generated by default. Part of the HMAC message. |
| Nonce | A per-round counter within the active seed pair. Starts at 0, increments per bet, shared across all steps in a single round, resets on seed rotation. |
| Draw index (t) | The counter in the HMAC message, one per shuffle draw (t = 0 … 18, so t = 19 − i). If all 8 chunks of a digest were rejected, Duel’s Verify-tab code increments it and draws again; the public sources do not settle that case, and no captured draw reaches it. |
| Seed Pair | The combination of one server seed and one client seed. A seed pair defines an epoch. |
| Next Server Seed Hash | The hash of the server seed that becomes active at the next rotation, published before it. Each rotation must activate it. |
| Phase-Boundary Marker | A seed-rotation entry that carries a valid commitment but no bets. Created by the capture script forcing a clean seed rotation at each phase transition. The 139-entry seed set contains 8 such markers (4 in the primary dataset, 4 in Phase E); the remaining 131 entries are bet-bearing epochs. |
Cryptographic Functions
| Term | Definition |
|---|---|
| SHA-256 | A 256-bit cryptographic hash function. Used here for server seed commitment: SHA-256(hex_bytes(serverSeed)) = serverSeedHashed. |
| HMAC-SHA256 | Hash-based message authentication code built on SHA-256. Takes a key and a message, returns a 256-bit (64-hex-char) digest. Used here for death-point position generation. |
| HMAC-SHA256 Backward Fisher-Yates | The full RNG pipeline: one HMAC-SHA256 per draw yields 4-byte chunks, and a backward Fisher-Yates shuffle uses them to reorder the 20 tiles. |
| Rejection Sampling | A technique for bias-free uniform sampling. A 4-byte chunk is accepted only below floor(2^32 / range) × range, a whole number of ranges, so every index in the range is equally likely. |
Verification Terms
| Term | Definition |
|---|---|
| Parity | Agreement between the live game’s reported outcome and an independent recomputation from the same inputs. 100% parity means zero mismatches. |
| Recomputation | Running the audit’s standalone RNG implementation on captured seed triples and comparing the output to the live API response. |
| Anti-Circularity Proof | A proof that RTP is not an empirical observation but a mathematical identity — winChance × payoutMult = 0.992 by algebraic cancellation, independent of any simulation. |
| Hypergeometric Distribution | The probability distribution describing sampling without replacement. For Beef, the survival probability after k safe steps with m death points on a 20-tile grid is C(20−m, k) / C(20, k) — the ratio of safe-tile combinations to total combinations. Combining with the multiplier C(20, k) / C(20−m, k) × 0.992 yields the fixed RTP identity. |
| Cherry-Pick Detection (Pass 2) | A statistical test over the revealed casino seeds that checks whether a seed’s first nonces behave differently from the rest: the pattern seed pre-selection would leave. Each rule is a count over the seeds with a stated false-alarm rate. |
Game Mechanics
| Term | Definition |
|---|---|
| Grid Size | The total number of tiles on the Beef board. Fixed at 20 for all difficulty levels. |
| Difficulty Level | One of four settings (EASY, MEDIUM, HARD, EXPERT) that determines how many of the 20 tiles are death points (1, 3, 5, 10 respectively). |
| Death Point | A tile position that ends the round on contact. Placed by the Fisher-Yates shuffle; count determined by difficulty level. |
| Step | Moving one tile along the road. A safe step grows the multiplier; a death point ends the round. |
| Multiplier Chain | The sequence of running multipliers as a player steps through tiles: m₁, m₂, ..., mₖ. Each step satisfies mₖ = C(20,k) / C(20−m,k) × 0.992. |
| Cash-Out | Stopping after k safe steps and collecting amount × mₖ. Only available after at least one safe step. |
| Death-Point Set Invariance | The property that the death-point set is fixed at round start and does not change based on which tiles the player steps on, or in what order. |
Audit Terms
| Term | Definition |
|---|---|
| Fairness Integrity (FI) Matrix | The standard test matrix applied to every audit, covering commit-reveal, determinism, payout, isolation, and parameter enforcement. Documented in S5. |
| Chi-Squared Test | A goodness-of-fit test comparing observed distributions (e.g., death-point positions, win counts) to theoretical expectations. Used with Bonferroni correction where multiple configurations are tested. |
| Bonferroni Correction | A multiple-comparison adjustment: when testing N hypotheses at significance α, the per-test threshold is α/N. Prevents false positives from mass testing. |
| Point-in-Time Audit | An audit verdict that applies to the code and configuration in force at the audit date. Subsequent changes are outside scope unless re-certified. |
| Framework 1.1 | The ProvablyFair.org audit framework this release is certified under. Releases under it carry the RTP claim rule, game profile coverage, capture flags and the reproduction gate. |
| RTP Claim Rule | RTP-CLAIM 1.2.0: the RTP figure a casino publishes is held against the true RTP of every setting it covers, within ±0.1 pp. A house-side miss makes the verdict RTP FIGURE OVERSTATED (exit 5). |
| Capture Flag | A flag raised by a limitation of our own capture, not the operator. It is disclosed and verdict-neutral: here, two rounds our capture missed, reconstructed from the revealed seeds (Step 4). |
| Game Profile | The framework’s list of checks for a game type: the 30 checks of the Beef profile 1.0.2. Each is covered by a scored step, a package check, or marked n/a with a reason. |
| Reproduction Gate | Every run writes to outputs/run/ and is compared with the committed results: integers and strings exactly, other values within 1e-14 absolute + 1e-12 relative. A difference beyond that exits 1. |
Data Formats
| Term | Definition |
|---|---|
| beef-master-6000bets.json | Primary capture dataset. 6,000 rounds across Phases A–D: all four difficulty levels, EXPERT at volume, $10 stakes and player-set client seeds. All single-step (k = 1). SHA-256 pinned in S7. |
| beef-phaseE-450bets.json | Multi-step capture dataset. 450 rounds across 4 sub-phases (E1–E4) with cash-out targets of 2, 3 and 5 steps on all 4 difficulty levels. SHA-256 pinned in S7. |
| verification-results.json | Output of the 25-step verification suite: per-step status, details, data blocks and profile mappings. |
| simulation-results.json | Output of the two-pass simulation: Pass 1 (4M rounds on pinned auditor seeds, RTP and chi-squared) and Pass 2 (121 casino seeds, cherry-pick test). |
| rtp-claim-table.json | The RTP claim rule’s table: the exact RTP of all 61 settings against the published 99.2%. |
Seed, Nonce & Determinism
Can the casino change your outcome after you bet?
Every Beef round on Duel.com is fixed by four inputs: server seed, client seed, nonce and difficulty. Duel publishes the SHA-256 hash of the server seed (the commitment) and reveals the seed itself when you rotate. All 131 bet-bearing seeds hash to the commitments their bets were served under, and every rotation activated the hash Duel had published as next. These are consistency checks. That each commitment was shown before its bets rests on the capture’s own records, which stored every epoch’s commitment at the rotation that opened it, before its first bet.
What we verified
- All 131 bet-bearing server seeds hash to the commitment their bets were served under
- All 139 rotations activated the hash Duel had published as next, with a link read before each capture began
- The capture recorded each epoch’s commitment at its opening rotation, before the epoch’s first bet
- Nonces count up from 0 under each commitment with no repeat; two rounds our capture missed carry a capture flag
- The client seed is set in the browser; a wrong client seed changes the full 20-tile shuffle on every bet
- Identical inputs always produce the same death points: 6,450 / 6,450 recomputed
What this means for you
- A seed swapped after your bet would not match the commitment shown before it
- Your client seed is a real input to every draw of the shuffle
- The death points are fixed before your first step; how far you walk does not move them
- Every bet can be rechecked from its seeds, today or months later
- Seed selection is screened statistically in S4.6, which finds no sign of cherry-picking
- All 131 bet-bearing server seeds hash to the commitment their bets were served under
- All 139 rotations activated the hash Duel had published as next, with a link read before each capture began
- The capture recorded each epoch’s commitment at its opening rotation, before the epoch’s first bet
- Nonces count up from 0 under each commitment with no repeat; two rounds our capture missed carry a capture flag
- The client seed is set in the browser; a wrong client seed changes the full 20-tile shuffle on every bet
- Identical inputs always produce the same death points: 6,450 / 6,450 recomputed
- A seed swapped after your bet would not match the commitment shown before it
- Your client seed is a real input to every draw of the shuffle
- The death points are fixed before your first step; how far you walk does not move them
- Every bet can be rechecked from its seeds, today or months later
- Seed selection is screened statistically in S4.6, which finds no sign of cherry-picking
Commitment matches revealed seedPass
Commitment shown before betsInfo
Next-seed promotionPass
Hash consistency within epochPass
Nonce sequencingCapture flag
Client seed originPass
Client seed influencePass
Deterministic outputPass
All 131 bet-bearing seeds match their commitments and every next-seed promotion links up. Each commitment was recorded before its epoch’s first bet; that timing rests on the capture’s records. Nonces run in order; two rounds our capture missed are reconstructed from the revealed seeds and carry a capture flag (Step 4). The same inputs always produce the same death points.
| Check | Result | Evidence |
|---|---|---|
| Commitment matches revealed seed | Pass | 121 / 121 primary rotations and every bet-bearing seed of both files hash to their commitments (Step 1). A consistency check, not a timestamp |
| Commitment shown before bets | Info | Recorded before the first bet in 121 / 121 primary and 10 / 10 Phase E epochs (capture timestamps, not scored) |
| Next-seed promotion | Pass | 125 / 125 primary and 14 / 14 Phase E rotations activate the published next hash; 124 / 124 and 13 / 13 forward links (Step 2) |
| Hash consistency within epoch | Pass | Epochs taken from the rotation timeline: every bet carries the commitment and client seed of the rotation active at its timestamp (Step 3) |
| Nonce sequencing | Capture flag | From 0 with no repeat in all 131 epochs. Two rounds our capture missed were reconstructed from the revealed seeds (Step 4 capture flag) |
| Client seed origin | Pass | Generated in the browser and submitted at rotation; the server echoes it and does not assign it. In this capture our script set the seeds |
| Client seed influence | Pass | A wrong client seed changes the full 20-tile shuffle on 6,000 / 6,000 bets; so does an empty one (Step 6) |
| Deterministic output | Pass | Same (serverSeed, clientSeed, nonce, difficulty) always gives the same death points: 6,450 / 6,450 (Steps 5 and 21) |
Commitment matches revealed seedPass
Commitment shown before betsInfo
Next-seed promotionPass
Hash consistency within epochPass
Nonce sequencingCapture flag
Client seed originPass
Client seed influencePass
Deterministic outputPass
All 131 bet-bearing seeds match their commitments and every next-seed promotion links up. Each commitment was recorded before its epoch’s first bet; that timing rests on the capture’s records. Nonces run in order; two rounds our capture missed are reconstructed from the revealed seeds and carry a capture flag (Step 4). The same inputs always produce the same death points.
How It Works — Seed, Nonce & Determinism8 sections
1.1Server Seed Commitment
Before an epoch’s bets, Duel publishes a commitment: serverSeedHashed = SHA-256(hexDecode(serverSeed)), where the server seed is a 64-character hex string (32 bytes) and the hash covers those 32 raw bytes, not the hex text. Every bet in the epoch is served under it. When you rotate, Duel reveals the seed and anyone can recompute the hash. Step 1 does this at the primary file’s rotations (121 of 124; the 3 that open Phases B, C and D reveal an earlier seed again), and the loader hash-checks the seed of every bet-bearing epoch in both data files before any outcome is recomputed. A match shows the revealed seed is the one the bets were served under. It is a consistency check; when the commitment was shown is covered in 1.4.
export function verifyHash(serverSeed: string, serverSeedHashed: string): boolean { let key: Buffer; try { key = decodeServerSeed(serverSeed); } catch { return false; } if (typeof serverSeedHashed !== "string") return false; const computed = createHash("sha256").update(key).digest("hex"); return computed === serverSeedHashed.toLowerCase();}Real Example from Live Data:
// bets[1].seed — round 7722773, Phase A, MEDIUM, nonce 1{ "serverSeedHashed": "b86763e0dc0f362d83e9bf1e6466f9be05434a502b7ea5fd1f96c2873b2bbcfe", "clientSeed": "8AgNlaGR1fxeiy93", "nonce": 1}// seeds[1].seed — the next rotation reveals the epoch's server seed{ "serverSeed": "fcf0584ae26b61deecc138adfc788ef039d69814c172a7d71667b5c9cdc661fb"}Verification:
const crypto = require('crypto'); const serverSeed = "fcf0584ae26b61deecc138adfc788ef039d69814c172a7d71667b5c9cdc661fb"; const hashedServerSeed = crypto .createHash("sha256") .update(Buffer.from(serverSeed, 'hex')) .digest("hex"); console.log(hashedServerSeed);// Output: b86763e0dc0f362d83e9bf1e6466f9be05434a502b7ea5fd1f96c2873b2bbcfe ✅1.2Commitment Linkage (Next-Seed Promotion)
Duel also shows the hash of the next server seed, in the fairness panel and the /api/v2/client-seed API. At every rotation the hash published as next (previousNextHash) must equal the hash that becomes active (newActiveHash), and each seed entry’s nextServerSeedHash must equal the following entry’s commitment. A pre-capture link anchors the chain: the first epoch’s commitment equals the next hash read before the capture’s first rotation. In this capture these are one comparison, not three: the capture scripts copied each rotation’s next hash into both fields. Like the hash match, the equalities show the seed records fit together, not when a hash was shown.
const chainFailures: string[] = [];let promoChecked = 0, promoOk = 0;for (const s of seeds) { if (!s.nextSeedPromotion) { chainFailures.push(`${s.context}: no promotion record — rotation not observable`); continue; } promoChecked++; if (s.nextSeedPromotion.previousNextHash === s.nextSeedPromotion.newActiveHash) promoOk++; else chainFailures.push( `${s.context}: previousNextHash ${s.nextSeedPromotion.previousNextHash.substring(0, 16)}… ≠ newActiveHash ${s.nextSeedPromotion.newActiveHash.substring(0, 16)}…`, );} let linksChecked = 0, linksOk = 0;for (let i = 0; i < seeds.length - 1; i++) { linksChecked++; if (seeds[i].seed.nextServerSeedHash === seeds[i + 1].seed.serverSeedHashed) linksOk++; else chainFailures.push( `link ${i}→${i + 1}: seeds[${i}].nextServerSeedHash ≠ seeds[${i + 1}].serverSeedHashed — forward link broken`, );} const first = seeds[0];const preCaptureLink = first !== undefined && first.nextSeedPromotion !== undefined && first.nextSeedPromotion.previousNextHash === first.seed.serverSeedHashed;if (!preCaptureLink) { chainFailures.push( 'pre-capture link absent: the first epoch\'s serverSeedHashed is not the hash that was outstanding as "next" before capture opened — the first epoch could have been chosen after observation began', );}1.3Hash Consistency Within Epoch
An epoch is the run of bets under one server seed. Step 3 takes epochs from the rotation timeline, not from the bets: each seed record opens a window at its timestamp, and a bet belongs to the latest rotation at or before its own. Every bet must then carry that rotation’s commitment and client seed. A seed swapped mid-epoch, a bet before the first rotation, or bets out of time order would all fail. The same check runs on both data files.
const windowBets = new Map<number, number>();const hashes = new Set<string>();let orphans = 0, wrongHash = 0, wrongClient = 0, outOfOrder = 0, lastT = -Infinity;let w = -1;for (const b of betList) { hashes.add(b.seed.serverSeedHashed); const t = Date.parse(b.at); if (!Number.isFinite(t) || t < lastT) outOfOrder++; lastT = Number.isFinite(t) ? t : lastT; while (w + 1 < timeline.length && timeline[w + 1].t <= t) w++; if (w < 0) { orphans++; continue; } const win = timeline[w]; if (b.seed.serverSeedHashed !== win.hash) wrongHash++; if (b.seed.clientSeed !== win.cs) wrongClient++; windowBets.set(win.i, (windowBets.get(win.i) ?? 0) + 1);}if (orphans > 0) issues.push(`${label}: ${orphans} bets before the first rotation record`);if (outOfOrder > 0) issues.push(`${label}: ${outOfOrder} bets out of time order`);if (wrongHash > 0) issues.push(`${label}: ${wrongHash} bets carry a serverSeedHashed other than the rotation active at their timestamp`);if (wrongClient > 0) issues.push(`${label}: ${wrongClient} bets carry a clientSeed other than the rotation active at their timestamp`);if (windowBets.size !== hashes.size) issues.push(`${label}: ${windowBets.size} bet-bearing rotation windows != ${hashes.size} distinct serverSeedHashed values in the bets`);if (windowBets.size !== expectedWindows) issues.push(`${label}: ${windowBets.size} bet-bearing windows != ${expectedWindows} declared in src/loader.ts`);const emptyWindows = timeline.filter(x => !windowBets.has(x.i)).map(x => x.i);return { issues, windows: windowBets.size, emptyWindows, orphans, wrongHash, wrongClient, outOfOrder };1.4Commitment Timing (Capture Records)
Steps 1–3 are consistency checks: a seed and hash pair made after settlement would pass them too. Timing comes from the capture. Every rotation response returns the new server_seed_hashed and next_server_seed_hash, and the capture stored them as the epoch’s seed entry before it placed the epoch’s first bet. The first epoch’s hash was already outstanding as next at the pre-capture reading, in both data files.
| Property | Value |
|---|---|
| Epochs with bets | 121 primary + 10 Phase E |
| Seed entry recorded before the first bet | 121 / 121 and 10 / 10 |
| Lead time before the first bet | 1.7 to 5.4 seconds (capture timestamps; measured, not scored) |
| Pre-capture reading | The next hash read before the first rotation equals the first epoch’s commitment (Step 2) |
1.5Client Seed Origin & Control
On Duel the browser generates the client seed and submits it with POST /api/v2/client-seed/rotate. The response carries only the new server_seed_hashed, the next_server_seed_hash, the echoed client_seed and the reset nonce: the server does not generate or assign the client seed. Duel’s live JavaScript draws the default seed one character at a time from a 63-character alphabet, using rejection-sampled crypto.getRandomValues, and pre-fills a 16-character value in the “New client seed” field (E05). Players can replace it with their own at any time, and it is an input to every HMAC-SHA256 computation.
Where this capture’s client seeds came from: our capture script set them itself. In Phases A–C and E it generated a 16-character seed per epoch with Math.random(); the 16 Phase D seeds were built as 'pfaudit' + Date.now() in base 36, which are clock-derived and therefore guessable.
8AgNlaGR1fxeiy932u03Imtz0NnpNAklsl0FFAHA20CUJBSytd4o47U8ntfUFG6kpfauditmo2180iw
pfaudit seeds from Phase D in the primary file, and 10 in Phase E. Evidence: the two data files and the client-seed origin capture (E05).1.6Nonce Incrementation
The nonce starts at 0 and counts up by one per round under the active server seed. One round uses one nonce, however many steps it takes, and the nonce resets when the seed pair is rotated. The 50-round epochs are the capture’s own rotation interval, not a Duel rule: Duel reveals a seed only when the player rotates.
In two epochs our capture missed one round on a retried request: nonce 25 of epoch b2dfe98473b69f19… in the primary file and nonce 31 of epoch 1dfe6dcfa0e64dc5… (E4) in the Phase E file. The next round in each epoch received the next nonce. Both revealed seeds hash to the commitments their epochs were served under, so the missed rounds’ death points can be reconstructed; the capture holds no served outcome for them, so they are not verified. Step 4 raises a capture flag. It is limited by our capture script, not a Duel issue, and it does not count against the verdict. Both gaps are declared individually, by epoch and nonce: any other gap would fail the step.
| Missed round | EASY | MEDIUM | HARD | EXPERT |
|---|---|---|---|---|
| Primary · b2dfe984… #25 | 13 | 13, 16, 19 | 1, 3, 13, 16, 19 | 1, 3, 5, 6, 7, 9, 10, 13, 16, 19 |
| Phase E · 1dfe6dcf… #31 | 11 | 5, 11, 13 | 0, 5, 11, 13, 15 | 0, 3, 5, 11, 13, 14, 15, 16, 17, 18 |
const auditNonces = (label: string, epochs: Map<string, BeefGame[]>, declared: Set<string>) => { for (const [hash, epochBets] of epochs) { const sorted = [...epochBets].sort((a, b) => a.seed.nonce - b.seed.nonce); const shortHash = `${label} ${hash.substring(0, 16)}`; const nonces = sorted.map(b => b.seed.nonce); const clientSeeds = new Set(sorted.map(b => b.seed.clientSeed)); if (clientSeeds.size !== 1) hardFailures.push(`epoch ${shortHash}: ${clientSeeds.size} distinct client seeds`); if (nonces[0] !== 0) hardFailures.push(`epoch ${shortHash}: first nonce is ${nonces[0]} (expected 0)`); const bad = nonces.filter(n => !Number.isInteger(n) || n < 0 || n > EXPECTED_EPOCH_SIZE - 1); if (bad.length > 0) hardFailures.push(`epoch ${shortHash}: nonces outside 0..${EXPECTED_EPOCH_SIZE - 1}: ${bad.slice(0, 3).join(', ')}`); const dups = nonces.filter((n, i) => i > 0 && n === nonces[i - 1]); if (dups.length > 0) hardFailures.push(`epoch ${shortHash}: duplicate nonce(s) ${[...new Set(dups)].slice(0, 3).join(', ')}`); const nonceSet = new Set(nonces); const maxNonce = Math.max(...nonces); for (let n = 0; n <= maxNonce; n++) { if (nonceSet.has(n)) continue; const key = `${hash}#${n}`; observedGaps.push(key); if (!declared.has(key)) { hardFailures.push(`epoch ${shortHash}: undeclared nonce gap at ${n}`); continue; } const ss = seedMap.get(hash); if (!ss) { hardFailures.push(`epoch ${shortHash}: declared gap at ${n} but the seed is unrevealed`); continue; } if (!verifyHash(ss, hash)) { hardFailures.push(`epoch ${shortHash}: declared gap at ${n} but the revealed seed does not hash to the commitment`); continue; } const byDiff: Record<string, number[]> = {}; for (const d of [1, 2, 3, 4]) byDiff[String(d)] = computeDeathPoints(ss, sorted[0].seed.clientSeed, n, DEATH_POINTS_BY_DIFFICULTY[d]); reconstructed.push({ file: label, epoch: hash, nonce: n, deathPointsByDifficulty: byDiff }); } }1.7Deterministic Mapping
The RNG is fully deterministic: the same server seed, client seed, nonce and difficulty always produce the same death points. The server seed is hex-decoded to 32 raw bytes and used as the HMAC-SHA256 key. The shuffle makes 19 draws, t = 0 … 18, and draw t messages clientSeed:nonce:t. Each draw reads the first 4-byte big-endian chunk below the rejection limit and swaps two tiles of a backward Fisher-Yates shuffle over the 20 tiles. The first m tiles of the shuffled array, sorted, are the death points: 1, 3, 5 or 10 by difficulty.
/** * §2 Step 3 (last line): death points are the tile VALUES held in the first m * slots of the shuffled array. Returned sorted ascending (the spec treats them * as a set; §2 notes the capture records the set sorted). */export function computeDeathPointsFromBuffer( keyBuffer: Buffer, clientSeed: string, nonce: number, deathPointsCount: number, gridSize: number = GRID_SIZE, census?: DrawCensus,): number[] { validateCommon(keyBuffer, clientSeed, nonce, gridSize); assertInt("deathPointsCount", deathPointsCount, 0, gridSize); const a = computePermutationFromBuffer(keyBuffer, clientSeed, nonce, gridSize, census); return a.slice(0, deathPointsCount).sort((x, y) => x - y);} /** §1.1: the server seed is 64 hex characters encoding 32 bytes. */function decodeServerSeed(serverSeed: string): Buffer { if (typeof serverSeed !== "string" || !/^[0-9a-fA-F]{64}$/.test(serverSeed)) { throw new TypeError("serverSeed must be 64 hexadecimal characters"); } return Buffer.from(serverSeed, "hex");} /** §2 Step 1: the HMAC key is the hex-decoded server seed (32 raw bytes). */export function computeDeathPoints( serverSeed: string, clientSeed: string, nonce: number, deathPointsCount: number, gridSize: number = GRID_SIZE,): number[] { return computeDeathPointsFromBuffer(decodeServerSeed(serverSeed), clientSeed, nonce, deathPointsCount, gridSize);}mines_positions, 0 mismatches, 0 skipped. No other input enters the computation.Real Bet Verified:
// Phase A, difficulty_level 2 (MEDIUM, 3 death points), nonce 1{ "serverSeed": "fcf0584ae26b61deecc138adfc788ef039d69814c172a7d71667b5c9cdc661fb", "serverSeedHashed": "b86763e0dc0f362d83e9bf1e6466f9be05434a502b7ea5fd1f96c2873b2bbcfe", "clientSeed": "8AgNlaGR1fxeiy93", "nonce": 1, "difficulty_level": 2, "current_step": [0], "mines_positions": [1, 9, 15], "multiplier": "1.176470588235294118", "no_house_edge_multiplier": "1.167058823529411765", "amount_won": "0.011670588235294118"}Verification:
// computeDeathPoints() from the verification script in S6.9, run under Node 22computeDeathPoints( "fcf0584ae26b61deecc138adfc788ef039d69814c172a7d71667b5c9cdc661fb", "8AgNlaGR1fxeiy93", 1, 3);// → [ 1, 9, 15 ] served mines_positions: [1, 9, 15] ✅1.8Client Seed Influence
All 6,000 primary bets were shuffled again with a wrong client seed (wrong-client-seed-test) on the same server seed and nonce, and again with an empty one. Step 6 compares the full 20-tile permutation, the whole RNG output, where a chance repeat has probability 1/20! (about 4 × 10⁻¹⁹), and requires every bet to change. The death-point set alone is a coarser view: at EASY a single death point lands on the same tile by chance 1 time in 20, so a few unchanged sets are expected and are reported, not scored.
| Statistic | Observed | Expected by chance |
|---|---|---|
| Full permutation changed (wrong seed) | 6,000 / 6,000 | 6,000 |
| Full permutation changed (empty seed) | 6,000 / 6,000 | 6,000 |
| Same death-point set by chance | 59 (58 EASY, 1 MEDIUM) | 61.3 |
const WRONG_CLIENT = 'wrong-client-seed-test';let tested = 0, changed = 0, s6Skipped = 0, projectionUnchanged = 0, emptyChanged = 0;const projectionUnchangedByDifficulty: Record<string, number> = {};const unchanged: string[] = [];for (const b of bets) { const ss = seedMap.get(b.seed.serverSeedHashed); if (!ss) { s6Skipped++; continue; } tested++; const key = Buffer.from(ss, 'hex'); const correct = computePermutationFromBuffer(key, b.seed.clientSeed, b.seed.nonce); const wrong = computePermutationFromBuffer(key, WRONG_CLIENT, b.seed.nonce); if (correct.join(',') !== wrong.join(',')) changed++; else if (unchanged.length < MAX_LISTED) unchanged.push(`${b.seed.serverSeedHashed.substring(0, 16)}…#${b.seed.nonce}`); if (computePermutationFromBuffer(key, '', b.seed.nonce).join(',') !== correct.join(',')) emptyChanged++; const dpc = DEATH_POINTS_BY_DIFFICULTY[b.response.difficulty_level]; const proj = (p: number[]) => p.slice(0, dpc).sort((x, y) => x - y).join(','); if (proj(correct) === proj(wrong)) { projectionUnchanged++; const d = String(b.response.difficulty_level); projectionUnchangedByDifficulty[d] = (projectionUnchangedByDifficulty[d] ?? 0) + 1; }}Technical Evidence & Verification5 sections
1.9Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Seed hash integrity (Step 1) | 121 / 121 primary rotations, 3 declared phase-boundary exemptions | Pass |
| Next-seed promotion (Step 2) | 125 / 125 and 14 / 14 rotations, pre-capture links present | Pass |
| Hash consistency (Step 3) | 121 + 10 bet-bearing windows from the rotation timeline | Pass |
| Commitment timing (capture records) | 121 / 121 and 10 / 10 recorded before the first bet | Info |
| Nonce audit (Step 4) | 131 epochs sequential; 2 capture retries reconstructed | Capture flag |
| Death-point recomputation (Steps 5, 21) | 6,000 / 6,000 and 450 / 450 | Pass |
| Client seed influence (Step 6) | 6,000 / 6,000 permutations change; empty-seed control 6,000 / 6,000 | Pass |
| Epoch size (Step 15) | 119 epochs of 50, plus the capture-retry pair of 1 and 49 | Pass |
1.10Code References7 source files
| File | Purpose |
|---|---|
| tests/verify.ts | Runs the 25 scored steps and the reproduction gate (Steps 1–6 cover S1) |
| tests/steps/commitment.ts | Steps 1–4: commitments, next-seed promotion, hash consistency, nonce audit |
| tests/steps/determinism.ts | Steps 5–6: death-point recomputation and client seed influence |
| src/rng.ts | HMAC-SHA256 backward Fisher-Yates and verifyHash, rebuilt from docs/ALGORITHM.md |
| src/loader.ts | Dataset loading, the SHA-256 check and the pinned population constants |
| capture/beef-capture.reference.js | Reference record of the capture script for all phases (not runnable) |
| capture/beef-capture-phaseE.reference.js | Reference record of the Phase E capture script (not runnable) |
1.11Datasets UsedSource artifacts
| Property | Value |
|---|---|
| File | data/beef-master-6000bets.json |
| Scope | Phases A–D, captured 16 April 2026: all four difficulty levels, EXPERT at volume, $10 stakes (Phase C) and player-set client seeds (Phase D). Single-step rounds. |
| Records | 6,000 bets, 125 seed entries, 121 bet-bearing epochs |
| SHA-256 | d654ef7c6195584501e9033202d5acad13a16d89d296baab8befc0240fb36d36 |
| Property | Value |
|---|---|
| File | data/beef-phaseE-450bets.json |
| Scope | Phase E, captured 21 April 2026: multi-step rounds with cash-out targets of 2, 3 and 5 steps on all four difficulty levels |
| Records | 450 bets, 14 seed entries, 10 bet-bearing epochs |
| SHA-256 | ef39d7f584cdb6d8057e846cdcb9b4ffcc60495bfcce8443d15bb910a9c51001 |
Fields used: bets — serverSeedHashed, clientSeed, nonce, difficulty_level, mines_positions, current_step, outcome, multiplier, no_house_edge_multiplier, amount_won, effective_edge, round_id; Phase E adds step_results[], cashed_out and reached_k; seed entries — serverSeed, serverSeedHashed, nextServerSeedHash, nextSeedPromotion.
1.12Verified Invariants8 invariants
| Invariant | Result |
|---|---|
| SHA-256(hexDecode(serverSeed)) equals the commitment at every primary rotation and for every bet-bearing seed | Pass |
| Each rotation activates the published next hash: 125 / 125 and 14 / 14, pre-capture links present | Pass |
| Every bet carries the commitment and client seed of the rotation active at its timestamp | Pass |
| Nonces sequential from 0 with no repeat in every epoch, one client seed per epoch | Pass |
| Two missed nonces reconstructed from commitment-matching revealed seeds | Capture flag |
| Same inputs produce the same death points for all 6,450 rounds | Pass |
| A wrong or empty client seed changes the full permutation on 6,000 / 6,000 bets | Pass |
| Client seed set in the browser and echoed, not assigned, by the server | Pass |
1.13Reproduction InstructionsRun locally
Clone the release, install dependencies and run the suite:
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test # Steps 1–6 cover S1Steps 1–6 cover Seed, Nonce & Determinism. Expected output:
[PASS] Step 1 — Seed Hash Integrity
[PASS] Step 2 — Next-Seed Promotion + Forward Commitment Chain
[PASS] Step 3 — Hash Consistency Within Epoch
[FLAG:capture] Step 4 — Nonce Audit
121 primary + 10 Phase E epochs: nonces from 0, no duplicates, all within 0..49, one client seed per epoch; 2 nonce gap(s), matching the 2 capture-retry gap(s) declared by identity in src/loader.ts (b2dfe98473b69f19…#25, Phase E 1dfe6dcfa0e64dc5…#31). Each revealed server seed hashes to the commitment its epoch's bets were served under, so the missed rounds' death points are reconstructed in this step's data block — but the rounds themselves were not captured and are NOT verified. Capture-origin FLAG: disclosed, verdict-neutral.
[PASS] Step 5 — Outcome Recomputation (Death Points)
[PASS] Step 6 — Client Seed InfluenceRNG & Entropy Model
Is the randomness genuinely random, or could it be rigged?
This section checks that Duel’s Beef randomness is cryptographically sound and unbiased and uses only the disclosed inputs. Each round is a backward Fisher-Yates shuffle of the 20 tiles driven by HMAC-SHA256: every one of its 19 draws takes a 4-byte chunk of its own HMAC and keeps only chunks below a whole number of ranges, so no tile is favoured. Our RNG code was rebuilt from a written specification by an implementer who never opened Duel’s code. It reproduces every captured round, and Duel’s own published Verify-tab code, run unmodified as a second check, agrees on all 6,450.
What we verified
- HMAC-SHA256 keyed by the server seed drives every draw of the shuffle
- Only the disclosed inputs affect outcomes: no timestamps, no server-side state, no hidden entropy
- Rejection sampling makes every swap index exactly equiprobable on all 19 ranges (2–20)
- The death-point positions of 4M simulated rounds are consistent with a uniform shuffle on all 4 difficulty levels
- Simulated outcomes show no sign of serial dependence on any difficulty level
- A wrong client seed changes the full shuffle on 6,000 / 6,000 bets
What this means for you
- Each death-point placement is drawn fairly and is not skewed by the reduction step
- Every tile is equally likely to hold a death point
- No hidden randomness or server-side state changes where death points appear
- Past rounds do not influence future ones
- The algorithm depends only on seeds you can verify
- HMAC-SHA256 keyed by the server seed drives every draw of the shuffle
- Only the disclosed inputs affect outcomes: no timestamps, no server-side state, no hidden entropy
- Rejection sampling makes every swap index exactly equiprobable on all 19 ranges (2–20)
- The death-point positions of 4M simulated rounds are consistent with a uniform shuffle on all 4 difficulty levels
- Simulated outcomes show no sign of serial dependence on any difficulty level
- A wrong client seed changes the full shuffle on 6,000 / 6,000 bets
- Each death-point placement is drawn fairly and is not skewed by the reduction step
- Every tile is equally likely to hold a death point
- No hidden randomness or server-side state changes where death points appear
- Past rounds do not influence future ones
- The algorithm depends only on seeds you can verify
RNG derived only from disclosed inputsPass
RNG code originPass
Operator code as a second checkPass
Modulo biasPass
Key encodingPass
Position uniformity and serial independencePass
Live-sample fitPass
The Beef RNG uses only the disclosed inputs, and its draws are exactly unbiased. Our code, rebuilt from the written spec, reproduces all 6,450 captured rounds, and Duel’s Verify-tab code agrees with it on every one. Simulated death points are consistent with a uniform shuffle and show no sign of serial dependence.
| Check | Result | Evidence |
|---|---|---|
| RNG derived only from disclosed inputs | Pass | HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:t) for draw t = 0 … 18; 6,450 / 6,450 rounds reproduce from these inputs alone |
| RNG code origin | Pass | Rebuilt from the written spec (docs/ALGORITHM.md) by an implementer who never opened Duel’s code; no operator code is ported |
| Operator code as a second check | Pass | Duel’s Verify-tab code (E06), run unmodified: its death points equal the served ones and ours on 6,450 / 6,450 rounds |
| Modulo bias | Pass | Accepted window a whole number of ranges on all 19 ranges, measured from the code: bias exactly 0 (Step 5) |
| Key encoding | Pass | The server seed is hex-decoded to 32 bytes, not used as text; the hex-text key matches 62 of 6,450 rounds, chance level |
| Position uniformity and serial independence | Pass | 4 × 1M simulated rounds: 0 / 4 position chi-squared and 0 / 4 serial failures at Bonferroni α/4 = 0.0025 (Step 18) |
| Live-sample fit | Pass | Death-point positions of the 6,450 live rounds fit the uniform lattice at all 4 difficulty levels (Step 25, informational) |
RNG derived only from disclosed inputsPass
RNG code originPass
Operator code as a second checkPass
Modulo biasPass
Key encodingPass
Position uniformity and serial independencePass
Live-sample fitPass
The Beef RNG uses only the disclosed inputs, and its draws are exactly unbiased. Our code, rebuilt from the written spec, reproduces all 6,450 captured rounds, and Duel’s Verify-tab code agrees with it on every one. Simulated death points are consistent with a uniform shuffle and show no sign of serial dependence.
How It Works — RNG & Entropy Model8 sections
2.1RNG Function Implementation
Each Beef round places m death points on the 20 tiles with a backward Fisher-Yates shuffle. The shuffle makes 19 draws, t = 0 … 18, swapping slot i = 19 − t with a slot j drawn over the range r = i + 1. Each draw computes its own HMAC-SHA256, keyed with the hex-decoded server seed, over the message clientSeed:nonce:t. It reads the digest as eight big-endian 32-bit chunks and takes the first chunk below floor(2^32 / r) × r; j = chunk mod r. The first m slots of the shuffled array, sorted ascending, are the death points.
This construction is taken from the written specification (docs/ALGORITHM.md), which was fixed from Duel’s public pages, the standard provably-fair construction, Duel’s public Beef config and the 6,450 live rounds, without Duel’s code. src/rng.ts was written from that specification alone.
| Component | Detail |
|---|---|
| Hash function | HMAC-SHA256, one call per draw |
| Key | Buffer.from(serverSeed, 'hex') — 32 bytes |
| Message | clientSeed:nonce:t, draw index t = 0 … 18 |
| Extraction | Eight 4-byte chunks per digest, each read as a big-endian uint32 |
| Rejection | chunk < floor(2^32 / r) × r — a whole number of ranges |
| Reduction | chunk mod r → swap index j ∈ [0, r) |
| Shuffle | Backward Fisher-Yates: slots 19 down to 1, ranges 20 down to 2 |
| Output | The first m slots, sorted → the death-point set |
/** * §2 Steps 1-2 for one draw t: a fresh HMAC per draw, then the first accepted * big-endian u32 chunk of that digest, reduced mod range. */function drawIndex( keyBuffer: Buffer, clientSeed: string, nonce: number, t: number, range: number, census: DrawCensus | undefined,): number { // §2 Step 1: message is UTF-8 of "clientSeed:nonce:t", all numbers plain base 10. const message = Buffer.from(`${clientSeed}:${nonce.toString(10)}:${t.toString(10)}`, "utf8"); const digest = createHmac("sha256", keyBuffer).update(message).digest(); for (let c = 0; c < CHUNKS_PER_DIGEST; c++) { if (c > 0 && census) census.cursorAdvances++; // §2 Step 2: bytes c*4 .. c*4+3 as an unsigned big-endian 32-bit integer. const v = digest.readUInt32BE(c * 4); if (census) census.chunksRead++; const idx = drawFromChunk(v, range); if (idx !== null) { if (census) census.draws++; return idx; } if (census) census.rejectedChunks++; } // §6 O1: the spec leaves "all 8 chunks rejected" unsettled; refuse to guess. throw new Error( `all ${CHUNKS_PER_DIGEST} chunks rejected for draw t=${t} (range ${range}); behaviour unspecified (ALGORITHM.md O1)`, );} function validateCommon(keyBuffer: Buffer, clientSeed: string, nonce: number, gridSize: number): void { if (!Buffer.isBuffer(keyBuffer)) throw new TypeError("keyBuffer must be a Buffer"); if (typeof clientSeed !== "string") throw new TypeError("clientSeed must be a string"); assertInt("nonce", nonce, 0, Number.MAX_SAFE_INTEGER); assertInt("gridSize", gridSize, 1, TWO_POW_32);} /** * §2 Step 3: backward Fisher-Yates over [0 .. gridSize-1]. Draw t (t = 0 .. gridSize-2) * swaps slot i = gridSize-1-t with a slot j drawn over range i+1. */export function computePermutationFromBuffer( keyBuffer: Buffer, clientSeed: string, nonce: number, gridSize: number = GRID_SIZE, census?: DrawCensus,): number[] { validateCommon(keyBuffer, clientSeed, nonce, gridSize); const a: number[] = Array.from({ length: gridSize }, (_, n) => n); for (let t = 0; t <= gridSize - 2; t++) { const i = gridSize - 1 - t; const j = drawIndex(keyBuffer, clientSeed, nonce, t, i + 1, census); const tmp = a[i] as number; a[i] = a[j] as number; a[j] = tmp; } return a;}The written specification it was built from:
LIMIT(r) = floor(2^32 / r) * rfor c in 0, 4, 8, …, 28: v = digest_t[c .. c+3] read as an unsigned 32-bit BIG-ENDIAN integer if v < LIMIT(r): return v mod r# all 8 chunks rejected: Open point O12.2Entropy Sources
All randomness comes from HMAC-SHA256 over three cleanly separated inputs:
| Source | Controlled By | Purpose |
|---|---|---|
| Server Seed | Casino | The HMAC key, committed by its SHA-256 hash before the epoch’s bets |
| Client Seed | Player | Player-contributed entropy in every HMAC message |
| Nonce | System | Makes each round unique; counts up within each epoch |
| Draw index t | Fixed | Separates the 19 draws of one shuffle (t = 0 … 18) |
How we know: all 6,450 rounds recompute from these inputs alone. A hidden entropy source would make some recomputations fail; none does.
Verified absent: no timestamps, no Math.random(), no external APIs and no server-side mutable state in the derivation: HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:t) only.
2.3Modulo Bias Analysis
Each swap index is chunk mod r, for ranges r = 20 down to 2. A plain modulo would favour low indices whenever 2^32 is not a multiple of r. The shuffle removes that bias with rejection sampling: it accepts only chunks below LIMIT(r) = floor(2^32 / r) × r, a whole number of ranges, and moves to the next chunk of the digest otherwise. Every accepted index is then exactly equiprobable.
For range = 20 (the first draw, t = 0):
LIMIT = floor(4,294,967,296 / 20) × 20
= 4,294,967,280 (= 214,748,364 × 20)
Rejected = [4,294,967,280 .. 4,294,967,295] = 16 values
Rate = 16 / 2^32 ≈ 3.7 × 10⁻⁹ per chunk
For ranges 2, 4, 8 and 16, 2^32 is already a whole number of ranges:
LIMIT = 2^32, nothing is rejected./** §2 Step 2: LIMIT(r) = floor(2^32 / r) * r; chunk values at or above it are rejected. */export function maxFairFor(range: number): number { assertInt("range", range, 1, TWO_POW_32); return Math.floor(TWO_POW_32 / range) * range;} /** * §2 Step 2: one 32-bit chunk to an index in [0, range), or null when the chunk * falls in the biased tail (v >= LIMIT(range)). */export function drawFromChunk(value: number, range: number): number | null { assertInt("value", value, 0, TWO_POW_32 - 1); if (value >= maxFairFor(range)) return null; return value % range;}Step 5 measures the bound from the code itself on all 19 ranges and finds every accepted window a whole number of ranges, so the worst bias is exactly 0 (an uncorrected modulo would lean by up to 4.66 × 10⁻⁹ relative). Over the 6,000 primary rounds, 114,000 draws read 114,000 chunks: no chunk was rejected (9.6 × 10⁻⁵ rejections expected).
Duel’s Verify-tab code differs from the specification in two places no captured round reaches. At ranges 2, 4, 8 and 16 its bound is 2^32 − r, so it also rejects the top r values; both windows are whole numbers of ranges, so both are unbiased. If all eight chunks of a digest were rejected, Duel’s code draws again on the next counter, while ours stops with an error: the public sources do not settle that case, and its probability is at most about 4 × 10⁻⁶⁸ per draw.
2.4RNG Isolation
Each draw within a round uses its own draw index in the HMAC message (clientSeed:nonce:t), and each round its own nonce, so every draw gets a separate HMAC output. HMAC-SHA256 is a pseudorandom function: without the secret server seed, one output gives no usable information about another. The derivation keeps no state between draws, rounds or epochs.
Evidence: the functions in 2.1 take (key, clientSeed, nonce, draw) explicitly, keep no class or module state and make no external calls, and the same inputs always return the same output. A live two-account probe in S5 found no server seed hash shared between accounts.
2.5Monte Carlo Simulation (4M Rounds)
A 4,000,000-round simulation (1,000,000 rounds at each difficulty) checks the shuffle’s death-point distribution at scale. It runs our RNG code on four pinned seed pairs, one per difficulty, generated once with crypto.randomBytes and fixed in the package so the run is reproducible.
| Difficulty | Position χ² (df 19) | p | Win rate | Expected |
|---|---|---|---|---|
| EASY (m=1) | 17.95 | 0.526 | 94.9942% | 95% |
| MEDIUM (m=3) | 23.53 | 0.215 | 84.9665% | 85% |
| HARD (m=5) | 20.18 | 0.384 | 74.9610% | 75% |
| EXPERT (m=10) | 8.78 | 0.977 | 49.9415% | 50% |
// ── Pinned simulation seeds — one unique pair per config (4 total) ──────────// Generated via crypto.randomBytes(32) / crypto.randomBytes(16). Pinned so the// simulation output is reproducible across runs.const SIM_SEEDS: Array<{ server: string; client: string }> = [ { server: 'e33ac56577654adb77e9ed4cad54142bb99f12a85b93ac4b473ec687631d584a', client: '857902ce8e141aff4bd073ede94cc708' }, { server: 'e2a6b8999929cb7a99313e7e8030c77913f656bdcd8b13e4138a7d83732f1018', client: '788fd3d35a196357da74e1f89a82bbaf' }, { server: 'e7fd02dd9662ad142310ab99a02ba70692d2a38b1024ccbbe9001d6633f01f45', client: '29cbc576e54475c5b5f835103da9bda4' }, { server: '3dda4af8d5357e02c72cd519b926edda4dfc778d6bdca163da3041b0b3889bf9', client: '0c013271e4ef52b6b1a2b438b92a1bb2' },];Method: chi-squared goodness of fit of the death-point frequency over the 20 tiles at each difficulty, scored at Bonferroni α/4 = 0.0025; serial independence by lag-1 autocorrelation and the runs test (2.6). The test counts the m death points of each round as independent draws. Corrected for drawing them without replacement, as Step 25 does for the live rounds, the p-values are 0.122 (MEDIUM), 0.143 (HARD) and 0.611 (EXPERT); all still pass.
2.6Serial Independence
Serial independence means consecutive rounds are not correlated: a win or loss on one round says nothing about the next. Two tests run on each difficulty’s 1,000,000-round win/loss series:
Lag-1 autocorrelation: the correlation r₁ between consecutive outcomes, near 0 for an independent series. A difficulty fails if |z| > 3.5, where z = r₁ × √n.
Wald-Wolfowitz runs test: counts the runs of consecutive wins or losses against the number expected for the observed win and loss counts. A difficulty fails at p < 0.0025 (α/4).
| Difficulty | r₁ | z | Runs p |
|---|---|---|---|
| EASY (m=1) | -0.00021 | -0.21 | 0.837 |
| MEDIUM (m=3) | -0.00028 | -0.28 | 0.780 |
| HARD (m=5) | 0.00048 | 0.48 | 0.628 |
| EXPERT (m=10) | -0.00062 | -0.62 | 0.536 |
export function runsTest(series: number[]): RunsTestResult { const n = series.length; if (n === 0) throw new Error('runsTest: empty series'); let n1 = 0; let runs = 1; for (let i = 0; i < n; i++) { const x = series[i]; if (x !== 0 && x !== 1) throw new Error(`runsTest: series[${i}] = ${x} is not a 0/1 outcome`); if (x === 1) n1++; if (i > 0 && x !== series[i - 1]) runs++; } const n2 = n - n1; const expected = (2 * n1 * n2) / n + 1; const varRuns = (2 * n1 * n2 * (2 * n1 * n2 - n)) / (n * n * (n - 1)); const z = varRuns > 0 ? (runs - expected) / Math.sqrt(varRuns) : 0; const pValue = 2 * (1 - normalCDF(Math.abs(z))); return { runs, expected, z, pValue };}2.7Live-Sample Fit (Step 25)
The live rounds give a smaller, real-world view of the same distribution. Step 25 counts where the death points of all 6,450 captured rounds fell, per difficulty, and tests the counts against the uniform 20-tile lattice. The Pearson statistic is corrected for drawing m distinct tiles without replacement. The step is informational: a deviation would be reported, not scored, because Step 5 ties every live round to the shuffle and Step 18’s simulation is consistent with a uniform one.
| Difficulty | Live rounds | Corrected χ² (df 19) | p |
|---|---|---|---|
| EASY (m=1) | 1,300 | 18.31 | 0.5020 |
| MEDIUM (m=3) | 1,500 | 37.84 | 0.0062 |
| HARD (m=5) | 1,350 | 7.58 | 0.9904 |
| EXPERT (m=10) | 2,300 | 18.17 | 0.5111 |
// ── 1. Death-point positions per difficulty ─────────────────────────────────────────────────────const positions: Record<string, { rounds: number; pearson: number; corrected: number; df: number; p: number }> = {};for (const d of DIFFICULTY_LEVELS) { const m = DEATH_POINTS_BY_DIFFICULTY[d]; const counts = new Array(GRID_SIZE).fill(0); let rounds = 0, malformed = 0; for (const b of [...primary, ...phaseE]) { if (b.response.difficulty_level !== d) continue; rounds++; const mp = b.response.mines_positions ?? []; if (mp.length !== m || new Set(mp).size !== m) { malformed++; continue; } for (const t of mp) { if (!Number.isInteger(t) || t < 0 || t >= GRID_SIZE) { malformed++; continue; } counts[t]++; } } if (malformed > 0) problems.push(`difficulty ${d}: ${malformed} round(s) without ${m} distinct in-range death points`); const expected = (rounds * m) / GRID_SIZE; const pearson = expected > 0 ? counts.reduce((s, o) => s + (o - expected) ** 2 / expected, 0) : 0; const corrected = pearson * (GRID_SIZE - 1) / (GRID_SIZE - m); const df = GRID_SIZE - 1; const p = chiSquaredPValue(corrected, df); positions[`difficulty${d}`] = { rounds, pearson, corrected, df, p }; if (rounds === 0) problems.push(`difficulty ${d}: no rounds`); else if (p < alpha) problems.push(`difficulty ${d} death-point positions p below ${alpha}`);}2.8Worked Example — Full RNG Trace
Real bet from the dataset: round 7722773, difficulty 2 (MEDIUM, m = 3), nonce 1. Recomputed from beef-master-6000bets.json; the first five of the 19 draws:
serverSeed = fcf0584ae26b61deecc138adfc788ef039d69814c172a7d71667b5c9cdc661fb
clientSeed = 8AgNlaGR1fxeiy93
nonce = 1
difficulty_level = 2 (MEDIUM, m=3)
current_step = [0]| t | i | range | HMAC[:8] | uint32 | j | swap |
|---|---|---|---|---|---|---|
| 0 | 19 | 20 | 5ed36ebf | 1,590,914,751 | 11 | pos[19]↔︎pos[11] |
| 1 | 18 | 19 | ee6377b7 | 3,999,496,119 | 14 | pos[18]↔︎pos[14] |
| 2 | 17 | 18 | 79caf915 | 2,043,345,173 | 5 | pos[17]↔︎pos[5] |
| 3 | 16 | 17 | e6d47848 | 3,872,684,104 | 5 | pos[16]↔︎pos[5] |
| 4 | 15 | 16 | a582f7fe | 2,776,823,806 | 14 | pos[15]↔︎pos[14] |
20 / 17 × 0.992 = 1.1670588…; payout 0.01 × 1.1670588… = 0.011670588, as served.Technical Evidence & Verification5 sections
2.9Evidence Coverage Summary8 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Death-point recomputation (Steps 5, 21) | 6,000 / 6,000 primary and 450 / 450 Phase E rounds | Pass |
| Operator code, second check (Step 5) | Duel’s Verify-tab code on 6,450 / 6,450 rounds | Pass |
| Key encoding (hex, not text) | Confirmed by recomputation | Pass |
| Draw-bias bound (Step 5) | All 19 ranges, measured from the code: bias 0 | Pass |
| Client seed influence (Step 6) | 6,000 / 6,000 permutations change | Pass |
| Simulation position chi-squared (Step 18) | 0 / 4 fail at Bonferroni α/4 | Pass |
| Serial independence (Step 18) | 0 / 4 fail (lag-1 and runs test) | Pass |
| Live-sample fit (Step 25) | 12 tests above the Bonferroni bound (informational) | Pass |
2.10Code References9 source files
| File | Purpose |
|---|---|
| docs/ALGORITHM.md | The written specification the RNG code was rebuilt from |
| src/rng.ts | HMAC-SHA256 backward Fisher-Yates (drawIndex, computePermutationFromBuffer, computeDeathPoints) |
| src/bias.ts | The draw-bias bound, measured from drawFromChunk (audit code, not part of the RNG) |
| src/operator-verifier.ts | Runs Duel’s pinned Verify-tab code (E06) as a second check |
| src/simulate.ts | Two-pass simulation: 4M rounds on pinned seeds; 121 casino seeds × 10,000 nonces |
| src/stats.ts | Chi-squared, lag-1 autocorrelation and the Wald-Wolfowitz runs test |
| tests/steps/determinism.ts | Steps 5–6: recomputation, bias bound, verifier parity, client seed influence |
| tests/steps/simulation.ts | Steps 18–19: simulation integrity and the cherry-pick test |
| tests/steps/live-fit.ts | Step 25: live-sample fit (informational) |
2.11Verified Invariants9 invariants
| Invariant | Result |
|---|---|
| HMAC-SHA256 recomputation matches the live game for all 6,450 rounds | Pass |
| Duel’s Verify-tab code, run unmodified, agrees on all 6,450 rounds | Pass |
| The key is the hex-decoded seed; the text key does not reproduce the rounds | Pass |
| Rejection sampling leaves zero bias on all ranges 2–20 | Pass |
| No external entropy is needed to reproduce any round | Pass |
| Simulated death-point positions consistent with uniform at all 4 difficulty levels (1M rounds each) | Pass |
| Lag-1 autocorrelation near zero and runs test p > 0.0025 at all 4 difficulty levels | Pass |
| Live death-point positions fit the uniform lattice at all 4 difficulty levels | Pass |
| A different client seed changes the full permutation on 6,000 / 6,000 bets | Pass |
2.12Datasets UsedSource artifacts
2.13Reproduction InstructionsRun locally
Clone the release, install dependencies and run the suite:
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test # Steps 5, 6, 18 and 25 cover S2npm run test:full # optional: regenerate the simulation and diff itSteps 5, 6, 18 and 25 cover RNG & Entropy. Expected output:
[PASS] Step 5 — Outcome Recomputation (Death Points)
[PASS] Step 6 — Client Seed Influence
[PASS] Step 18 — Simulation Results — Pass 1 Integrity
[PASS] Step 25 — Live-Sample Fit (informational, BEEF-22)Verifier Parity
Does the live game actually follow its own rules?
This section checks that an independent recomputation produces the exact same death-point set as the live game for every captured round, single-step and multi-step. It also confirms the win rule and that every payout matches the multiplier formula. Any mismatch would invalidate the fairness guarantee.
What we verified
- Every round recomputed from its seeds: the full death-point set, not just the payout
- Every payout equals stake × the paid multiplier to relative 1e-12, and every loss credits 0
- Every winning multiplier equals C(20,k) / C(20−m,k) × 0.992 on all 4 difficulty levels
- The win rule holds: the round wins only if no stepped tile is a death point, and a loss ends on the first one
- All five capture phases recompute identically, including 450 multi-step rounds of up to 5 steps
What this means for you
- The verifier is not a simulation: it produces the same death-point set as the live game
- Every bet you play can be independently recomputed by anyone
- Neither the stake nor how far you walk changes the death points or the formula you are paid by
- The live game follows the published algorithm on every captured round
- Every round recomputed from its seeds: the full death-point set, not just the payout
- Every payout equals stake × the paid multiplier to relative 1e-12, and every loss credits 0
- Every winning multiplier equals C(20,k) / C(20−m,k) × 0.992 on all 4 difficulty levels
- The win rule holds: the round wins only if no stepped tile is a death point, and a loss ends on the first one
- All five capture phases recompute identically, including 450 multi-step rounds of up to 5 steps
- The verifier is not a simulation: it produces the same death-point set as the live game
- Every bet you play can be independently recomputed by anyone
- Neither the stake nor how far you walk changes the death points or the formula you are paid by
- The live game follows the published algorithm on every captured round
Death-point set recomputationPass
Player-verifier parityPass
Payout correctnessPass
Multiplier formulaPass
Win conditionPass
Bet-size independencePass
Multi-phase coveragePass
All 6,450 rounds matched the independent recomputation exactly, across all five capture phases, including 450 multi-step rounds of up to 5 steps. ProvablyFair.org’s player verifier code agrees on every round. Every payout and every multiplier matches the formula, and every loss credits 0.
| Check | Result | Evidence |
|---|---|---|
| Death-point set recomputation | Pass | 6,000 / 6,000 primary and 450 / 450 Phase E rounds match exactly (Steps 5 and 21) |
| Player-verifier parity | Pass | ProvablyFair.org’s verifier code, pinned and executed: 6,450 / 6,450 death-point sets agree, and its multiplier is within 1e-12 on all 4,539 wins |
| Payout correctness | Pass | amount_won = amount × no_house_edge_multiplier to relative 1e-12 on 6,000 bets; 202 cash-outs and 248 losses in Phase E (Steps 7 and 22) |
| Multiplier formula | Pass | 4,337 paid multipliers match C(20,k) / C(20−m,k) × 0.992 at relative 1e-12; 1,085 Phase E ladder rungs match the raw ratio in 15 cells (Steps 8 and 20) |
| Win condition | Pass | 6,450 / 6,450 rounds against the recomputed death points: steps are the path 0…k−1, and every loss ends on its first death point (Step 9) |
| Bet-size independence | Pass | The stake is not an RNG input; 200 Phase C bets at $10 pay by the same formula as $0.01 bets (Step 10) |
| Multi-phase coverage | Pass | 5 phases: all difficulties (A), EXPERT at volume (B), $10 stakes (C), player-set client seeds (D), multi-step cash-outs (E) |
Death-point set recomputationPass
Player-verifier parityPass
Payout correctnessPass
Multiplier formulaPass
Win conditionPass
Bet-size independencePass
Multi-phase coveragePass
All 6,450 rounds matched the independent recomputation exactly, across all five capture phases, including 450 multi-step rounds of up to 5 steps. ProvablyFair.org’s player verifier code agrees on every round. Every payout and every multiplier matches the formula, and every loss credits 0.
How It Works — Verifier Parity9 sections
3.1Why Parity Matters
If an independent verifier produced results that differ from the live game, players could not rely on verification at all. 100% parity is required, because even one discrepancy would point to a bug in the verification logic, a difference in the live game, or an RNG that is not the one published. Players must be able to take the revealed seeds after play, put them into an independent verifier and get the exact death points they played against.
3.2Five-Phase Collection Design
Data was collected in five structured phases, each aimed at a specific fairness property. Together they cover every difficulty level, EXPERT at volume, stake invariance, player-set client seeds and multi-step cash-outs.
| Phase | Bets | Config | Stake | Purpose |
|---|---|---|---|---|
| A — Baseline difficulty coverage | 4,000 | All 4 difficulties (1,000 each) | $0.01 | Formula and recomputation at every difficulty |
| B — EXPERT at volume | 1,000 | EXPERT (m=10) | $0.01 | The highest-variance setting: 50% first-step win chance |
| C — Stake equivalence | 200 | MEDIUM (m=3) | $10.00 | The same formula and RNG path at 1,000× the stake |
| D — Player-set client seeds | 800 | Random difficulty | $0.01 | 16 pfaudit client seeds, one per epoch |
| E — Multi-step & cash-out | 450 | E1 EASY to 5 steps · E2 MEDIUM to 3 · E3 HARD to 5 · E4 EXPERT to 2 | $0.01 | Ladder multipliers, cash-outs and losses at k > 1 |
3.3Death-Point Recomputation (Step 5)
For every bet, the verifier looks up the revealed server seed by its commitment, computes the death points with computeDeathPointsFromBuffer(key, clientSeed, nonce, deathPointsCount) and compares them, as a set, with the served mines_positions. A bet whose seed was never revealed would fail the step rather than be skipped. Step 21 does the same for the 450 Phase E rounds.
let mismatches = 0;let skipped = 0;const census = newDrawCensus();for (const b of bets) { const ss = seedMap.get(b.seed.serverSeedHashed); if (!ss) { skipped++; continue; } const dpc = DEATH_POINTS_BY_DIFFICULTY[b.response.difficulty_level]; const key = Buffer.from(ss, 'hex'); const computed = computeDeathPointsFromBuffer(key, b.seed.clientSeed, b.seed.nonce, dpc, GRID_SIZE, census); const actual = [...b.response.mines_positions].sort((a, c) => a - c); if (computed.length !== actual.length || !computed.every((v, i) => v === actual[i])) mismatches++;}mines_positions.3.4Player Verifier and Operator Code (Step 5)
Step 5 also runs two other implementations on every round of both files. ProvablyFair.org’s Beef verifier code (VerifyBets/games/beef/derive.js with its HMAC library) is pinned by SHA-256 in the package and executed unchanged: its death points must equal ours, and on every win its cash-out multiplier must equal the exact paid multiplier within relative 1e-12. Duel’s own Verify-tab code (E06) is executed with only its input values filled in: its death points must equal the served ones and ours. The main-site page at www.provablyfair.org/verify-bets is a separate build and was not checked for Beef.
| Implementation | Pinned | Rounds | Result |
|---|---|---|---|
| ProvablyFair.org verifier code (derive.js) | 0003d6347506334f… | 6,450 | 0 disagreements; multiplier within 1e-12 on 4,539 wins |
| Duel’s Verify-tab code (E06) | 43ba4dfbd068cbf5… | 6,450 | Equal to the served and recomputed death points on every round |
for (const b of [...bets, ...ctx.phaseE]) { const ss = seedMap.get(b.seed.serverSeedHashed); if (!ss) { siteUnrecomputable++; continue; } const level = b.response.difficulty_level; const d = byCode.get(level); const m = DEATH_POINTS_BY_DIFFICULTY[level]; if (!d) { siteMismatches++; continue; } const site = Array.from(sv.deriveBeef({ clientSeed: b.seed.clientSeed, serverSeed: ss, nonce: b.seed.nonce, difficulty: d.id }).deathPositions); const pkg = computeDeathPoints(ss, b.seed.clientSeed, b.seed.nonce, m); siteCompared++; if (site.length !== pkg.length || !site.every((v, i) => v === pkg[i])) siteMismatches++; if (b.response.outcome === 'win') { const k = b.response.reached_k ?? (b.response.current_step || []).length; const siteMult = sv.cashoutMultiplier(m, k); const siteStr = String(siteMult); const devExact = /e/i.test(siteStr) ? Infinity : relativeDeviation(siteStr, exactMultiplier(m, k, true)); const devServed = relativeDeviation(b.response.no_house_edge_multiplier, exactMultiplier(m, k, true)); siteMultWorst = Math.max(siteMultWorst, devExact); siteMultChecked++; if (!(devExact <= MULT_REL_TOL) || !(devServed <= MULT_REL_TOL)) siteMultMismatches++; }}3.5Payout Math (Step 7)
For every primary bet the verifier compares the served amount_won with amount × no_house_edge_multiplier at a relative tolerance of 1e-12, the tolerance every payout comparison in the suite shares. A loss must credit exactly "0". Duel’s field names are reversed: multiplier is the raw ratio C(20,k) / C(20−m,k) without the edge, and no_house_edge_multiplier is the paid multiplier, with the 0.992 factor applied.
let payoutErrors = 0;for (const b of bets) { if (b.response.outcome === 'win') { const amt = parseFloat(b.response.amount_currency || b.request.amount); const nhe = parseFloat(b.response.no_house_edge_multiplier ?? '0'); const won = parseFloat(b.response.amount_won); if (!Number.isFinite(won) || Math.abs(amt * nhe - won) > moneyTol(amt * nhe)) payoutErrors++; } else { if (b.response.amount_won !== '0') payoutErrors++; }}3.6Multiplier Formula Verification (Step 8)
Beef’s paid multiplier is C(20,k) / C(20−m,k) × 0.992. Step 8 parses both served 18-decimal strings of every winning primary bet exactly and compares them with the exact fraction at relative 1e-12: multiplier with the raw ratio, no_house_edge_multiplier with the paid one. Step 20 does the same for every rung of the Phase E ladders. Duel’s config (GET /api/v2/cross-road/config, E07) publishes the same table: all 61 cells match the formula, worst relative deviation 3.0 × 10⁻¹⁹ (scripts/check-config-table.mjs).
| Metric | Count |
|---|---|
| Winning primary bets checked (k = 1) | 4,337 |
| Matching the exact fraction at relative 1e-12 | 4,337 (worst 5.0 × 10⁻¹⁹) |
| Mismatches | 0 |
| Phase E ladder rungs (Step 20) | 1,085 across 15 (difficulty, k) cells (worst 9.63 × 10⁻¹⁵) |
| Config table cells (E07) | 61 / 61 |
let multErrors = 0;let s8Worst = 0;for (const b of bets) { if (b.response.outcome !== 'win') continue; const dpc = DEATH_POINTS_BY_DIFFICULTY[b.response.difficulty_level]; const k = (b.response.current_step || []).length; // number of steps completed const dRaw = relativeDeviation(b.response.multiplier, exactMultiplier(dpc, k, false)); const dPaid = relativeDeviation(b.response.no_house_edge_multiplier, exactMultiplier(dpc, k, true)); s8Worst = Math.max(s8Worst, dRaw, dPaid); if (!(dRaw <= MULT_REL_TOL)) multErrors++; if (!(dPaid <= MULT_REL_TOL)) multErrors++;}3.7Win Condition Verification (Step 9)
In Beef the player walks a fixed path, tile 0, then 1, then 2. Step 9 checks every round of both files against the recomputed death points, not the served ones: the stepped tiles must be exactly 0 … k−1, the round wins if and only if none of them is a death point, and a loss must end on the first death point it meets.
| Scope | Coverage | Verified |
|---|---|---|
| Primary dataset (Phases A–D) | 6,000 single-step rounds | 6,000 / 6,000 |
| Phase E multi-step rounds | 450 rounds, 1 to 5 steps | 450 / 450 |
| Phase E cash-outs at k > 1 (Step 22) | 202 winning rounds | 202 / 202 |
for (const b of [...bets, ...phaseE]) { const ss = seedMap.get(b.seed.serverSeedHashed); if (!ss) { condUnrecomputable++; continue; } condChecked++; const steps = b.response.current_step || []; const deaths = new Set(computeDeathPoints(ss, b.seed.clientSeed, b.seed.nonce, DEATH_POINTS_BY_DIFFICULTY[b.response.difficulty_level])); const k = steps.length; const prefixOk = k >= 1 && steps.every((t, i) => t === i) && (b.response.reached_k === undefined || b.response.reached_k === k); const hits = steps.map(t => deaths.has(t)); const anyHit = hits.some(h => h); const expectedOutcome = anyHit ? 'loss' : 'win'; const lossShapeOk = !anyHit || (hits[k - 1] === true && hits.slice(0, k - 1).every(h => !h)); if (!prefixOk || b.response.outcome !== expectedOutcome || !lossShapeOk) { condErrors++; if (condIssues.length < 5) condIssues.push(`${b.seed.serverSeedHashed.substring(0, 12)}…#${b.seed.nonce}: steps [${steps.join(',')}] deaths [${[...deaths].join(',')}] outcome ${b.response.outcome}`); }}3.8Phase C — Bet-Size Equivalence (Step 10)
Phase C placed 200 bets at $10 on MEDIUM (m = 3), the same setting played at $0.01 in Phase A. Every Phase C death-point set recomputes from its revealed seed, and every one of the 165 wins pays by the same C(20,k) / C(20−m,k) × 0.992 formula as the $0.01 bets. The stake is not an input to the RNG.
3.9Worked Example — Full Parity Verification
Real bet from Phase E1: round 7843993, EASY (m = 1), nonce 0, five safe steps, then a cash-out. Verified from beef-phaseE-450bets.json:
serverSeed = 414cf32bb0d5412e2e1f42fa304f4b45601e9715074ed2d436d8569ccaed5844
clientSeed = zqpIvz4yp068AeIU
nonce = 0
difficulty_level = 1 (EASY, m=1)
steps = [0, 1, 2, 3, 4]
cashed_out = true
reached_k = 5
target_k = 5| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher-Yates: 19 HMAC-SHA256 draws | Shuffled tile array |
| 2 | The first slot (m = 1) → death-point set | {6} |
| 3 | Steps on tiles 0, 1, 2, 3, 4 — none is a death point | 5 safe steps |
| 4 | Raw ladder C(20,k) / C(19,k) for k = 1 … 5 | 1.0526× → 1.1111× → 1.1765× → 1.2500× → 1.3333× |
| 5 | Cash-out at k = 5: 1.3333… × 0.992, × $0.01 | $0.0132267 ✅ |
// computeDeathPoints("414cf32b...", "zqpIvz4yp068AeIU", 0, 1)// 19 Fisher-Yates steps → death-point SET = {6}//// Step chain (player steps on tiles 0, 1, 2, 3, 4 — all safe).// Live step_results multipliers are the raw combinatorial ratio (no edge):// k=1: mult = C(20,1) / C(19,1) = 20/19 = 1.052632×// k=2: mult = C(20,2) / C(19,2) = 190/171 = 1.111111×// k=3: mult = C(20,3) / C(19,3) = 1140/969 = 1.176471×// k=4: mult = C(20,4) / C(19,4) = 4845/3876 = 1.250000×// k=5: mult = C(20,5) / C(19,5) = 15504/11628 = 1.333333×//// Cash-out at k=5 applies the 0.8% house edge:// no_house_edge_multiplier = 1.333333 × 0.992 = 1.322667// Payout: 0.01 × 1.322667 = 0.013227// Live amount_won: 0.013226666... ✅Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary12 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Death-point recomputation (Step 5) | 6,000 / 6,000 primary rounds | Pass |
| Player-verifier parity (Step 5) | ProvablyFair.org’s verifier code on 6,450 / 6,450 rounds | Pass |
| Payout math (Step 7) | 6,000 / 6,000 bets at relative 1e-12 | Pass |
| Multiplier formula (Step 8) | 4,337 winning bets, exact fractions | Pass |
| Win condition (Step 9) | 6,450 / 6,450 rounds against recomputed death points | Pass |
| Phase C bet-size invariance (Step 10) | 200 / 200 at $10, 165 wins | Pass |
| Config completeness (Step 11) | All 4 difficulties ≥ 1,000 bets; 15 of 61 cells observed | Pass |
| Population and phases (Step 13) | 6,000 bets, 125 seed records, phases A–D | Pass |
| Phase D client seeds (Step 17) | 800 / 800 on 16 player-set seeds | Pass |
| Multi-step multiplier chain (Step 20) | 1,085 rungs across 15 cells | Pass |
| Phase E recomputation (Step 21) | 450 / 450 multi-step rounds | Pass |
| Cash-out payouts (Step 22) | 202 cash-outs (k=2: 27, k=3: 67, k=5: 108); 248 losses credit 0 | Pass |
3.11Code References7 source files
| File | Purpose |
|---|---|
| tests/steps/determinism.ts | Step 5: recomputation, ProvablyFair.org’s verifier code and Duel’s Verify-tab code |
| tests/steps/payouts.ts | Steps 7–12: payout math, multiplier formula, win condition, Phase C, coverage, house edge |
| tests/steps/dataset.ts | Steps 13–17: population, dataset hash, epoch size, anti-circularity, Phase D |
| tests/steps/multireveal.ts | Steps 20–22: multi-step chain, Phase E recomputation, cash-out payouts |
| src/exact.ts | Exact-fraction multipliers and the relative-deviation measure |
| src/site-verifier.ts | Pins and loads ProvablyFair.org’s verifier code (derive.js, hmac-sha256.js) |
| scripts/check-config-table.mjs | Checks the 61 cells of Duel’s config table (E07) against the formula |
3.12Datasets UsedSource artifacts
3.13Verified Invariants11 invariants
| Invariant | Result |
|---|---|
| Recomputed death-point set equals the served mines_positions for all 6,450 rounds | Pass |
| ProvablyFair.org’s verifier code and Duel’s Verify-tab code agree with the recomputation on all 6,450 rounds | Pass |
| amount_won = amount × no_house_edge_multiplier to relative 1e-12; every loss credits 0 | Pass |
| Paid multipliers equal C(20,k) / C(20−m,k) × 0.992 and raw multipliers the ratio alone, at relative 1e-12 | Pass |
| Win only when no stepped tile is a death point; every loss ends on its first death point | Pass |
| $10 bets pay by the same formula as $0.01 bets | Pass |
| No inputs beyond (serverSeed, clientSeed, nonce, difficulty) affect the death points | Pass |
| All 4 difficulty levels present, each above the 1,000-bet floor | Pass |
| Phase D: 800 / 800 rounds on 16 player-set client seeds recompute | Pass |
| The death-point set is fixed at round start: unchanged by the steps taken (450 Phase E rounds) | Pass |
| Cash-out payouts correct at k > 1: 202 cash-outs at k = 2, 3 and 5 | Pass |
3.14Reproduction InstructionsRun locally
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test # Steps 5, 7–11, 13, 17 and 20–22 cover S3Steps 5, 7–11, 13, 17 and 20–22 cover Verifier Parity. Expected output:
[PASS] Step 5 — Outcome Recomputation (Death Points)
[PASS] Step 7 — Payout Math
[PASS] Step 8 — Multiplier Formula (C(20,k)/C(20−m,k) × edge)
[PASS] Step 9 — Win Condition (all stepped tiles not in mines)
[PASS] Step 10 — Phase C Bet-Size Invariance ($10 bets)
[PASS] Step 11 — Config Completeness & Payout-Table Coverage
[PASS] Step 13 — Population & Phase Labels
[PASS] Step 17 — Phase D — Client Seed Variation
[PASS] Step 20 — Multi-Step Multiplier Chain (Phase E)
[PASS] Step 21 — Death-Point Recomputation (Phase E)
[PASS] Step 22 — Cash-Out Payout Correctness (k>1)RTP & Payout Logic
Is the house edge what the casino claims?
This section derives Beef’s RTP from first principles and holds Duel’s published figure to it. For every difficulty and cash-out step, the raw multiplier is the exact reciprocal of the chance of surviving k steps and the paid multiplier is that × 0.992, so survival × paid multiplier is exactly 0.992: a flat 0.8% house edge on all 61 settings, with no casino-supplied probability used. Under the RTP claim rule the published 99.2% holds on every one of them. The Beef config carries no stake tiers, so the same edge applies at every stake in it. 4 million simulated rounds are consistent with the derivation, and a seed-selection test on Duel’s own seeds finds no sign of cherry-picking.
What we verified
- Theoretical RTP is exactly 99.2% at all 61 difficulty and cash-out settings: survival × multiplier = 0.992
- The published 99.2% holds on every setting under the RTP claim rule (±0.1 pp)
- effective_edge 0.8 on every primary bet; the config carries no stake tiers
- 4M simulated rounds average 99.1468%, consistent with 99.2%
- Seed-selection test on 121 casino seeds: no sign of cherry-picking
- Bet amount does not change the death points or the formula: checked at $0.01 and $10
What this means for you
- The house edge on Beef is a flat 0.8% at every difficulty and every cash-out point
- The RTP is derived independently: it does not rely on the casino’s probabilities
- The 99.2% Duel’s game settings carry is what the game pays
- Duel’s seeds show no sign of being chosen to run cold
- Theoretical RTP is exactly 99.2% at all 61 difficulty and cash-out settings: survival × multiplier = 0.992
- The published 99.2% holds on every setting under the RTP claim rule (±0.1 pp)
- effective_edge 0.8 on every primary bet; the config carries no stake tiers
- 4M simulated rounds average 99.1468%, consistent with 99.2%
- Seed-selection test on 121 casino seeds: no sign of cherry-picking
- Bet amount does not change the death points or the formula: checked at $0.01 and $10
- The house edge on Beef is a flat 0.8% at every difficulty and every cash-out point
- The RTP is derived independently: it does not rely on the casino’s probabilities
- The 99.2% Duel’s game settings carry is what the game pays
- Duel’s seeds show no sign of being chosen to run cold
Theoretical RTP (anti-circularity)Pass
RTP claim rulePass
House edge and stake tiersPass
Payouts exactPass
Simulated RTP (Pass 1)Pass
Cherry-pick screening (Pass 2)Pass
Multiplier monotonicityPass
The 99.2% RTP is derived from combinatorial cancellation: survival × multiplier = 0.992 at every difficulty and every cash-out step, confirmed exactly by counting all 2^20 death-point sets. The published 99.2% holds on all 61 settings under the RTP claim rule. The house edge is a flat 0.8%, with no stake tiers in the config. 4M simulated rounds are consistent with it, and the seed-selection test finds no sign of cherry-picking.
Checked by counting all 2^20 death-point sets: exactly 992/1000 at every setting. The published 99.2% holds on all 61 (RTP claim rule).
| Check | Result | Evidence |
|---|---|---|
| Theoretical RTP (anti-circularity) | Pass | survival(m, k) × multiplier(m, k) = 0.992 at all 61 settings, from combinatorics alone; exact 992/1000 by counting all 2^20 death-point sets (Step 16) |
| RTP claim rule | Pass | Published flat 99.2% (Duel’s game settings) against the true RTP of each setting: 0 of 61 outside ±0.1 pp; scored on Step 16 |
| House edge and stake tiers | Pass | effective_edge 0.8 on 6,000 / 6,000 bets (Step 12); the config has no stake tiers; $10 bets pay as $0.01 bets (Step 10) |
| Payouts exact | Pass | All served multipliers equal the formula at relative 1e-12; all 61 config cells match it (E07) |
| Simulated RTP (Pass 1) | Pass | 4M rounds, mean 99.1468%, consistent with 99.2%; 0 / 4 position chi-squared and 0 / 4 serial failures (Step 18) |
| Cherry-pick screening (Pass 2) | Pass | 121 casino seeds × 10,000 nonces (Step 19): Test A 0 / 121, Test B 2 / 121, 1 seed off in both windows, where a flag needs 2 |
| Multiplier monotonicity | Pass | All 61 cells strictly increase with depth and difficulty; no max-odds cap is declared (Step 24) |
Theoretical RTP (anti-circularity)Pass
RTP claim rulePass
House edge and stake tiersPass
Payouts exactPass
Simulated RTP (Pass 1)Pass
Cherry-pick screening (Pass 2)Pass
Multiplier monotonicityPass
The 99.2% RTP is derived from combinatorial cancellation: survival × multiplier = 0.992 at every difficulty and every cash-out step, confirmed exactly by counting all 2^20 death-point sets. The published 99.2% holds on all 61 settings under the RTP claim rule. The house edge is a flat 0.8%, with no stake tiers in the config. 4M simulated rounds are consistent with it, and the seed-selection test finds no sign of cherry-picking.
How It Works — RTP & Payout Logic9 sections
4.1Theoretical RTP — Anti-Circularity (Step 16)
The theoretical RTP is derived without any casino-supplied probability. The shuffle makes the death-point set a uniform choice of m tiles out of 20, so the chance that the first k tiles are all safe is the hypergeometric ratio C(20−m, k) / C(20, k). The paid multiplier is the reciprocal ratio times 0.992. Their product cancels exactly: RTP = 0.992 for every difficulty and every cash-out step, a flat 0.8% house edge. No summation, no convergence.
Step 16 checks the identity on all 61 settings in floating point, then exactly: it enumerates all 2^20 death-point sets, counts the survivors at every setting and requires counted survival × the exact paid multiplier to equal 992/1000 in integer arithmetic. A negative control built on 991/1000 must be rejected at every setting, and is.
| Component | Formula | Source |
|---|---|---|
| Survival after k steps | survival(m, k) = C(20−m, k) / C(20, k) | Combinatorics of the shuffle, not the casino |
| Paid multiplier | multiplier(m, k) = C(20, k) / C(20−m, k) × 0.992 | Duel’s formula and config table |
| RTP | survival × multiplier | Independent probability × paid multiplier |
| Result | = 0.992 at all 4 difficulty levels and every valid k | Exact cancellation |
| Difficulty (m) | Survival (k=1) | Multiplier (with edge) | Survival × Multiplier | RTP |
|---|---|---|---|---|
| EASY (1) | 19/20 = 0.950000 | 20/19 × 0.992 = 1.044211 | 124/125 | 99.2% |
| MEDIUM (3) | 17/20 = 0.850000 | 20/17 × 0.992 = 1.167059 | 124/125 | 99.2% |
| HARD (5) | 15/20 = 0.750000 | 20/15 × 0.992 = 1.322667 | 124/125 | 99.2% |
| EXPERT (10) | 10/20 = 0.500000 | 20/10 × 0.992 = 1.984000 | 124/125 | 99.2% |
Anti-Circularity Verification:
for (const d of [1, 2, 3, 4] as const) { const m = DEATH_POINTS_BY_DIFFICULTY[d]; for (let k = 1; k <= GRID_SIZE - m; k++) { const surv = survivalProbability(m, k); const mult = theoreticalMultiplier(m, k, HOUSE_EDGE); const rtp = surv * mult; const dev = Math.abs(rtp - (1 - HOUSE_EDGE)); combosTested++; if (dev > maxDeviation) { maxDeviation = dev; worstConfig = `d=${d} (m=${m}), k=${k}`; } const cS = BigInt(anchor.survive[m][k]), cT = BigInt(anchor.total[m]); if (Math.abs(anchor.survive[m][k] / anchor.total[m] - surv) > S16_ANCHOR_REL * surv) anchorMismatches++; const paid = exactMultiplier(m, k, true); // counted survival × paid multiplier == the RTP table's exact row for this cell (C3, 14 Oct 2026: // the row, not the claimed 992/1000 — a cell paying less is an RTP miss, scored by RTP-CLAIM on // this step as RTP FIGURE OVERSTATED, never a FAIL here). cS·paid.num·row.d == cT·paid.den·row.n const row = tableRtp.get(`difficulty=${d} (m=${m}) k=${k}`); if (!row || cS * paid.num * row.d !== cT * paid.den * row.n) exactIdentityFailures++; // negative control: a multiplier built on 991/1000 must NOT reproduce the row const badNum = binomialBig(GRID_SIZE, k) * 991n, badDen = binomialBig(GRID_SIZE - m, k) * 1000n; if (row && cS * badNum * row.d === cT * badDen * row.n) negativeControlAccepted++; }}Why this derivation is non-circular: survival(m, k) comes from counting death-point sets and never reads a casino field; the only casino-sourced input is the multiplier being tested. Duel’s config also publishes the multiplier table, 61 cells, and every cell matches C(20,k) / C(20−m,k) × 0.992 (worst relative deviation 3.0 × 10⁻¹⁹). Because the identity holds at every k ≤ 20 − m, the RTP does not depend on when you cash out.
4.2RTP Claim Rule (RTP-CLAIM 1.2.0)
Framework 1.1 holds the RTP a casino publishes to the true RTP of every setting it covers. The claim scored here is a flat 99.2%, published in Duel’s game settings: the effective_edge 0.8 served with every Beef bet (6,000 of 6,000, Step 12) and the Beef config’s payout tables, built on 0.992. The rule scores each of the 61 difficulty and cash-out settings against it within a ±0.1 pp band, and the outcome is scored on Step 16. A house-side miss would make the verdict RTP FIGURE OVERSTATED (exit 5) rather than NOT PROVABLY FAIR: the rule scores the published figure, not the draws.
| Difficulty | Settings | True RTP (exact) | Gap to 99.2% | Outcome |
|---|---|---|---|---|
| EASY (m=1) | k = 1 … 19 (19 settings) | 124/125 = 99.200000% at every k | 0.000000 pp | Pass |
| MEDIUM (m=3) | k = 1 … 17 (17 settings) | 124/125 = 99.200000% at every k | 0.000000 pp | Pass |
| HARD (m=5) | k = 1 … 15 (15 settings) | 124/125 = 99.200000% at every k | 0.000000 pp | Pass |
| EXPERT (m=10) | k = 1 … 10 (10 settings) | 124/125 = 99.200000% at every k | 0.000000 pp | Pass |
export function computeRtpClaim(): RtpClaimResult { const acc = new RtpClaimAccumulator(RTP_CLAIM); for (const d of [1, 2, 3, 4]) { const m = DEATH_POINTS_BY_DIFFICULTY[d]!; for (let k = 1; k <= GRID_SIZE - m; k++) { const pay = exactMultiplier(m, k, true); acc.add(`difficulty=${d} (m=${m}) k=${k}`, binomialBig(GRID_SIZE - m, k) * pay.num, binomialBig(GRID_SIZE, k) * pay.den); } } return acc.result();}outputs/rtp-claim-table.json, pinned by SHA-256.4.3House Edge and Stake Tiers (Step 12)
The house edge comes from the × 0.992 factor in the paid multiplier C(20,k) / C(20−m,k) × 0.992. Every bet response also carries an effective_edge field: all 6,000 primary bets read 0.8, at every difficulty, phase and both captured stakes. Step 8 checks the formula against every primary win, Step 22 against every multi-step cash-out, and Step 7 reconciles the primary payouts to it.
Stake tiers: the Beef config Duel’s site loads (GET /api/v2/cross-road/config, fetched read-only on 5 October 2026, E07) returns one payout table per difficulty, with no stake dimension and no scaling_edge. The edge is therefore the same at every stake in the config. The capture placed bets at $0.01 and $10, which pay by the same formula (Step 10); no bet above $10 was placed.
Rakeback: after the capture, Duel added a 0.8% rakeback on Beef under its Zero Edge allowance. It is not part of the game’s paytable and is not audited here. The certified RTP is the game’s 99.2%.
effective_edge 0.8 on all 6,000 primary bets (Step 12). No stake tiers in the config.4.4Full RTP Table — All 4 Difficulties
All four difficulty levels have the same theoretical RTP, 99.200%. The simulated RTP of each varies with sampling noise, most at EXPERT, where a 50% win chance gives the largest per-round variance.
| Difficulty | Theoretical RTP | Simulated RTP (1M rounds) | Deviation |
|---|---|---|---|
| EASY (m=1) | 99.200% | 99.194% | −0.006 pp |
| MEDIUM (m=3) | 99.200% | 99.161% | −0.039 pp |
| HARD (m=5) | 99.200% | 99.148% | −0.052 pp |
| EXPERT (m=10) | 99.200% | 99.084% | −0.116 pp |
4.5Simulation Pass 1 — Pinned Seeds (Step 18)
4.1 derives the RTP. Pass 1 checks that the implementation behaves like the derivation at scale: 4 million rounds, 1 million per difficulty, run with our RNG code on four pinned auditor seed pairs (not casino seeds), each round one step and paid at the k = 1 multiplier.
Chi-squared test: death-point frequency over the 20 tiles at each difficulty against uniform. 0 / 4 fail at α = 0.01, 0 / 4 at Bonferroni α/4 = 0.0025.
Serial independence: lag-1 autocorrelation and the runs test on each 1M-round win/loss series. 0 / 4 fail (2.6).
RTP: mean simulated RTP 99.1468% against 99.2000% theoretical, a deviation of −0.053 pp, consistent with sampling variance at this size.
for (let nonce = 0; nonce < ROUNDS_PER_CONFIG; nonce++) { const deaths = computeDeathPointsFromBuffer(keyBuffer, seedPair.client, nonce, dpc); for (const pos of deaths) positionFreq[pos]++; const revealTile = nonce % GRID_SIZE; const deathSet = new Set(deaths); const won = !deathSet.has(revealTile); if (won) { totalWins++; totalPayout += mult; } winSequence[nonce] = won ? 1 : 0; const roundNum = nonce + 1; if (sampleSet.has(roundNum)) rtpSnapshots.set(roundNum, totalPayout / roundNum);}What is a Monte Carlo simulation? Instead of relying on algebra alone, we play millions of rounds in software. Each round computes a death-point set from scratch with the same HMAC-SHA256 backward Fisher-Yates shuffle, steps on a tile and records the win and the payout. The aggregate return is then compared with the theoretical 99.2%.
nonce mod 20; every real Beef round steps on tile 0 first. On fresh auditor seeds every tile has the same death probability, so the choice does not change what Pass 1 tests. Measured on tile 0 for disclosure, EXPERT’s runs test gives p = 5.7 × 10⁻⁴, below the 0.0025 threshold. It does not replicate: nonces 1,000,000–9,999,999 of the same seed give p = 0.094, and 200 fresh seeds at 1M rounds each give a mean lag-1 z of 0.076 (standard error 0.068). Pass 2 and Step 19 score tile 0.4.6Cherry-Pick Detection — Pass 2 (Step 19)
Could Duel choose server seeds that run cold for players? A commitment fixes a seed before your bets, but Duel generates its seeds alone, with no external randomness beacon. Selection need not bias a seed’s whole nonce range: a player meets the early nonces first (this capture rotated after at most 50), so a seed could be chosen on those and look ordinary after. Pass 2 replays all 121 revealed casino seeds of the primary file for 10,000 nonces each at MEDIUM (85% first-step win chance), every round one step on tile 0, and compares the early window (nonces 0–49) with the late one (50–9,999). Every rule that can move the verdict is a count over the 121 seeds, with its false-alarm rate on a fair game stated: at most 5% for a FLAG and 1% for a FAIL.
Result: Test A 0 / 121 (binomial p = 1.000); Test B 2 / 121 isolated-early seeds (binomial p = 0.985); off in both windows at p < 0.05: 1 / 121 (count p = 0.261); at p < 0.001: 0.
Disclosed observation: the one seed off in both windows is commitment c9ddfba9…7121b568, client seed Ty1rZcxKscWFXxqt: 36 wins in its first 50 nonces (p = 0.010042) and 8,387 in the next 9,950 (p = 0.047777), against 42.5 and 8,457.5 expected. A fair game gives at least one such seed among 121 about one time in four, which is why the count is scored, not the seed.
Pooled early windows: 5,151 wins in 6,050 rounds (85.14%) against 85% expected.
Detection power: not quantified. The board is a fixed MEDIUM single step, not the settings each epoch served, and the late windows are read from the pinned artifact rather than replayed.
| Rule | Moves the step to | Triggers at | False alarm (model / exact) | This dataset |
|---|---|---|---|---|
| Test A: full window off at p < 0.01 | FAIL | 5 or more seeds | 0.76% / 0.89% | 0 |
| Test B: early off, late not (p < 0.05) | FLAG | 11 or more | 4.0% / 1.3% | 2 |
| Test B, same count | FAIL | 13 or more | 0.77% / 0.18% | 2 |
| Off in both windows at p < 0.05 | FLAG | 2 or more | 3.7% / 2.9% | 1 |
| Off in both windows, same count | FAIL | 3 or more | 0.36% / 0.25% | 1 |
| Off in both windows at p < 0.001 | FAIL | 1 or more | 0.012% / 0.024% | 0 |
const key = Buffer.from(ss, 'hex'); let early = 0; for (let n = 0; n < EARLY; n++) { if (!computeDeathPointsFromBuffer(key, r.clientSeed, n, 3).includes(SIM_FIRST_STEP_TILE)) early++; } if (early !== r.earlyWins) earlyReplayMismatch++; const pEarly = chiSquaredTest([r.earlyWins, EARLY - r.earlyWins], [theoWin * EARLY, (1 - theoWin) * EARLY]).pValue; const pLate = chiSquaredTest([r.lateWins, LATE - r.lateWins], [theoWin * LATE, (1 - theoWin) * LATE]).pValue; const tot = r.earlyWins + r.lateWins; const pA = chiSquaredTest([tot, TOTAL - tot], [theoWin * TOTAL, (1 - theoWin) * TOTAL]).pValue; if (!(Math.abs(pEarly - r.earlyP) <= P_TOL) || !(Math.abs(pLate - r.lateP) <= P_TOL)) pMismatch++; const flag = pEarly < 0.05 && pLate >= 0.05; const aFail = pA < 0.01; if (flag !== r.cherry_pick_flag || aFail !== r.testA_chi2_fail) flagMismatch++; if (flag) flags++; if (aFail) testA++; if (pEarly < 0.05 && pLate < 0.05) { broad++; broadSeeds.push({ serverSeedHashed: r.serverSeedHashed, clientSeed: r.clientSeed, earlyWins: r.earlyWins, earlyP: pEarly, lateWins: r.lateWins, lateP: pLate }); } if (pEarly < 0.001 && pLate < 0.001) broadSevere++;}4.7Bet-Size Invariance (Step 10)
Phase C placed 200 bets at $10 on MEDIUM (m = 3), the setting also played at $0.01 in Phase A. All 200 death-point sets recompute from the revealed seeds through the same HMAC-SHA256 path, and all 165 wins pay by the same C(20,k) / C(20−m,k) × 0.992 formula. The stake is not an input to the RNG.
| Metric | Phase A ($0.01) | Phase C ($10) |
|---|---|---|
| Bets | 4,000 (all 4 difficulties, 1,000 each) | 200 (MEDIUM, m=3) |
| Stake | $0.01 | $10.00 |
| Death-point recomputation | 4,000 / 4,000 | 200 / 200 |
| Multiplier formula | C(20,k)/C(20−m,k) × 0.992 | C(20,k)/C(20−m,k) × 0.992 |
| effective_edge | 0.8 | 0.8 |
4.8Live Win Rates and Returns (Not Scored)
These figures describe the captured sample for transparency; none is scored. At these sample sizes empirical RTP is not a measure of fairness: the derivation in 4.1 is. Across the 6,000 primary bets the return is 96.3737%, driven by the 200 $10 bets, which carry 97% of the stake and won 165 against 170 expected. The 5,800 bets at $0.01 returned 99.52%.
| Item | Value | Context |
|---|---|---|
| Phase A empirical RTP | 99.088% | 4,000 bets at $0.01, all 4 difficulties |
| Phase B empirical RTP | 101.978% | 1,000 bets at $0.01, EXPERT |
| Phase C empirical RTP | 96.282% | 200 bets at $10, MEDIUM |
| Phase D empirical RTP | 98.630% | 800 bets at $0.01, random difficulty, player-set seeds |
| Phase E empirical RTP | 108.650% | 450 multi-step bets at $0.01, cash-outs at k = 2, 3 and 5 |
| Group | Bets | Wins | Expected | p (exact binomial) |
|---|---|---|---|---|
| EASY (m=1), k = 1 | 1,200 | 1,132 | 1,140 | 0.320 |
| MEDIUM (m=3), k = 1 | 1,400 | 1,198 | 1,190 | 0.579 |
| HARD (m=5), k = 1 | 1,200 | 903 | 900 | 0.872 |
| EXPERT (m=10), k = 1 | 2,200 | 1,104 | 1,100 | 0.881 |
| E1: EASY to k = 5 | 100 | 76 | 75.0 | 0.923 |
| E2: MEDIUM to k = 3 | 100 | 67 | 59.6 | 0.160 |
| E3: HARD to k = 5 | 150 | 32 | 29.1 | 0.602 |
| E4: EXPERT to k = 2 | 100 | 27 | 23.7 | 0.500 |
4.9Worked Example — Payout Verification
Real bet from Phase E1 — Round ID 7843993, EASY (m=1), nonce 0, 5 safe steps cashed out at k=5. Verified from beef-phaseE-450bets.json:
serverSeed = 414cf32bb0d5412e2e1f42fa304f4b45601e9715074ed2d436d8569ccaed5844
clientSeed = zqpIvz4yp068AeIU
nonce = 0
difficulty_level = 1 (EASY, m=1)
steps = [0, 1, 2, 3, 4]
k = 5Step 1 — Death-point computation: computeDeathPoints(serverSeed, clientSeed, 0, 1) → 19 Fisher-Yates draws → death-point set = {6}
Step 2 — Win check: The player stepped on tiles [0, 1, 2, 3, 4]. None is in {6} → win at k = 5
Step 3 — Multiplier: C(20, 5) / C(19, 5) × 0.992 = 15504/11628 × 0.992 = 1.322667×
Step 4 — Payout: 0.01 × 1.322667 = 0.0132267; served amount_won 0.013226666666666685
| Step | Process | Output |
|---|---|---|
| 1 | Backward Fisher-Yates: 19 HMAC draws | Death-point set = {6} ✅ |
| 2 | Win check: is any stepped tile a death point? | {0, 1, 2, 3, 4} ∩ {6} = ∅ → win |
| 3 | Multiplier: C(20,5) / C(19,5) × 0.992 | 1.322667× |
| 4 | RTP check: survival × multiplier | C(19,5)/C(20,5) × C(20,5)/C(19,5) × 0.992 = 0.992 |
| 5 | Payout: 0.01 × 1.322667 | 0.0132267 ✅ |
// EASY (m=1), k=5 — anti-circularity proof// winChance(1, 5) = C(19,5) / C(20,5) = 11628/15504 = 0.75 (survive 5 steps)// multiplier(1, 5, 0.008) = C(20,5) / C(19,5) × 0.992 = 15504/11628 × 0.992 = 1.322667 // RTP = winChance × multiplier// = 0.75 × 1.322667// = 0.992000000 (99.2%) ✅ // Algebraic cancellation (exact, not an estimate):// C(20-m, k) / C(20, k) × C(20, k) / C(20-m, k) × 0.992// = 1 × 0.992// = 0.992Technical Evidence & Verification5 sections
4.10Evidence Coverage Summary9 checks
| Verification Area | Coverage | Result |
|---|---|---|
| Anti-circularity (Step 16) | 61 settings; exact 992/1000 by counting all 2^20 sets; negative control rejected | Pass |
| RTP claim rule (Step 16) | Flat 99.2% claim: 0 of 61 settings outside ±0.1 pp | Pass |
| House edge audit (Step 12) | effective_edge 0.8 on 6,000 / 6,000 bets | Pass |
| Multiplier formula (Steps 8, 20) | 4,337 winning bets and 1,085 ladder rungs | Pass |
| Monotonicity and bounds (Step 24) | 57 / 57 depth and 42 / 42 difficulty pairs increase; no cap declared | Pass |
| Simulation Pass 1 (Step 18) | 4M rounds, 0 / 4 chi-squared, 0 / 4 serial | Pass |
| Simulation Pass 2 (Step 19) | 121 seeds: Test A 0, Test B 2, both windows 1 (flag at 2) | Pass |
| Bet-size invariance (Step 10) | 200 / 200 Phase C at $10 | Pass |
| Multi-step payouts (Steps 20, 22) | 1,085 rungs and 202 cash-outs at k = 2, 3 and 5 | Pass |
4.11Code References8 source files
| File | Purpose |
|---|---|
| tests/steps/dataset.ts | Step 16: anti-circularity, counting anchor and negative control |
| src/rtp-settings.ts | The RTP claim and the exact RTP of all 61 settings |
| src/rtp-claim.ts | The framework’s RTP claim rule, version 1.2.0 |
| tests/steps/payouts.ts | Steps 8, 10, 12: multiplier formula, bet-size invariance, house edge |
| tests/steps/simulation.ts | Steps 18–19: simulation integrity and the cherry-pick test |
| tests/steps/monotonicity.ts | Step 24: multiplier monotonicity and bounds |
| src/simulate.ts | Two-pass Monte Carlo simulation |
| src/rng.ts | survivalProbability and theoreticalMultiplier, exact binomials |
4.12Datasets UsedSource artifacts
4.13Verified Invariants12 invariants
| Invariant | Result |
|---|---|
| survival × multiplier = 0.992 at all 4 difficulty levels and every k (61 settings) | Pass |
| Counted survival over all 2^20 death-point sets × exact paid multiplier = 992/1000 at every setting | Pass |
| The published flat 99.2% holds within ±0.1 pp on all 61 settings | Pass |
| Flat 0.8% house edge: × 0.992 in the formula, effective_edge 0.8 on all 6,000 primary bets | Pass |
| Every served multiplier matches the formula; Duel’s config table matches on 61 / 61 cells | Pass |
| Multipliers strictly increase with depth and with difficulty | Pass |
| Mean simulated RTP 99.1468% over 4M rounds, consistent with 99.2% | Pass |
| 0 / 4 position chi-squared failures at Bonferroni α/4 = 0.0025 | Pass |
| 0 / 4 serial independence failures (lag-1 and runs test) | Pass |
| No count of the cherry-pick test reaches its trigger across 121 casino seeds | Pass |
| $10 bets pay by the same formula as $0.01 bets | Pass |
| Multi-step cash-outs at k = 2, 3 and 5 pay the formula (202 / 202) | Pass |
4.14Reproduction InstructionsRun locally
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test # Steps 8, 10, 12, 16, 18, 19, 24 and the RTP claim cover S4node scripts/check-config-table.mjs # Duel’s config table against the formulaSteps 8, 10, 12, 16, 18, 19 and 24 cover RTP & Payout Logic. Expected output:
[PASS] Step 8 — Multiplier Formula (C(20,k)/C(20−m,k) × edge)
[PASS] Step 10 — Phase C Bet-Size Invariance ($10 bets)
[PASS] Step 12 — House Edge Audit (effective_edge = 0.8%)
[PASS] Step 16 — Probability Independence (Anti-Circularity)
[PASS] Step 18 — Simulation Results — Pass 1 Integrity
[PASS] Step 19 — Simulation Results — Pass 2 Cherry-Pick Test
[PASS] Step 24 — Multiplier Monotonicity & Bounds (BEEF-14)
rtp-claim: ENFORCED — PASS
rtp-claim: claim flat 99.200000% — source: game settings: effective_edge = 0.8 (%), the edge Duel's site is served with every Beef bet (6,000 of 6,000, Step 12); the Beef config the site loads (GET /api/v2/cross-road/config, E07, fetched 2026-10-05) carries the payout tables built on 0.992 (docs/ALGORITHM.md §3.1; scripts/check-config-table.mjs, 61 of 61 cells; MANIFEST.md#payouts-and-rtp; declaration gameModel.edge.claimed 0.008)
rtp-claim: band ±0.10 pp · 61 settings · true min 99.200000% (difficulty=1 (m=1) k=1) · true max 99.200000% (difficulty=1 (m=1) k=1)
rtp-claim: house side beyond band: 0 · player-favourable beyond band: 0 · worst difficulty=1 (m=1) k=1 at 0.000000 pp
rtp-claim: outcome PASS · minimal fix: none — the claim holds for every setting it states a figure for
rtp-claim: committed table outputs/rtp-claim-table.json: equals this run; sha256 1528d0c9b255f9a4… matches the pinFairness Integrity Testing
Does the implementation maintain fairness under non-standard conditions?
Sections 1–4 prove the game is mathematically fair. Section 5 proves the implementation maintains integrity under non-standard conditions. We applied 16 fairness integrity tests covering nonce integrity, seed commitment, outcome determinism, cross-player isolation, and payout integrity (including Beef-specific multi-step game-state checks). All 16 tests passed, including one Beef-specific multi-step state integrity test.
What we verified
- Nonce tampering — can the sequence be forced, replayed, or skipped?
- Seed injection — can server or client seed fields be overridden via API?
- Outcome replay — can a completed bet be replayed for duplicate payouts?
- Cross-player isolation — can one player's seeds or outcomes affect another's?
- Payout tampering — can multiplier or payout values be injected client-side?
- Parameter limits — can invalid difficulty levels or grid sizes be submitted?
- Beef-specific — can a round that has already been cashed out be stepped on again?
What this means for you
- Across the 16 tests we ran, no API path allowed outcomes to be altered, replayed, or injected — by player or casino
- Once a bet is placed, the death-point layout cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player
- The server rejects malformed, out-of-range, and duplicate requests
- Nonce tampering — can the sequence be forced, replayed, or skipped?
- Seed injection — can server or client seed fields be overridden via API?
- Outcome replay — can a completed bet be replayed for duplicate payouts?
- Cross-player isolation — can one player's seeds or outcomes affect another's?
- Payout tampering — can multiplier or payout values be injected client-side?
- Parameter limits — can invalid difficulty levels or grid sizes be submitted?
- Beef-specific — can a round that has already been cashed out be stepped on again?
- Across the 16 tests we ran, no API path allowed outcomes to be altered, replayed, or injected — by player or casino
- Once a bet is placed, the death-point layout cannot be changed or replayed
- Each bet is cryptographically unique and isolated
- Your results are independent of every other player
- The server rejects malformed, out-of-range, and duplicate requests
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
16 fairness integrity tests: all 16 pass, including one Beef-specific multi-step state integrity test.
Category Coverage
| Check | Result | Evidence |
|---|---|---|
| Nonce integrity | Pass | Sequential, server-controlled, no duplicates across all 131 epochs (2 rounds our capture missed, reconstructed from the revealed seeds) |
| Seed commitment integrity | Pass | Locked at bet acceptance, unique per epoch — 131/131 epochs verified |
| Outcome determinism | Pass | Identical inputs produce identical death-point sets — 6,450/6,450 confirmed including multi-step |
| Round & player isolation | Pass | Per-user seeds, serial independence confirmed (0/4 fail in 4M-round simulation) |
| Payout integrity | Pass | Parameter limits enforced (4/4 invalid difficulty rejected); injected payout fields ignored (0 honoured); post-settlement step injection blocked |
Nonce integrityPass
Seed commitment integrityPass
Outcome determinismPass
Round & player isolationPass
Payout integrityPass
16 fairness integrity tests: all 16 pass, including one Beef-specific multi-step state integrity test.
How It Works — Fairness Integrity Testing2 sections
5.1Framework Overview
Testing follows the ProvablyFair.org Fairness Integrity Framework — a structured methodology derived from real, historically observed failures in provably fair systems. Five categories target specific fairness properties, with Payout Integrity extended to cover Beef's multi-step reveal and cash-out surface. Scope boundary: S5 tests whether fairness guarantees hold under non-standard API interaction. Platform-level implementation testing falls outside standard certification.
| Category | Tests | What It Catches |
|---|---|---|
| Nonce Integrity | 4 | Sequence gaps, server-side nonce manipulation, session continuity |
| Seed Commitment | 5 | Mid-epoch seed changes, seed reuse, predictable seed generation |
| Outcome Determinism | 2 | Non-deterministic outputs, outcome replay, cash-out manipulation |
| Player Isolation | 2 | Cross-round correlation, cross-user outcome dependence |
| Payout Integrity | 3 | Parameter enforcement, server-side computation, duplicate-step idempotency |
5.2Severity Framework & Hard Fail Criteria
Findings are classified by severity. Hard fail criteria — any one triggers a NOT PROVABLY FAIR verdict.
| Severity | Meaning | Action |
|---|---|---|
| PASS | Test passed — no issue detected | None |
| N/A | Test not applicable to this game type | None |
| FLAG | Anomaly detected, documented for transparency | Disclosed |
| HARD FAIL | Fairness guarantee cannot be confirmed | Certification blocked until remediated |
| Condition | Consequence |
|---|---|
| Nonce gap or duplicate within epoch | Outcome sequence integrity broken |
| Server seed changed mid-epoch | Commit-reveal guarantee broken |
| Death-point recomputation mismatch | Undisclosed inputs affecting placement |
| Client seed not used in HMAC | Player has no influence on outcomes |
| Death-point set changes during step sequence | Per-step manipulation possible |
| Duplicate step advances payout multiplier | Multi-step state corruption |
16 tests · 16 pass
Nonce Integrity4/4
FI-NONCE-001PassEach bet increments the nonce sequentially with no gaps, repeats, or resets — preventing the server from skipping unfavourable outcomes
FI-NONCE-002PassNonce progression is server-controlled — the client cannot inject, skip, or replay a nonce value via the API
S1, Step 4 — server controls nonce assignment. Client bet requests do not include a nonce field.
FI-NONCE-003PassSubmitting an invalid or out-of-sequence nonce does not produce a game outcome — the server rejects the request
API probe — 7 adversarial nonce values (−1, 0, 999999999, 'abc', INT32_MAX, INT32_MAX+1, 9e18) injected into beef-start requests. All 7 silently ignored; server assigned valid sequential nonces. Continuity preserved (baseline 9 → post-test 17); no stack traces leaked.
FI-NONCE-004PassNonce sequence continues correctly after disconnect/reconnect — no reset to zero mid-epoch
Seed Commitment5/5
FI-SEED-001PassEmpty, null, or invalid client seeds are handled deterministically — the server enforces input requirements
API probe — 6/7 invalid client seeds rejected (empty, null, special chars, emoji, CJK, whitespace-only). Oversized seed (>1000 chars) accepted — permissive but safe (long entropy). All Beef bets after each rejection remained functional; no stack traces leaked.
FI-SEED-002PassOnce a bet is accepted, the seed pair is locked for the epoch — no mid-epoch mutation of server or client seed is possible
FI-SEED-003PassEach epoch uses a unique server seed — no seed is reused across epochs or sessions
FI-SEED-004PassNo shared seed pool across users — each player's seeds are independently generated and isolated
API probe — 10 concurrent seed rotations on Account A and 10 on Account B. Zero hash collisions across 20 rotations; all hashes within each account distinct. Full account isolation confirmed.
FI-SEED-005PassServer seeds show no correlation with timestamps, sequential patterns, or other predictable inputs
API probe — 10 rotations spaced 5 seconds apart over ~51 seconds. All 10 server seed hashes distinct; no two shared 6+ leading hex characters. Time-correlated derivation ruled out.
Outcome Determinism2/2
FI-OUTCOME-001PassGiven identical inputs (serverSeed, clientSeed, nonce, difficultyLevel), the game always produces the same death-point set — verified across all 6,450 live bets including 450 multi-step bets with target_k ∈ {2, 3, 5} across all 4 difficulties
FI-OUTCOME-002PassA completed bet cannot be replayed to generate a duplicate payout — death-point set is cryptographically fixed at bet time and cash-out payouts are deterministically bound to the formula
Player Isolation2/2
FI-ISO-001PassRNG state is fully independent across rounds — no carry-over from one bet to the next. Each nonce produces a fresh HMAC-SHA256 computation
FI-ISO-002PassOne player's seeds, nonces, and outcomes cannot be observed or influenced by another player — complete cross-user isolation
Follows from seed uniqueness (FI-SEED-003) — if each user has a unique server seed, outcomes are isolated by construction. Confirmed by FI-SEED-004 — zero hash collisions across 20 cross-account rotations.
Payout Integrity3/3
FI-PAYOUT-001PassGame parameters cannot exceed defined limits — only valid difficulty levels (1–4) and the 20-tile grid are accepted
API probe — 4/4 invalid difficulty values rejected with HTTP 422 (0, −1, 9999, 'abc'). Both valid controls (difficulty=1, 2) and recovery bet accepted. No out-of-range values silently coerced.
FI-PAYOUT-002PassMultiplier and payout fields in the API request are ignored — the server computes all values from the combinatorial formula, not from client-supplied values
API probe — 6 injected fields (multiplier='9999', mines_positions, is_win, win_amount, payout_multiplier, death_points) all silently ignored. Server computed death point positions and payout values independently from the seed pair on every request. noInjectionHonoured=true.
FI-BEEF-STATE-001PassA step on a round that has already been cashed out is rejected, so a settled round can't be advanced
API probe — game started, first step taken (multiplier 1.0526…), round cashed out, then a step request targeting the now-settled round rejected with HTTP 404. Multiplier did not advance from first-step value; no double-step vulnerability observed. multiplierAdvanced=false.
Technical Evidence & Verification4 sections
5.3Coverage Summary16 checks
| Test ID | Category | Verification Source | Status |
|---|---|---|---|
| FI-NONCE-001 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-002 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-NONCE-003 | Nonce | API probe | Pass |
| FI-NONCE-004 | Nonce | S1, Step 4 (data-driven) | Pass |
| FI-SEED-001 | Seed | API probe | Pass |
| FI-SEED-002 | Seed | S1, Steps 3 & 6 (data-driven) | Pass |
| FI-SEED-003 | Seed | S1, Step 1 (data-driven) | Pass |
| FI-SEED-004 | Seed | API probe | Pass |
| FI-SEED-005 | Seed | API probe | Pass |
| FI-OUTCOME-001 | Determinism | S3, Steps 5 & 21 (data-driven) | Pass |
| FI-OUTCOME-002 | Determinism | S3, Steps 21 & 22 (data-driven) | Pass |
| FI-ISO-001 | Isolation | S2, Step 18 (simulation) | Pass |
| FI-ISO-002 | Isolation | Structural — seed uniqueness | Pass |
| FI-PAYOUT-001 | Payout | API probe | Pass |
| FI-PAYOUT-002 | Payout | API probe | Pass |
| FI-BEEF-STATE-001 | Payout | API probe | Pass |
5.4Additional Integrity Evidence (S1–S4)8 records
| Property | Source | Finding |
|---|---|---|
| 131/131 seed hashes verified | S1, Step 1 | Commit-reveal chain intact |
| 125/125 next-seed promotions | S1, Step 2 | Seed rotation chain intact |
| 6,000/6,000 exact parity (primary) + 450/450 Phase E | S3, Steps 5 & 21 | No post-RNG conditional logic, death-point set fixed at round start |
| Anti-circularity proven (algebraic) | S4, Step 16 | 0.8% house edge from first principles |
| Test A 0/121, Test B 2/121; 1 seed off in both windows (a flag needs 2) | S4, Step 19 (Pass 2) | No seed pre-selection bias |
| 100% client seed influence (6,000/6,000) | S1, Step 6 | Player entropy is genuine |
| 202 cash-outs verified at k ∈ {2, 3, 5} | S3, Step 22 | Multi-step payout integrity intact |
| 1,085 step-multiplier pairs verified across 15 (difficulty, k) combos | S3, Step 20 | Multi-step multiplier chain correct |
5.5Scope
This certification covers the 16 fairness integrity tests listed above — the minimum required to verify that the provably fair implementation holds up under non-standard conditions, including one Beef-specific multi-step state integrity test under Payout Integrity. This is not a penetration test. It focuses specifically on the provably fair implementation — not the operator's broader platform security.
Standard scope: The 16 tests above are our standard Beef fairness integrity matrix. The base list is applied to every game we audit, with per-game adaptations where a test does not apply (and additions where multi-step game state requires extra coverage — Beef includes FI-BEEF-STATE-001 for post-settlement step rejection, which is not applicable to single-step games).
No infrastructure testing: Server security, network-level protections and operational controls fall under platform-level security, not game-level fairness, and sit outside this certification.
Point-in-time: Results apply to the game configuration and codebase at the time of audit. Post-audit changes require re-certification.
5.6Reproduction InstructionsRun locally
Data-driven tests (9 of 16): Fully reproducible from the open-source repo. These tests run against the captured dataset and produce deterministic results.
API probe tests (7 of 16): Verified by issuing live adversarial requests against the running game. Per-test evidence (HTTP status codes, server-assigned nonces, seed hashes, server-computed multipliers, death-point decisions) is retained in our private adversarial-testing archive and summarised in the integrity test review document. The testing harness itself is kept private so it can't be reused against the game.
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm testExpected output (S5-related steps):
[PASS] Step 1 — Seed Hash Integrity
[PASS] Step 2 — Next-Seed Promotion + Forward Commitment Chain
[PASS] Step 3 — Hash Consistency Within Epoch
[FLAG:capture] Step 4 — Nonce Audit
[PASS] Step 5 — Outcome Recomputation (Death Points)
[PASS] Step 6 — Client Seed Influence
[PASS] Step 7 — Payout Math
[PASS] Step 8 — Multiplier Formula (C(20,k)/C(20−m,k) × edge)
[PASS] Step 10 — Phase C Bet-Size Invariance ($10 bets)
[PASS] Step 14 — Dataset Hash
[PASS] Step 17 — Phase D — Client Seed Variation
[PASS] Step 18 — Simulation Results — Pass 1 Integrity
[PASS] Step 19 — Simulation Results — Pass 2 Cherry-Pick Test
[PASS] Step 20 — Multi-Step Multiplier Chain (Phase E)
[PASS] Step 21 — Death-Point Recomputation (Phase E)
[PASS] Step 22 — Cash-Out Payout Correctness (k>1)
Standard checks: FI-SEED-003 Step 1 · FI-SEED-002 Steps 3 + 6 · FI-NONCE-001, 002, 004 Step 4 · FI-OUTCOME-001 Steps 5 + 21 · FI-OUTCOME-002 Steps 21 + 22 · FI-ISO-001 Step 18API Probe Tests (completed):
[PASS] FI-NONCE-003 — Invalid nonce handling → 7/7 invalid nonces ignored (HTTP 200)[PASS] FI-SEED-001 — Invalid client seed handling → 6/7 rejected; oversized accepted[PASS] FI-SEED-004 — Cross-user seed pool check → 0/20 collisions across 2 accounts[PASS] FI-SEED-005 — Seed timing analysis → 10 distinct hashes, no time correlation[PASS] FI-PAYOUT-001 — Invalid difficulty handling → 4/4 boundary violations rejected (HTTP 422)[PASS] FI-PAYOUT-002 — Field injection handling → 0 injections honoured[PASS] FI-BEEF-STATE-001 — Post-settlement step probe → step on settled round rejected (HTTP 404)Player Verification
Can a player verify their own bets without trusting anyone?
Every Beef round can be reproduced from publicly disclosed inputs, with no hidden variables or private backend data. Rotate your seed pair to reveal the server seed, check it against the commitment, recompute the death points, then check the outcome and the payout. This section walks through the process with scripts you can run yourself that reproduce all 6,450 captured rounds, and links the ProvablyFair.org verifier.
Key principles
- Every Beef round can be independently reproduced
- No hidden variables and no private backend data
- A revealed seed that hashes to the commitment is the seed your round was served under
- Matching death points, outcome and payout show the round followed the published algorithm
- Duel’s Provably Fair panel and round history show everything you need
What you need
- Server Seed — revealed when you rotate the seed pair (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the round’s position under the seed, counting up from 0
- Difficulty Level — the difficulty you played: EASY, MEDIUM, HARD or EXPERT (1, 3, 5 or 10 death points)
- Every Beef round can be independently reproduced
- No hidden variables and no private backend data
- A revealed seed that hashes to the commitment is the seed your round was served under
- Matching death points, outcome and payout show the round followed the published algorithm
- Duel’s Provably Fair panel and round history show everything you need
- Server Seed — revealed when you rotate the seed pair (casino entropy)
- Client Seed — your player-controlled seed
- Nonce — the round’s position under the seed, counting up from 0
- Difficulty Level — the difficulty you played: EASY, MEDIUM, HARD or EXPERT (1, 3, 5 or 10 death points)
Player can access all required inputsPass
Client seed origin transparentPass
Verification process documentedPass
Casino UI exposes verificationPass
Independent verifier availablePass
Manual recomputation possiblePass
No hidden or proprietary stepsPass
Only disclosed inputs are used, and identical inputs always produce identical output. A revealed seed that hashes to its commitment, and death points, outcome and payout that recompute, show your round followed the published rules.
- 1
Play, Then Rotate
Play your Beef rounds. The Provably Fair panel shows your client seed, the server seed’s hash and the nonce. When you rotate the seed pair, Duel reveals the server seed you were playing on, and every round under it becomes checkable.
- 2
Collect the Round’s Fields
For the round you want to check, note the revealed server seed, the commitment shown before the round, your client seed, the nonce (from 0) and the difficulty, plus the served death points, steps, outcome, multipliers and payout.
- 3
Check the Hash, Recompute
SHA-256 of the hex-decoded server seed must equal the commitment. Then recompute the shuffle with the ProvablyFair.org verifier or the script in 6.9: the first 1, 3, 5 or 10 tiles, sorted, are the death points.
- 4
Check Outcome and Payout
You walked tiles 0 … k−1. The round wins only if none of them is a death point, and a loss ends on the first one. A winning cash-out pays stake × C(20,k) / C(20−m,k) × 0.992; a loss credits 0.
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
Verify with ProvablyFair.org
Recompute any Beef round from its revealed seeds, independently of the casino.
Open independent verifierBuilt-in verification
The operator’s own verification page. This tool is controlled by Duel.com.
Open Duel verifierVisual Walkthroughstep-by-step
Choose your difficulty (EASY, MEDIUM, HARD or EXPERT, which Duel’s UI calls Extreme) and place a bet. The death points on the road ahead are fixed by the active server seed, your client seed and the nonce before you take a step; you only learn where they are by stepping on one, or from the round record afterwards.

Duel.com Beef — the road with its difficulty selector and step multipliers. The death points are fixed before the first step.
Open the Provably Fair modal on the game page. It shows the active client seed, the hashed server seed (the casino’s commitment) and your current nonce, plus the hash of the next server seed. You can set the client seed that becomes active after rotation. “Rotate seed” retires the active pair, which reveals its server seed for your previous rounds.

Provably Fair modal — active client seed, hashed server seed, nonce, customisable new client seed, next pair pre-commitment, and Rotate seed action.
After rotating, open Transactions and click a past Beef round. The per-bet modal shows the revealed plaintext server seed alongside the round ID, client seed and nonce. SHA-256 of the hex-decoded seed must equal the commitment the round was served under:
Server Seed (revealed) — the plaintext value the casino committed to. Hash its 32 bytes and compare with the commitment.
Client Seed — your player-controlled entropy input.
Nonce — the round’s position under this seed pair, from 0.

Per-bet transaction modal — revealed plaintext server seed, client seed, and nonce for the round.
Click Verify in the per-bet modal to open Duel’s Provably Fair page with the seeds filled in. The page recomputes the round and shows the step multipliers with the death point marked. If it matches your live round and the revealed seed matches its commitment, the result is consistent with the published algorithm. For a check that does not rely on Duel’s page, use the ProvablyFair.org verifier or the scripts in 6.9 and 6.10.

Provably Fair page — seeds populated from the per-bet modal, recomputed step multipliers and death point rendered inline matching the live game result.
Manual Verification (Advanced)7 sections
6.5Why Manual Verification Matters
True provably fair verification means not having to trust any casino-provided tool. Manual verification runs the calculation on your own machine, so a tampered verifier can’t mislead you, and it shows exactly how results are generated.
6.6How the Algorithm Works (Plain English)
The death points are fixed by three ingredients and your difficulty:
- The server’s secret seed — committed by its hash, shown before your round
- Your client seed — set in your browser and an input to every draw
- The nonce — a counter that makes each round unique
- The difficulty level — EASY, MEDIUM, HARD or EXPERT, which sets the number of death points: 1, 3, 5 or 10
These are combined with HMAC-SHA256 to shuffle the 20 tiles with a backward Fisher-Yates shuffle, one HMAC per draw. The first tiles of the shuffled array, as many as your difficulty’s death points, are the death points. The server seed can’t change after your round without failing to match its commitment, and your client seed is your own input, so a changed one would give different death points when you recompute. Once the shuffle is done the death points are fixed: how far you walk, or when you cash out, does not move them.
6.7Seven Checks for One Round7 records
The package’s player guide checks a single round end to end in seven steps, using the field names Duel serves. Nothing in it reads an operator odds or win-chance field.
| # | Check | Compare |
|---|---|---|
| 1 | Reveal the server seed | Rotate your seed pair in the Beef Provably Fair panel |
| 2 | Collect the fields | serverSeed, seed.serverSeedHashed (the commitment shown before the round), seed.clientSeed, seed.nonce (from 0), request.difficulty_level and the served response.* fields |
| 3 | Commitment encoding | SHA-256(hex_decode(serverSeed)) equals seed.serverSeedHashed |
| 4 | Recompute the shuffle | computeDeathPoints(serverSeed, clientSeed, nonce, m) (6.9) |
| 5 | Death-point count | m = 1 / 3 / 5 / 10 for difficulty 1 / 2 / 3 / 4; the set equals response.mines_positions |
| 6 | Path and win rule | You stood on tiles 0 … k−1 (response.current_step); a win has no death point among them |
| 7 | Settlement | Win: multiplier = C(20,k) / C(20−m,k), no_house_edge_multiplier = that × 0.992, amount_won = stake × the paid multiplier. Loss: ends on its first death point and credits "0" |
no_house_edge_multiplier is null and multiplier keeps the raw value of the last safe position, or 1 when the first step is fatal. Example: round 7722782, EXPERT, died on its first step and records multiplier 1.000000000000000000, no_house_edge_multiplier null and amount_won "0". All 1,911 captured losses look like this.6.8Casino Verifier vs ProvablyFair.org Verifier3 records
Two verification tools are available. Both should give the same death points; if they don’t, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | ProvablyFair.org |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Trust model | Requires trusting the casino | Not controlled by the casino |
6.9JavaScript Verification Script
Copy and run this in Node.js to verify any Beef round. computeDeathPoints is the function from the package’s player guide (MANIFEST.md), verbatim:
const crypto = require('crypto'); // computeDeathPoints, exactly as in the audit package's player guide (MANIFEST.md, "Verify a bet")function computeDeathPoints(serverSeed, clientSeed, nonce, deathPointsCount) { const key = Buffer.from(serverSeed, 'hex'); const positions = Array.from({ length: 20 }, (_, i) => i); for (let t = 0; t <= 18; t++) { const i = 19 - t; const range = i + 1; const limit = Math.floor(2 ** 32 / range) * range; const digest = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${t}`).digest(); let j = null; for (let c = 0; c < 8 && j === null; c++) { const value = digest.readUInt32BE(c * 4); if (value < limit) j = value % range; } if (j === null) throw new Error('all 8 chunks rejected (ALGORITHM.md open point O1)'); [positions[i], positions[j]] = [positions[j], positions[i]]; } return positions.slice(0, deathPointsCount).sort((a, b) => a - b);} function verifyHash(serverSeed, serverSeedHashed) { const hash = crypto.createHash('sha256').update(Buffer.from(serverSeed, 'hex')).digest('hex'); return hash === serverSeedHashed.toLowerCase();} const DEATH_POINTS = { 1: 1, 2: 3, 3: 5, 4: 10 }; // difficulty_level → death points // Replace with your valuesconst serverSeed = 'YOUR_SERVER_SEED';const serverSeedHashed = 'YOUR_SERVER_SEED_HASH';const clientSeed = 'YOUR_CLIENT_SEED';const nonce = 0;const difficultyLevel = 2; // 1=EASY, 2=MEDIUM, 3=HARD, 4=EXPERT console.log('Hash check:', verifyHash(serverSeed, serverSeedHashed) ? 'PASS' : 'FAIL');console.log('Death points:', computeDeathPoints(serverSeed, clientSeed, nonce, DEATH_POINTS[difficultyLevel]));computeDeathPoints returns the served death points on 6,450 / 6,450 rounds, and verifyHash prints PASS for all 131 commitments.6.10Python Verification Script
The same verification in Python (standard library only):
import hashlib, hmac DEATH_POINTS = {1: 1, 2: 3, 3: 5, 4: 10} # difficulty_level → death points def compute_death_points(server_seed, client_seed, nonce, death_points_count): key = bytes.fromhex(server_seed) positions = list(range(20)) for t in range(19): # draw index t = 0 … 18 i = 19 - t r = i + 1 # ranges 20, 19, …, 2 limit = (2**32 // r) * r # whole number of ranges digest = hmac.new(key, f'{client_seed}:{nonce}:{t}'.encode(), hashlib.sha256).digest() j = None for c in range(8): # eight big-endian 4-byte chunks value = int.from_bytes(digest[4 * c:4 * c + 4], 'big') if value < limit: j = value % r break if j is None: raise ValueError('all 8 chunks rejected (behaviour not specified)') positions[i], positions[j] = positions[j], positions[i] return sorted(positions[:death_points_count]) def verify_hash(server_seed, server_seed_hashed): return hashlib.sha256(bytes.fromhex(server_seed)).hexdigest() == server_seed_hashed.lower() # Replace with your valuesserver_seed = 'YOUR_SERVER_SEED'server_seed_hashed = 'YOUR_SERVER_SEED_HASH'client_seed = 'YOUR_CLIENT_SEED'nonce = 0difficulty_level = 2 # 1=EASY, 2=MEDIUM, 3=HARD, 4=EXPERT print('Hash check:', 'PASS' if verify_hash(server_seed, server_seed_hashed) else 'FAIL')print('Death points:', compute_death_points(server_seed, client_seed, nonce, DEATH_POINTS[difficulty_level]))compute_death_points returns the served death points on 6,450 / 6,450 rounds, and verify_hash passes for all 131 commitments.6.11Evidence Screenshots4 records
| Evidence | Description |
|---|---|
| E02 | Provably Fair panel: active client seed, hashed server seed, nonce, next server seed hash and the rotate action. Illustrative: it shows the final Phase E rotation, under which no bet was recorded |
| E03 | Duel.com fairness page: what provably fair means, seed generation and the hash commitment |
| E04 | Fairness verification page: game selector, client seed, server seed and nonce inputs, and the published verification code |
| E05 | Duel.com’s live JavaScript, annotated: the default client seed is generated in the browser with rejection-sampled crypto.getRandomValues |
Verify a real bet, step by stepVerify a real bet · Swipe for all 4 steps →
How it works
- 1
Play, Then Rotate
Play your Beef rounds. The Provably Fair panel shows your client seed, the server seed’s hash and the nonce. When you rotate the seed pair, Duel reveals the server seed you were playing on, and every round under it becomes checkable.
- 2
Collect the Round’s Fields
For the round you want to check, note the revealed server seed, the commitment shown before the round, your client seed, the nonce (from 0) and the difficulty, plus the served death points, steps, outcome, multipliers and payout.
- 3
Check the Hash, Recompute
SHA-256 of the hex-decoded server seed must equal the commitment. Then recompute the shuffle with the ProvablyFair.org verifier or the script in 6.9: the first 1, 3, 5 or 10 tiles, sorted, are the death points.
- 4
Check Outcome and Payout
You walked tiles 0 … k−1. The round wins only if none of them is a death point, and a loss ends on the first one. A winning cash-out pays stake × C(20,k) / C(20−m,k) × 0.992; a loss credits 0.
Visual Walkthroughstep-by-step
Choose your difficulty (EASY, MEDIUM, HARD or EXPERT, which Duel’s UI calls Extreme) and place a bet. The death points on the road ahead are fixed by the active server seed, your client seed and the nonce before you take a step; you only learn where they are by stepping on one, or from the round record afterwards.

Duel.com Beef — the road with its difficulty selector and step multipliers. The death points are fixed before the first step.
Open the Provably Fair modal on the game page. It shows the active client seed, the hashed server seed (the casino’s commitment) and your current nonce, plus the hash of the next server seed. You can set the client seed that becomes active after rotation. “Rotate seed” retires the active pair, which reveals its server seed for your previous rounds.

Provably Fair modal — active client seed, hashed server seed, nonce, customisable new client seed, next pair pre-commitment, and Rotate seed action.
After rotating, open Transactions and click a past Beef round. The per-bet modal shows the revealed plaintext server seed alongside the round ID, client seed and nonce. SHA-256 of the hex-decoded seed must equal the commitment the round was served under:
Server Seed (revealed) — the plaintext value the casino committed to. Hash its 32 bytes and compare with the commitment.
Client Seed — your player-controlled entropy input.
Nonce — the round’s position under this seed pair, from 0.

Per-bet transaction modal — revealed plaintext server seed, client seed, and nonce for the round.
Click Verify in the per-bet modal to open Duel’s Provably Fair page with the seeds filled in. The page recomputes the round and shows the step multipliers with the death point marked. If it matches your live round and the revealed seed matches its commitment, the result is consistent with the published algorithm. For a check that does not rely on Duel’s page, use the ProvablyFair.org verifier or the scripts in 6.9 and 6.10.

Provably Fair page — seeds populated from the per-bet modal, recomputed step multipliers and death point rendered inline matching the live game result.
Technical evidence
6.5Why Manual Verification Matters
True provably fair verification means not having to trust any casino-provided tool. Manual verification runs the calculation on your own machine, so a tampered verifier can’t mislead you, and it shows exactly how results are generated.
6.6How the Algorithm Works (Plain English)
The death points are fixed by three ingredients and your difficulty:
- The server’s secret seed — committed by its hash, shown before your round
- Your client seed — set in your browser and an input to every draw
- The nonce — a counter that makes each round unique
- The difficulty level — EASY, MEDIUM, HARD or EXPERT, which sets the number of death points: 1, 3, 5 or 10
These are combined with HMAC-SHA256 to shuffle the 20 tiles with a backward Fisher-Yates shuffle, one HMAC per draw. The first tiles of the shuffled array, as many as your difficulty’s death points, are the death points. The server seed can’t change after your round without failing to match its commitment, and your client seed is your own input, so a changed one would give different death points when you recompute. Once the shuffle is done the death points are fixed: how far you walk, or when you cash out, does not move them.
6.7Seven Checks for One Round7 records
The package’s player guide checks a single round end to end in seven steps, using the field names Duel serves. Nothing in it reads an operator odds or win-chance field.
| # | Check | Compare |
|---|---|---|
| 1 | Reveal the server seed | Rotate your seed pair in the Beef Provably Fair panel |
| 2 | Collect the fields | serverSeed, seed.serverSeedHashed (the commitment shown before the round), seed.clientSeed, seed.nonce (from 0), request.difficulty_level and the served response.* fields |
| 3 | Commitment encoding | SHA-256(hex_decode(serverSeed)) equals seed.serverSeedHashed |
| 4 | Recompute the shuffle | computeDeathPoints(serverSeed, clientSeed, nonce, m) (6.9) |
| 5 | Death-point count | m = 1 / 3 / 5 / 10 for difficulty 1 / 2 / 3 / 4; the set equals response.mines_positions |
| 6 | Path and win rule | You stood on tiles 0 … k−1 (response.current_step); a win has no death point among them |
| 7 | Settlement | Win: multiplier = C(20,k) / C(20−m,k), no_house_edge_multiplier = that × 0.992, amount_won = stake × the paid multiplier. Loss: ends on its first death point and credits "0" |
no_house_edge_multiplier is null and multiplier keeps the raw value of the last safe position, or 1 when the first step is fatal. Example: round 7722782, EXPERT, died on its first step and records multiplier 1.000000000000000000, no_house_edge_multiplier null and amount_won "0". All 1,911 captured losses look like this.6.8Casino Verifier vs ProvablyFair.org Verifier3 records
Two verification tools are available. Both should give the same death points; if they don’t, something has changed.
| Duel.com Verifier | ProvablyFair.org Verifier | |
|---|---|---|
| Source | Casino-controlled | ProvablyFair.org |
| Access | duel.com/provably-fair/verify | provablyfair.org/verify-bets/duel |
| Trust model | Requires trusting the casino | Not controlled by the casino |
6.9JavaScript Verification Script
Copy and run this in Node.js to verify any Beef round. computeDeathPoints is the function from the package’s player guide (MANIFEST.md), verbatim:
const crypto = require('crypto'); // computeDeathPoints, exactly as in the audit package's player guide (MANIFEST.md, "Verify a bet")function computeDeathPoints(serverSeed, clientSeed, nonce, deathPointsCount) { const key = Buffer.from(serverSeed, 'hex'); const positions = Array.from({ length: 20 }, (_, i) => i); for (let t = 0; t <= 18; t++) { const i = 19 - t; const range = i + 1; const limit = Math.floor(2 ** 32 / range) * range; const digest = crypto.createHmac('sha256', key).update(`${clientSeed}:${nonce}:${t}`).digest(); let j = null; for (let c = 0; c < 8 && j === null; c++) { const value = digest.readUInt32BE(c * 4); if (value < limit) j = value % range; } if (j === null) throw new Error('all 8 chunks rejected (ALGORITHM.md open point O1)'); [positions[i], positions[j]] = [positions[j], positions[i]]; } return positions.slice(0, deathPointsCount).sort((a, b) => a - b);} function verifyHash(serverSeed, serverSeedHashed) { const hash = crypto.createHash('sha256').update(Buffer.from(serverSeed, 'hex')).digest('hex'); return hash === serverSeedHashed.toLowerCase();} const DEATH_POINTS = { 1: 1, 2: 3, 3: 5, 4: 10 }; // difficulty_level → death points // Replace with your valuesconst serverSeed = 'YOUR_SERVER_SEED';const serverSeedHashed = 'YOUR_SERVER_SEED_HASH';const clientSeed = 'YOUR_CLIENT_SEED';const nonce = 0;const difficultyLevel = 2; // 1=EASY, 2=MEDIUM, 3=HARD, 4=EXPERT console.log('Hash check:', verifyHash(serverSeed, serverSeedHashed) ? 'PASS' : 'FAIL');console.log('Death points:', computeDeathPoints(serverSeed, clientSeed, nonce, DEATH_POINTS[difficultyLevel]));computeDeathPoints returns the served death points on 6,450 / 6,450 rounds, and verifyHash prints PASS for all 131 commitments.6.10Python Verification Script
The same verification in Python (standard library only):
import hashlib, hmac DEATH_POINTS = {1: 1, 2: 3, 3: 5, 4: 10} # difficulty_level → death points def compute_death_points(server_seed, client_seed, nonce, death_points_count): key = bytes.fromhex(server_seed) positions = list(range(20)) for t in range(19): # draw index t = 0 … 18 i = 19 - t r = i + 1 # ranges 20, 19, …, 2 limit = (2**32 // r) * r # whole number of ranges digest = hmac.new(key, f'{client_seed}:{nonce}:{t}'.encode(), hashlib.sha256).digest() j = None for c in range(8): # eight big-endian 4-byte chunks value = int.from_bytes(digest[4 * c:4 * c + 4], 'big') if value < limit: j = value % r break if j is None: raise ValueError('all 8 chunks rejected (behaviour not specified)') positions[i], positions[j] = positions[j], positions[i] return sorted(positions[:death_points_count]) def verify_hash(server_seed, server_seed_hashed): return hashlib.sha256(bytes.fromhex(server_seed)).hexdigest() == server_seed_hashed.lower() # Replace with your valuesserver_seed = 'YOUR_SERVER_SEED'server_seed_hashed = 'YOUR_SERVER_SEED_HASH'client_seed = 'YOUR_CLIENT_SEED'nonce = 0difficulty_level = 2 # 1=EASY, 2=MEDIUM, 3=HARD, 4=EXPERT print('Hash check:', 'PASS' if verify_hash(server_seed, server_seed_hashed) else 'FAIL')print('Death points:', compute_death_points(server_seed, client_seed, nonce, DEATH_POINTS[difficulty_level]))compute_death_points returns the served death points on 6,450 / 6,450 rounds, and verify_hash passes for all 131 commitments.6.11Evidence Screenshots4 records
| Evidence | Description |
|---|---|
| E02 | Provably Fair panel: active client seed, hashed server seed, nonce, next server seed hash and the rotate action. Illustrative: it shows the final Phase E rotation, under which no bet was recorded |
| E03 | Duel.com fairness page: what provably fair means, seed generation and the hash commitment |
| E04 | Fairness verification page: game selector, client seed, server seed and nonce inputs, and the published verification code |
| E05 | Duel.com’s live JavaScript, annotated: the default client seed is generated in the browser with rejection-sampled crypto.getRandomValues |
Only disclosed inputs are used, and identical inputs always produce identical output. A revealed seed that hashes to its commitment, and death points, outcome and payout that recompute, show your round followed the published rules.
Reproducibility & Artifacts
Can anyone independently reproduce every finding in this audit?
This section consolidates the open-source repository, datasets, output artifacts and reproducibility of the audit. Every scored step, statistic and verdict in the package can be reproduced by anyone with a computer and an internet connection: check out release v1.2.1, run npm test, and the run is compared with the committed results. The repository is the credential, not this report.
Repository Details
- GitHub: ProvablyFair-org/duel-beef
- Release: v1.2.1 (Framework 1.1)
- Original audit: 05530ee (June 2026)
- Game: Beef (duel-beef)
- Public Verifier: provablyfair.org/verify-bets/duel
Prerequisites
- Node.js 22.x (pinned in package.json and .nvmrc)
- npm
- Git
- About 40 seconds for npm test on a 12-core laptop
- GitHub: ProvablyFair-org/duel-beef
- Release: v1.2.1 (Framework 1.1)
- Original audit: 05530ee (June 2026)
- Game: Beef (duel-beef)
- Public Verifier: provablyfair.org/verify-bets/duel
- Node.js 22.x (pinned in package.json and .nvmrc)
- npm
- Git
- About 40 seconds for npm test on a 12-core laptop
Check out release v1.2.1 and run npm test: every result is recomputed, written to outputs/run/ and compared with the committed artifacts, and the exit code is the verdict. The dataset hashes pin the exact 6,450 rounds.
Commands to Reproduce
Check out the release tag, then install. Use Node 22.x, as pinned in .nvmrc and package.json. npm test runs the 25 unit tests (Mocha), then the 25 scored steps against the committed simulation artifact. It does not rerun the simulation.
After the unit tests report 25 passing, the verifier prints the output below. Our run on Node 22.22.0: exit 0, the scored steps in 26 s. Each step prints [PASS], [FAIL] (a hard fail), [FLAG:capture] (limited by our capture, verdict-neutral) or [FLAG] (operator-origin, verdict-affecting). The within-tolerance count and the largest gap on the REPRODUCED line depend on the CPU.
Runs write only to outputs/run/, which is compared with the committed results field by field: integers and strings exactly, everything else within 1e-14 absolute + 1e-12 relative. A difference beyond that exits 1. Committed artifacts are never rewritten by an ordinary run. npm run test:full also regenerates the whole simulation into outputs/run/ and diffs it. The config check compares Duel’s published table (E07) with the formula.
The exit code is the verdict, so nothing automated can read a Conditional Pass as clean. This release exits 0.
Audit Reproducibility Pinning
- Release
- v1.2.1 · Framework 1.1 · commit 0cca070770618cc724349ee59ef93407053f1b23 (21 October 2026)
- Original Audit
- 05530ee044c2b2170e2c66554b124c5733953d22 · 4 June 2026
- Signed Tag
- v1.2.1, ProvablyFair.org SSH key SHA256:gEujiJm2pRyq7lQsfYQfQ1r97H/J7GdaKHbOW8GtikY
- Node Version
- 22.x (package.json engines, .nvmrc)
- Primary Dataset
- data/beef-master-6000bets.json (6,000 bets, 121 epochs)
- Primary Dataset Hash (SHA-256)
- d654ef7c6195584501e9033202d5acad13a16d89d296baab8befc0240fb36d36
- Phase E Dataset
- data/beef-phaseE-450bets.json (450 bets, 10 epochs)
- Phase E Dataset Hash (SHA-256)
- ef39d7f584cdb6d8057e846cdcb9b4ffcc60495bfcce8443d15bb910a9c51001
- Config Copy E07 (SHA-256)
- a7836863db88f699083e14a695fd916799fcbc349006b8bad81d4477a919feca
- verification-results.json
- aee9567ef1811021fd1de0f44d52f5771a35b383e919af4acca946de93f9dc4a
- simulation-results.json
- 7119a3e3743fbd288bf81477ce52ec289b67ea80b4be4fc70663b1a78dd5f613
- determinism-log.json
- 88bc153e2d6e867f375c0cf8138491185761cdb3150e4c921a0746ecf5a7b3c2
- chi-squared-results.json
- 65857a46ab1d0d4acfe0c46ceaa264f22a112358895643160bc5605310451ca0
- rtp-claim-table.json
- 1528d0c9b255f9a448ec6cfa171b57779c25074430d5d8e215d51a7cdfb91987
- rtp-convergence.html
- 2633e8f87d9ed124b1c32c604c25291108ee5af775f8e2405e0ef3538e97d066
- Mutation Battery
- 45 / 45 counterexamples rejected · 25 / 25 scored steps covered · 0 declared survivors
- Runtime
- 37.39 s for npm test (Apple M2 Max, 12 cores, Node 22.23.1, release record)
- Audit Date
- Captured 16–21 April 2026 · updated October 2026
- Audit ID
- PF-2026-DL06
Output Artifacts6 committed artifacts
| File | Contents | Size |
|---|---|---|
| verification-results.json | Steps 1–25 with per-step details, profile mappings and the verdict | 59 KB |
| simulation-results.json | Pass 1 (4M rounds, pinned seeds) and Pass 2 (121 casino seeds × 10,000 nonces) | 58 KB |
| determinism-log.json | Summary of the primary recomputation: 6,000 verified, 0 mismatches, 0 skipped | <1 KB |
| chi-squared-results.json | Per-difficulty live win counts and chi-squared p-values | 1 KB |
| rtp-claim-table.json | Exact RTP of all 61 settings against the published 99.2% (RTP claim rule) | 10 KB |
| rtp-convergence.html | Self-contained RTP convergence chart | 206 KB |
Repository Structure
duel-beef/ ├── src/ │ ├── rng.ts → HMAC-SHA256 backward Fisher-Yates, rebuilt from docs/ALGORITHM.md │ ├── bias.ts → Draw-bias bound, measured from rng.ts │ ├── exact.ts → Exact-fraction multipliers │ ├── simulate.ts → Two-pass simulation (4M rounds; 121 seeds × 10,000 nonces) │ ├── stats.ts → Chi-squared, lag-1 autocorrelation, runs test │ ├── rtp-claim.ts → RTP claim rule 1.2.0 (framework copy) │ ├── rtp-settings.ts → Exact RTP of all 61 settings and the claim │ ├── operator-verifier.ts → Runs Duel’s Verify-tab code as a second check │ ├── site-verifier.ts → Runs ProvablyFair.org’s verifier code on every round │ ├── diff.ts → Reproduction gate (run vs committed results) │ ├── artifact-pins.ts → SHA-256 pins of the artifacts of record │ ├── domains.ts → Value domain of every numeric output │ ├── profile-map.ts → Step → Beef profile check mapping │ └── loader.ts → Dataset loader, pinned population and hashes ├── tests/ │ ├── verify.ts → 25-step verification suite + reproduction gate │ ├── mutations.json → 45 counterexamples for the mutation battery │ ├── steps/ │ │ ├── commitment.ts → Steps 1–4: commitments and nonces │ │ ├── determinism.ts → Steps 5–6: recomputation, verifiers, client seed │ │ ├── payouts.ts → Steps 7–12: payouts, formula, win rule, Phase C, house edge │ │ ├── dataset.ts → Steps 13–17: population, hashes, epochs, anti-circularity, Phase D │ │ ├── simulation.ts → Steps 18–19: simulation integrity + cherry-pick test │ │ ├── multireveal.ts → Steps 20–22: multi-step chain and cash-outs │ │ ├── artifacts.ts → Step 23: artifact integrity │ │ ├── monotonicity.ts → Step 24: multiplier monotonicity and bounds │ │ └── live-fit.ts → Step 25: live-sample fit │ └── beef/ → Unit tests (25, incl. the spec self-test) ├── docs/ │ ├── ALGORITHM.md → The written RNG specification │ └── INTERFACE.md → Module interface for the rebuild ├── data/ │ ├── beef-master-6000bets.json → 6,000 primary rounds (Phases A–D, 125 seed entries) │ └── beef-phaseE-450bets.json → 450 multi-step rounds (Phase E, 14 seed entries) ├── outputs/ → Committed artifacts of record (runs write to outputs/run/) │ ├── verification-results.json │ ├── simulation-results.json │ ├── determinism-log.json │ ├── chi-squared-results.json │ ├── rtp-claim-table.json │ └── rtp-convergence.html ├── verifier-parity/ → Pinned copies of ProvablyFair.org’s verifier code and Duel’s runner ├── evidence/ → Screenshots E01–E05, the config copy E07, Duel’s Verify-tab code E06 ├── capture/ → Reference records of the capture scripts (not runnable) ├── scripts/ → Config-table check, mutation battery, release manifest ├── RELEASE-MANIFEST.json → Release identity, artifact hashes, signature ├── README.md ├── MANIFEST.md └── package.json
Step-to-Section Cross-Reference25 scored steps mapped
| Step | Test Name | Report Section | Result |
|---|---|---|---|
| 1 | Seed Hash Integrity | S1 | Pass |
| 2 | Next-Seed Promotion + Forward Commitment Chain | S1 | Pass |
| 3 | Hash Consistency Within Epoch | S1 | Pass |
| 4 | Nonce Audit | S1, S5 | Capture flag |
| 5 | Outcome Recomputation (Death Points) | S1, S2, S3 | Pass |
| 6 | Client Seed Influence | S1, S2 | Pass |
| 7 | Payout Math | S3, S4 | Pass |
| 8 | Multiplier Formula (C(20,k)/C(20−m,k) × edge) | S3, S4 | Pass |
| 9 | Win Condition (all stepped tiles not in mines) | S3 | Pass |
| 10 | Phase C Bet-Size Invariance ($10 bets) | S3, S4 | Pass |
| 11 | Config Completeness & Payout-Table Coverage | S3 | Pass |
| 12 | House Edge Audit (effective_edge = 0.8%) | S4 | Pass |
| 13 | Population & Phase Labels | S3 | Pass |
| 14 | Dataset Hash | S7 | Pass |
| 15 | Epoch Size | S1 | Pass |
| 16 | Probability Independence (Anti-Circularity) | S4 | Pass |
| 17 | Phase D — Client Seed Variation | S1, S3 | Pass |
| 18 | Simulation Results — Pass 1 Integrity | S2, S4 | Pass |
| 19 | Simulation Results — Pass 2 Cherry-Pick Test | S4 | Pass |
| 20 | Multi-Step Multiplier Chain (Phase E) | S3 | Pass |
| 21 | Death-Point Recomputation (Phase E) | S3, S5 | Pass |
| 22 | Cash-Out Payout Correctness (k>1) | S3, S5 | Pass |
| 23 | Artifact Integrity (pinned artifacts of record) | S7 | Pass |
| 24 | Multiplier Monotonicity & Bounds | S4 | Pass |
| 25 | Live-Sample Fit (informational) | S2, S4 | Pass |
Game Profile CoverageBeef profile 1.0.2 · 30 checks
Framework 1.1 requires every check in the game profile to be covered by a scored step, by a package check, or marked n/a with a reason. All 30 checks of the Beef profile 1.0.2 are accounted for: 23 by scored steps, 6 by package checks and 1 n/a. The package marks three as partial coverage, with the reason given in the row.
| Profile check | Covered by | Coverage |
|---|---|---|
| BEEF-01 | Step 1 (Seed Hash Integrity) | Full |
| BEEF-02 | Step 2 (Next-Seed Promotion + Forward Commitment Chain) | Full |
| BEEF-03 | Step 3 (Hash Consistency Within Epoch) + Step 4 (Nonce Audit) | Full |
| BEEF-04 | Step 4 (Nonce Audit) · capture flag, verdict-neutral | Full |
| BEEF-05 | Step 13 (Population & Phase Labels) + Step 15 (Epoch Size) | Full |
| BEEF-06 | Step 6 (Client Seed Influence) + Step 17 (Phase D — Client Seed Variation) · partial: the capture’s client seeds came from Math.random() (Phases A–C and E) and a clock-derived string (Phase D), not a CSPRNG | Partial |
| BEEF-07 | Step 5 (Outcome Recomputation) + Step 21 (Death-Point Recomputation) | Full |
| BEEF-08 | Step 5 (Outcome Recomputation) | Full |
| BEEF-09 | Package check: RNG rebuilt from the written spec (docs/ALGORITHM.md, spec self-test); Duel’s Verify-tab code run unmodified as a second check in Step 5 | Full |
| BEEF-10 | Step 9 (Win Condition) | Full |
| BEEF-11 | Step 7 (Payout Math) + Step 22 (Cash-Out Payout Correctness) | Full |
| BEEF-12 | Step 10 (Phase C Bet-Size Invariance) | Full |
| BEEF-13 | Step 8 (Multiplier Formula) + Step 20 (Multi-Step Multiplier Chain) | Full |
| BEEF-14 | Step 24 (Multiplier Monotonicity & Bounds) | Full |
| BEEF-15 | Step 11 (Config Completeness & Payout-Table Coverage) | Full |
| BEEF-16 | n/a: no captured record carries a balance field, so there is no bet-to-bet balance change to reconcile; the credited amount is checked instead (Steps 7, 10, 22) | n/a |
| BEEF-17 | Step 20 (Multi-Step Multiplier Chain) + Step 21 (Death-Point Recomputation) + Step 22 (Cash-Out Payout Correctness) | Full |
| BEEF-18 | Step 16 (Probability Independence) | Full |
| BEEF-19 | Step 12 (House Edge Audit) + Step 16 (Probability Independence) · RTP claim rule scored here | Full |
| BEEF-20 | Step 18 (Simulation Results — Pass 1 Integrity) · partial: the simulation p-values are read from the pinned artifact, not re-derived on every run | Partial |
| BEEF-21 | Step 19 (Simulation Results — Pass 2 Cherry-Pick Test) · partial: a fixed MEDIUM single-step board; late windows read from the artifact, not replayed; no detection power stated | Partial |
| BEEF-22 | Step 25 (Live-Sample Fit) | Full |
| BEEF-23 | Package check: the S5 matrix in MANIFEST.md, each row tied to the scored steps that decide it | Full |
| BEEF-24 | Step 5 (Outcome Recomputation) | Full |
| BEEF-25 | Package check: The seven-step “Verify a bet” guide in MANIFEST.md, linked from the README | Full |
| BEEF-26 | Step 14 (Dataset Hash) | Full |
| BEEF-27 | Step 23 (Artifact Integrity) | Full |
| BEEF-28 | Package check: npm test and the reproduction gate: runs write to outputs/run/ and are compared with the committed results | Full |
| BEEF-29 | Package check: The mutation battery: 45 counterexamples, each rejected by a named scored step | Full |
| BEEF-30 | Package check: The evidence register E01–E07, the declared limitations and the load-bearing premises in MANIFEST.md | Full |
outputs/verification-results.json (profileCoverage and each step’s profileChecks).Release Historyv1.0.0 → v1.2.1
| Release | What changed | Verdict |
|---|---|---|
| v1.0.0 | The original audit, June 2026 | Full Pass |
| v1.1.0 | Re-certification under Framework 1.1: the RTP claim rule, two new scored steps and a mutation battery; dataset unchanged | Unchanged |
| v1.2.0 | RNG code rebuilt from a written spec; Duel’s Verify-tab code kept as a second check | Unchanged |
| v1.2.1 | A .gitattributes file keeps a Windows clone byte-identical; no audit content changed | Unchanged |
reproduce-audit.sh
Check out release v1.2.1 and run npm test: every result is recomputed, written to outputs/run/ and compared with the committed artifacts, and the exit code is the verdict. The dataset hashes pin the exact 6,450 rounds.