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

Beef

Certified · Active

Independent verification, backed by open-source code.

PF-2026-DL06Audited April 2026 · Updated October 2026Apr 2026 · Updated Oct 2026Framework 1.1Release v1.2.1Original audit 05530ee, June 2026, Jun 2026
AUDIT RESULTPassedPROVABLY FAIR — Full Pass24 / 25 steps passedPinned to release v1.2.1 and its datasets.
PROVABLY FAIR — Full Pass
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
24 / 25Verification steps passed

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.

DUEL BEEF$0.01 · Hard · 5 death points · Cash out at 5
Safe stepDeath point

Positions 0–19 · Cashed out after the recorded step

Bet #7844427Nonce 0 · Phase E3
50 real bets · Phase E3Bet 1 of 50
✓ Exact match
5.1215×

The casino result, reproduced.

Casino outcome
5 safe steps · Cashed out
Our reproduction
5 safe steps · Cashed out
Recorded payout
$0.0512
Open source

Run this audit yourself

Open GitHub ↗

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.

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

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

Results at a glance

Audit Verdict

CheckResultEvidence
Overall StatusPass
Proven RTPPass99.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 ParityPass6,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 SystemPassAll 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 AuditCapture flagNonces 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 SeedPassGenerated in the browser and submitted at rotation · a wrong client seed changes the full 20-tile shuffle on 6,000 / 6,000 bets
RNG AnalysisPassHMAC-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 LogicPassEvery 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 EdgePasseffective_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-CircularityPassTheoretical 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 IntegrityPass16 fairness integrity tests — all 16 pass (includes one Beef-specific multi-step state test)
DeterminismPassSame inputs, same death points on 6,450 / 6,450 rounds · npm test reproduces the committed results (exit 0)
Overall StatusPass
Proven RTPPass
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 ParityPass
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 SystemPass
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 AuditCapture 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 SeedPass
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 AnalysisPass
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 LogicPass
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 EdgePass
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-CircularityPass
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 IntegrityPass
16 fairness integrity tests — all 16 pass (includes one Beef-specific multi-step state test)
DeterminismPass
Same inputs, same death points on 6,450 / 6,450 rounds · npm test reproduces the committed results (exit 0)
Audit scope & reference

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
2 columns
AreaDescription
Commit-Reveal SystemSHA-256 commitments, next-seed promotion, reveal on rotation; commitment timing from the capture records
Client Seed OriginBrowser-generated, player-controlled, submitted at rotation and echoed by the server
Seed HandlingClient seed control, nonce lifecycle, seed pair rotation
RNG AnalysisHMAC-SHA256 backward Fisher-Yates, rebuilt from the written spec; draw-bias bound; Duel’s Verify-tab code run as a second check
Payout LogicMultiplier 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 ParityIndependent death-point recomputation of all 6,450 live rounds; ProvablyFair.org’s verifier code executed on every round
RTP ValidationTheoretical RTP from first principles, the RTP claim rule, 4M simulated rounds, cherry-pick screening (Pass 2)
Fairness IntegrityStandard 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.

Death-point positions are fixed by the seeds the moment the round starts, before you take a step. The road is the same for every difficulty; only the number of death points changes. A round uses one nonce, however many steps it takes.
Win Conditions

The win condition in Beef depends on whether every stepped tile avoided the death-point set.

3 columns
OutcomeConditionExample (difficulty=MEDIUM, k=3)
Safe stepStepped tile is not in death-point setMultiplier grows; player may cash out or continue
Cash outPlayer stops after k safe stepsk=3 → stake × 1.6631
LossStepped tile is in death-point setRound ends, bet is lost
Because stepping on any death point ends the round, the payout structure has no consolation payout — either you cash out with a multiplier, or you lose the bet.
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
3 columns
ParameterValueNotes
Grid Size20 tilesFixed; all difficulty levels use this layout
Difficulty Levels4 (EASY, MEDIUM, HARD, EXPERT)Player-selected; sets death-point count
Death Points by DifficultyEASY=1, MEDIUM=3, HARD=5, EXPERT=10Determines risk and multiplier curve
House Edge0.8% flatThe same at every difficulty and cash-out point; the config has no stake tiers
Theoretical RTP99.2%Derived for all 61 difficulty and cash-out settings
RNG AlgorithmHMAC-SHA256Backward 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.

4 columns
Seed TypeFormatExamplePurpose
Server Seed64-char hex (32 bytes)fcf0584a…Casino-provided randomness
Client SeedAlphanumeric string8AgNlaGR1fxeiy93Player-contributed entropy
NonceInteger ≥ 00Per-round counter within the active seed pair
The server seed is committed as serverSeedHashed (SHA-256 of the raw hex bytes) before play and revealed only on seed rotation. The HMAC key is the hex-decoded bytes of the server seed, not its UTF-8 text.
Multiplier & Payout

The payout multiplier after k safe 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
4 columns
Steps (k)Death Points (m)Raw multiplierWith 0.8% edge
111.0526×1.0442×
131.1765×1.1671×
151.3333×1.3227×
1102.0000×1.9840×
532.5055×2.4855×
1039.5000×9.4240×
555.1628×5.1215×
API field quirk — Duel’s API returns 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

2 columns
CheckWhat it shows
Server seed committed before playA seed changed after the bet would not match the commitment
SHA-256 of revealed seed matches committed hashRevealed seed is the one that was actually committed
Hash identical across all bets in an epochAll bets within a seed pair share the same commitment

Seed System

2 columns
CheckWhat it shows
Nonces are sequential within an epochNo nonce skipping or reuse
Single client seed per epochClient seed cannot be silently rotated mid-epoch
Next-seed hash published before rotationEach rotation activates the seed already published as next

RNG & Parity

2 columns
CheckWhat it shows
Death-point positions recompute from seeds + nonceOutcome is deterministic and verifiable
Independent verifier matches live API for every betNo hidden inputs to the RNG
Death-point set invariant across step sequenceLayout fixed at round start, not rewritten per step

Payout & RTP

2 columns
CheckWhat it shows
Multiplier matches C(20,k)/C(20−m,k) × 0.992Payout formula matches published rules
amount_won = amount × no_house_edge_multiplierPayout arithmetic holds to relative 1e-12
survival × payout multiplier = 0.992 at all 61 settingsRTP is fixed at 99.2% by construction, not observation

Integrity

2 columns
CheckWhat it shows
Wrong client seed produces different death pointsClient seed genuinely influences outcome
Bet size does not influence outcomePhase 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.

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

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 nonce time
nonce lifecycle · Illustrative
// Per seed pair, nonce sequence://   bet 1 → nonce=0//   bet 2 → nonce=1//   bet 3 → nonce=2//   ...// On client seed change://   serverSeed revealed, new pair activated, nonce resets to 0
Determinism Guarantee

Given serverSeed, clientSeed, nonce and 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:

MANIFEST.md · shuffle · lines 138–147 · Canonical
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 ascending
Technical Glossary7 categories▶

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

Core Concepts
2 columns
TermDefinition
Provably FairA system where every game outcome can be independently verified from disclosed cryptographic inputs, with limited trust in the operator.
Commit-RevealA 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.
DeterminismA property where the same inputs always produce the same output. Beef is deterministic: (serverSeed, clientSeed, nonce, deathPointsCount) uniquely determines the death-point set.
EpochThe set of bets placed under a single active seed pair, from activation to rotation. Also called a seed pair lifecycle.
Seed System
2 columns
TermDefinition
Server SeedA 32-byte random value generated by the casino. Represented as a 64-character hex string. Used as the HMAC key (hex-decoded).
Server Seed HashedSHA-256(hex_bytes(serverSeed)). The commitment published before play.
Client SeedA player-controlled alphanumeric string, browser-generated by default. Part of the HMAC message.
NonceA per-round counter within the active seed pair. Starts at 0, increments per bet, shared across all 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 PairThe combination of one server seed and one client seed. A seed pair defines an epoch.
Next Server Seed HashThe hash of the server seed that becomes active at the next rotation, published before it. Each rotation must activate it.
Phase-Boundary MarkerA 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
2 columns
TermDefinition
SHA-256A 256-bit cryptographic hash function. Used here for server seed commitment: SHA-256(hex_bytes(serverSeed)) = serverSeedHashed.
HMAC-SHA256Hash-based message authentication code built on SHA-256. Takes a key and a message, returns a 256-bit (64-hex-char) digest. Used here for death-point position generation.
HMAC-SHA256 Backward Fisher-YatesThe 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 SamplingA 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
2 columns
TermDefinition
ParityAgreement between the live game’s reported outcome and an independent recomputation from the same inputs. 100% parity means zero mismatches.
RecomputationRunning the audit’s standalone RNG implementation on captured seed triples and comparing the output to the live API response.
Anti-Circularity ProofA proof that RTP is not an empirical observation but a mathematical identity — winChance × payoutMult = 0.992 by algebraic cancellation, independent of any simulation.
Hypergeometric DistributionThe 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
2 columns
TermDefinition
Grid SizeThe total number of tiles on the Beef board. Fixed at 20 for all difficulty levels.
Difficulty LevelOne of four settings (EASY, MEDIUM, HARD, EXPERT) that determines how many of the 20 tiles are death points (1, 3, 5, 10 respectively).
Death PointA tile position that ends the round on contact. Placed by the Fisher-Yates shuffle; count determined by difficulty level.
StepMoving one tile along the road. A safe step grows the multiplier; a death point ends the round.
Multiplier ChainThe 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-OutStopping after k safe steps and collecting amount × mₖ. Only available after at least one safe step.
Death-Point Set InvarianceThe 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
2 columns
TermDefinition
Fairness Integrity (FI) MatrixThe standard test matrix applied to every audit, covering commit-reveal, determinism, payout, isolation, and parameter enforcement. Documented in S5.
Chi-Squared TestA 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 CorrectionA multiple-comparison adjustment: when testing N hypotheses at significance α, the per-test threshold is α/N. Prevents false positives from mass testing.
Point-in-Time AuditAn audit verdict that applies to the code and configuration in force at the audit date. Subsequent changes are outside scope unless re-certified.
Framework 1.1The 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 RuleRTP-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 FlagA 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 ProfileThe 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 GateEvery 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
2 columns
TermDefinition
beef-master-6000bets.jsonPrimary 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.jsonMulti-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.jsonOutput of the 25-step verification suite: per-step status, details, data blocks and profile mappings.
simulation-results.jsonOutput 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.jsonThe RTP claim rule’s table: the exact RTP of all 61 settings against the published 99.2%.
01

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.

Commit-Reveal Consistency

131 / 131commitments verified

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
131 / 131commitments 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
HMAC-SHA256 Pipeline — Seed inputs through backward Fisher-Yates to death-point positions — illustrated flow
CheckResultEvidence
Commitment matches revealed seedPass121 / 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 betsInfoRecorded before the first bet in 121 / 121 primary and 10 / 10 Phase E epochs (capture timestamps, not scored)
Next-seed promotionPass125 / 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 epochPassEpochs taken from the rotation timeline: every bet carries the commitment and client seed of the rotation active at its timestamp (Step 3)
Nonce sequencingCapture flagFrom 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 originPassGenerated 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 influencePassA wrong client seed changes the full 20-tile shuffle on 6,000 / 6,000 bets; so does an empty one (Step 6)
Deterministic outputPassSame (serverSeed, clientSeed, nonce, difficulty) always gives the same death points: 6,450 / 6,450 (Steps 5 and 21)
Commitment matches revealed seedPass
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 betsInfo
Recorded before the first bet in 121 / 121 primary and 10 / 10 Phase E epochs (capture timestamps, not scored)
Next-seed promotionPass
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 epochPass
Epochs taken from the rotation timeline: every bet carries the commitment and client seed of the rotation active at its timestamp (Step 3)
Nonce sequencingCapture 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 originPass
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 influencePass
A wrong client seed changes the full 20-tile shuffle on 6,000 / 6,000 bets; so does an empty one (Step 6)
Deterministic outputPass
Same (serverSeed, clientSeed, nonce, difficulty) always gives the same death points: 6,450 / 6,450 (Steps 5 and 21)
✓  Commit-reveal consistent

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.

Server Seed Commitment — illustrated flow
src/rng.ts · verifyHash · lines 199–209 · Verified
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();}
Result: 121 / 121 primary rotations verified, 0 mismatches, 0 seed rows without plaintext. Three phase-boundary rotations are declared exemptions: the opening rotation of Phases B, C and D reveals the previous phase’s last bet-bearing seed again, not the end-of-phase seed, which had no bets. The package fixes that count at exactly 3 and checks it.

Real Example from Live Data:

beef-master-6000bets.json · round 7722773 and the reveal that follows it
// 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:

verify-seed.js · Verified
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.

tests/steps/commitment.ts · Step 2 · lines 108–140 · Verified
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',  );}
Result: Primary file: 125 / 125 promotions recomputed from raw hex, 124 / 124 forward links, pre-capture link present. Phase E file: 14 / 14 promotions, 13 / 13 forward links, pre-capture link present. 0 mismatches.
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.

tests/steps/commitment.ts · Step 3 · lines 210–233 · Verified
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 };
Result: Primary file: 6,000 bets in 121 bet-bearing windows, 4 rotation records with no bets (the phase boundaries and the end of the capture), 0 orphans. Phase E file: 450 bets in 10 windows. Every bet carries the commitment and client seed of the rotation active at its timestamp.
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.

2 columns
PropertyValue
Epochs with bets121 primary + 10 Phase E
Seed entry recorded before the first bet121 / 121 and 10 / 10
Lead time before the first bet1.7 to 5.4 seconds (capture timestamps; measured, not scored)
Pre-capture readingThe next hash read before the first rotation equals the first epoch’s commitment (Step 2)
Timing: This order comes from the capture’s own timestamps. A forged record would still have to recompute from a seed that hashes to the commitment it was served under.
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.

  • 8AgNlaGR1fxeiy93
  • 2u03Imtz0NnpNAkl
  • sl0FFAHA20CUJBSy
  • td4o47U8ntfUFG6k
  • pfauditmo2180iw
Result: 131 distinct client seeds, one per epoch: 105 from Phases A–C and 16 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.

Nonce Incrementation — illustrated flow
5 columns
Missed roundEASYMEDIUMHARDEXPERT
Primary · b2dfe984… #251313, 16, 191, 3, 13, 16, 191, 3, 5, 6, 7, 9, 10, 13, 16, 19
Phase E · 1dfe6dcf… #31115, 11, 130, 5, 11, 13, 150, 3, 5, 11, 13, 14, 15, 16, 17, 18
tests/steps/commitment.ts · Step 4 · lines 274–302 · Verified
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 });    }  }
Capture flag: Nonces from 0 with no repeat in all 131 epochs, one client seed per epoch. The table gives the death points the revealed seeds produce at each difficulty for the two missed rounds. The Phase E round was in E4, which is EXPERT only; the primary round’s difficulty was not captured. Verdict-neutral: the verdict stays Full Pass.
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.

Deterministic Mapping — illustrated flow
src/rng.ts · computeDeathPoints · lines 157–193 · Verified
/** * §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);}
Result: All 6,450 rounds: the recomputed death points equal the served mines_positions, 0 mismatches, 0 skipped. No other input enters the computation.

Real Bet Verified:

beef-master-6000bets.json · round 7722773 · 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:

verify-beef.js · Verified
// 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.

3 columns
StatisticObservedExpected by chance
Full permutation changed (wrong seed)6,000 / 6,0006,000
Full permutation changed (empty seed)6,000 / 6,0006,000
Same death-point set by chance59 (58 EASY, 1 MEDIUM)61.3
tests/steps/determinism.ts · Step 6 · lines 242–263 · Verified
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;  }}
Result: The client seed is a genuine input: a different one changes the shuffle on every bet. Phase D’s 800 bets on 16 player-set seeds also recompute, 800 / 800 (Step 17).
Technical Evidence & Verification5 sections
1.9Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Seed hash integrity (Step 1)121 / 121 primary rotations, 3 declared phase-boundary exemptionsPass
Next-seed promotion (Step 2)125 / 125 and 14 / 14 rotations, pre-capture links presentPass
Hash consistency (Step 3)121 + 10 bet-bearing windows from the rotation timelinePass
Commitment timing (capture records)121 / 121 and 10 / 10 recorded before the first betInfo
Nonce audit (Step 4)131 epochs sequential; 2 capture retries reconstructedCapture flag
Death-point recomputation (Steps 5, 21)6,000 / 6,000 and 450 / 450Pass
Client seed influence (Step 6)6,000 / 6,000 permutations change; empty-seed control 6,000 / 6,000Pass
Epoch size (Step 15)119 epochs of 50, plus the capture-retry pair of 1 and 49Pass
1.10Code References7 source files
2 columns
FilePurpose
tests/verify.tsRuns the 25 scored steps and the reproduction gate (Steps 1–6 cover S1)
tests/steps/commitment.tsSteps 1–4: commitments, next-seed promotion, hash consistency, nonce audit
tests/steps/determinism.tsSteps 5–6: death-point recomputation and client seed influence
src/rng.tsHMAC-SHA256 backward Fisher-Yates and verifyHash, rebuilt from docs/ALGORITHM.md
src/loader.tsDataset loading, the SHA-256 check and the pinned population constants
capture/beef-capture.reference.jsReference record of the capture script for all phases (not runnable)
capture/beef-capture-phaseE.reference.jsReference record of the Phase E capture script (not runnable)
1.11Datasets UsedSource artifacts
This audit uses two capture files:
2 columns
PropertyValue
Filedata/beef-master-6000bets.json
ScopePhases 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.
Records6,000 bets, 125 seed entries, 121 bet-bearing epochs
SHA-256d654ef7c6195584501e9033202d5acad13a16d89d296baab8befc0240fb36d36
2 columns
PropertyValue
Filedata/beef-phaseE-450bets.json
ScopePhase E, captured 21 April 2026: multi-step rounds with cash-out targets of 2, 3 and 5 steps on all four difficulty levels
Records450 bets, 14 seed entries, 10 bet-bearing epochs
SHA-256ef39d7f584cdb6d8057e846cdcb9b4ffcc60495bfcce8443d15bb910a9c51001

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
2 columns
InvariantResult
SHA-256(hexDecode(serverSeed)) equals the commitment at every primary rotation and for every bet-bearing seedPass
Each rotation activates the published next hash: 125 / 125 and 14 / 14, pre-capture links presentPass
Every bet carries the commitment and client seed of the rotation active at its timestampPass
Nonces sequential from 0 with no repeat in every epoch, one client seed per epochPass
Two missed nonces reconstructed from commitment-matching revealed seedsCapture flag
Same inputs produce the same death points for all 6,450 roundsPass
A wrong or empty client seed changes the full permutation on 6,000 / 6,000 betsPass
Client seed set in the browser and echoed, not assigned, by the serverPass
1.13Reproduction InstructionsRun locally

Clone the release, install dependencies and run the suite:

reproduce-s1.sh · 5 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test   # Steps 1–6 cover S1
Steps 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 Influence
02

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

Cryptographic Randomness Verification

6,450 / 6,450rounds reproduced

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
6,450 / 6,450rounds reproduced
  • 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
RNG Pipeline — HMAC-SHA256 → uint32 → rejection sampling → Fisher-Yates swap → death-point SET — illustrated flow
CheckResultEvidence
RNG derived only from disclosed inputsPassHMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:t) for draw t = 0 … 18; 6,450 / 6,450 rounds reproduce from these inputs alone
RNG code originPassRebuilt 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 checkPassDuel’s Verify-tab code (E06), run unmodified: its death points equal the served ones and ours on 6,450 / 6,450 rounds
Modulo biasPassAccepted window a whole number of ranges on all 19 ranges, measured from the code: bias exactly 0 (Step 5)
Key encodingPassThe 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 independencePass4 × 1M simulated rounds: 0 / 4 position chi-squared and 0 / 4 serial failures at Bonferroni α/4 = 0.0025 (Step 18)
Live-sample fitPassDeath-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
HMAC-SHA256(hexDecode(serverSeed), clientSeed:nonce:t) for draw t = 0 … 18; 6,450 / 6,450 rounds reproduce from these inputs alone
RNG code originPass
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 checkPass
Duel’s Verify-tab code (E06), run unmodified: its death points equal the served ones and ours on 6,450 / 6,450 rounds
Modulo biasPass
Accepted window a whole number of ranges on all 19 ranges, measured from the code: bias exactly 0 (Step 5)
Key encodingPass
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 independencePass
4 × 1M simulated rounds: 0 / 4 position chi-squared and 0 / 4 serial failures at Bonferroni α/4 = 0.0025 (Step 18)
Live-sample fitPass
Death-point positions of the 6,450 live rounds fit the uniform lattice at all 4 difficulty levels (Step 25, informational)
✓  Unbiased and cryptographically sound

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.

2 columns
ComponentDetail
Hash functionHMAC-SHA256, one call per draw
KeyBuffer.from(serverSeed, 'hex') — 32 bytes
MessageclientSeed:nonce:t, draw index t = 0 … 18
ExtractionEight 4-byte chunks per digest, each read as a big-endian uint32
Rejectionchunk < floor(2^32 / r) × r — a whole number of ranges
Reductionchunk mod r → swap index j ∈ [0, r)
ShuffleBackward Fisher-Yates: slots 19 down to 1, ranges 20 down to 2
OutputThe first m slots, sorted → the death-point set
src/rng.ts · drawIndex · computePermutationFromBuffer · lines 94–155 · Verified
/** * §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;}
Result: Our code reproduces all 6,450 live rounds, 0 mismatches. Duel’s published Verify-tab code, saved verbatim from duel.com on 26 September 2026 (E06), is run unmodified as a second check, not used as the source: it agrees on all 6,450. The two can differ only where no captured round reaches (2.3).

The written specification it was built from:

docs/ALGORITHM.md · §2 Step 2 · lines 143–148 · Spec
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 O1
2.2Entropy Sources

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

Entropy Sources — illustrated flow
3 columns
SourceControlled ByPurpose
Server SeedCasinoThe HMAC key, committed by its SHA-256 hash before the epoch’s bets
Client SeedPlayerPlayer-contributed entropy in every HMAC message
NonceSystemMakes each round unique; counts up within each epoch
Draw index tFixedSeparates the 19 draws of one shuffle (t = 0 … 18)
No mixed entropy sources detected. The same inputs always produce the same death points: 6,450 / 6,450.

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.
src/rng.ts · maxFairFor · drawFromChunk · lines 66–80 · Verified
/** §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;}
Result: Zero modulo bias: every swap index is exactly equiprobable on all 19 ranges of the shuffle.

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.

RNG Isolation — illustrated flow
Result: No state carries over between draws, rounds or epochs. Each HMAC call is keyed and messaged on its own.

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.

5 columns
DifficultyPosition χ² (df 19)pWin rateExpected
EASY (m=1)17.950.52694.9942%95%
MEDIUM (m=3)23.530.21584.9665%85%
HARD (m=5)20.180.38474.9610%75%
EXPERT (m=10)8.780.97749.9415%50%
src/simulate.ts · SIM_SEEDS · lines 50–58 · Verified
// ── 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' },];
Result: 4M rounds simulated. 0 / 4 difficulties fail the position chi-squared, at α = 0.01 or at Bonferroni α/4. The death-point positions are consistent with a uniform shuffle of the 20 tiles.

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

4 columns
Difficultyr₁zRuns p
EASY (m=1)-0.00021-0.210.837
MEDIUM (m=3)-0.00028-0.280.780
HARD (m=5)0.000480.480.628
EXPERT (m=10)-0.00062-0.620.536
src/stats.ts · runsTest · lines 170–187 · Verified
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 };}
Result: 0 / 4 difficulties fail either test. Every |r₁| is below 0.001, and every runs p is above 0.5.
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.

4 columns
DifficultyLive roundsCorrected χ² (df 19)p
EASY (m=1)1,30018.310.5020
MEDIUM (m=3)1,50037.840.0062
HARD (m=5)1,3507.580.9904
EXPERT (m=10)2,30018.170.5111
tests/steps/live-fit.ts · Step 25 positions · lines 44–69 · Verified
// ── 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}`);}
Result: All 12 live-sample tests (4 position fits here, 8 win-rate fits in S4) are above the Bonferroni bound 0.01 / 12 ≈ 0.00083. The smallest is the MEDIUM position fit, p = 0.0062.
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]
7 columns
tirangeHMAC[:8]uint32jswap
019205ed36ebf1,590,914,75111pos[19]↔︎pos[11]
11819ee6377b73,999,496,11914pos[18]↔︎pos[14]
2171879caf9152,043,345,1735pos[17]↔︎pos[5]
31617e6d478483,872,684,1045pos[16]↔︎pos[5]
41516a582f7fe2,776,823,80614pos[15]↔︎pos[14]
Parity verified: Round 7722773: the death-point set matches the recomputation exactly. Every draw accepted its first chunk. Tile 0 is not a death point, so the one step wins. Multiplier (m = 3, k = 1): 20 / 17 × 0.992 = 1.1670588…; payout 0.01 × 1.1670588… = 0.011670588, as served.
Live GameSET = {1, 9, 15}
VerifierSET = {1, 9, 15}
Technical Evidence & Verification5 sections
2.9Evidence Coverage Summary8 checks
3 columns
Verification AreaCoverageResult
Death-point recomputation (Steps 5, 21)6,000 / 6,000 primary and 450 / 450 Phase E roundsPass
Operator code, second check (Step 5)Duel’s Verify-tab code on 6,450 / 6,450 roundsPass
Key encoding (hex, not text)Confirmed by recomputationPass
Draw-bias bound (Step 5)All 19 ranges, measured from the code: bias 0Pass
Client seed influence (Step 6)6,000 / 6,000 permutations changePass
Simulation position chi-squared (Step 18)0 / 4 fail at Bonferroni α/4Pass
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
2 columns
FilePurpose
docs/ALGORITHM.mdThe written specification the RNG code was rebuilt from
src/rng.tsHMAC-SHA256 backward Fisher-Yates (drawIndex, computePermutationFromBuffer, computeDeathPoints)
src/bias.tsThe draw-bias bound, measured from drawFromChunk (audit code, not part of the RNG)
src/operator-verifier.tsRuns Duel’s pinned Verify-tab code (E06) as a second check
src/simulate.tsTwo-pass simulation: 4M rounds on pinned seeds; 121 casino seeds × 10,000 nonces
src/stats.tsChi-squared, lag-1 autocorrelation and the Wald-Wolfowitz runs test
tests/steps/determinism.tsSteps 5–6: recomputation, bias bound, verifier parity, client seed influence
tests/steps/simulation.tsSteps 18–19: simulation integrity and the cherry-pick test
tests/steps/live-fit.tsStep 25: live-sample fit (informational)
2.11Verified Invariants9 invariants
2 columns
InvariantResult
HMAC-SHA256 recomputation matches the live game for all 6,450 roundsPass
Duel’s Verify-tab code, run unmodified, agrees on all 6,450 roundsPass
The key is the hex-decoded seed; the text key does not reproduce the roundsPass
Rejection sampling leaves zero bias on all ranges 2–20Pass
No external entropy is needed to reproduce any roundPass
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 levelsPass
Live death-point positions fit the uniform lattice at all 4 difficulty levelsPass
A different client seed changes the full permutation on 6,000 / 6,000 betsPass
2.12Datasets UsedSource artifacts
Simulation: outputs/simulation-results.json — Pass 1, 4M rounds across the 4 difficulty levels
Primary dataset: data/beef-master-6000bets.json — 6,000 live rounds for death-point recomputation (Step 5)
Phase E dataset: data/beef-phaseE-450bets.json — 450 multi-step rounds (Step 21)
Simulation output: outputs/simulation-results.json — Pass 1 (4M rounds, position chi-squared and serial tests) and Pass 2 (121 casino seeds × 10,000 nonces)
Determinism log: outputs/determinism-log.json — summary of the primary death-point recomputation: 6,000 verified, 0 mismatches, 0 skipped
2.13Reproduction InstructionsRun locally

Clone the release, install dependencies and run the suite:

reproduce-s2.sh · 6 lines · Verified
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 it
Steps 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)
03

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.

Live ↔︎ Verifier Parity

6,450 / 6,450rounds matched

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
6,450 / 6,450rounds matched
  • 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
Parity Verification Flow — seeds → recompute → compare → exact match — illustrated flow
6,450Live Rounds Tested
100%Parity Rate
$0.01 & $10Stakes Tested
0Mismatches
CheckResultEvidence
Death-point set recomputationPass6,000 / 6,000 primary and 450 / 450 Phase E rounds match exactly (Steps 5 and 21)
Player-verifier parityPassProvablyFair.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 correctnessPassamount_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 formulaPass4,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 conditionPass6,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 independencePassThe 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 coveragePass5 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
6,000 / 6,000 primary and 450 / 450 Phase E rounds match exactly (Steps 5 and 21)
Player-verifier parityPass
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 correctnessPass
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 formulaPass
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 conditionPass
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 independencePass
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 coveragePass
5 phases: all difficulties (A), EXPERT at volume (B), $10 stakes (C), player-set client seeds (D), multi-step cash-outs (E)
✓  Live game and verifier fully aligned

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.

Why Parity Matters — illustrated flow
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.

5 columns
PhaseBetsConfigStakePurpose
A — Baseline difficulty coverage4,000All 4 difficulties (1,000 each)$0.01Formula and recomputation at every difficulty
B — EXPERT at volume1,000EXPERT (m=10)$0.01The highest-variance setting: 50% first-step win chance
C — Stake equivalence200MEDIUM (m=3)$10.00The same formula and RNG path at 1,000× the stake
D — Player-set client seeds800Random difficulty$0.0116 pfaudit client seeds, one per epoch
E — Multi-step & cash-out450E1 EASY to 5 steps · E2 MEDIUM to 3 · E3 HARD to 5 · E4 EXPERT to 2$0.01Ladder multipliers, cash-outs and losses at k > 1
Total: 6,450 bets across 131 bet-bearing epochs (139 seed entries). Total wagered: $2,062.50 ($40.00 Phase A + $10.00 Phase B + $2,000.00 Phase C + $8.00 Phase D + $4.50 Phase E).
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.

Death-Point Recomputation (Step 5) — illustrated flow
tests/steps/determinism.ts · Step 5 · lines 36–47 · Verified
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++;}
Result: 6,000 / 6,000 primary rounds verified, 0 skipped, 0 mismatches; 450 / 450 Phase E rounds (Step 21). Every recomputed set equals 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.

4 columns
ImplementationPinnedRoundsResult
ProvablyFair.org verifier code (derive.js)0003d6347506334f…6,4500 disagreements; multiplier within 1e-12 on 4,539 wins
Duel’s Verify-tab code (E06)43ba4dfbd068cbf5…6,450Equal to the served and recomputed death points on every round
tests/steps/determinism.ts · Step 5 site verifier · lines 109–130 · Verified
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++;  }}
Result: All three implementations agree on all 6,450 rounds. Duel’s code agreeing does not establish that the live Verify button, or Duel’s server, runs exactly that code.
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.

Payout Math (Step 7) — illustrated flow
tests/steps/payouts.ts · Step 7 · lines 18–28 · Verified
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++;  }}
Result: 6,000 / 6,000 primary bets: 0 errors at relative 1e-12. In Phase E, 202 / 202 cash-outs pay stake × the rung multiplier × 0.992 and 248 / 248 losses credit exactly 0 (Step 22).
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).

2 columns
MetricCount
Winning primary bets checked (k = 1)4,337
Matching the exact fraction at relative 1e-124,337 (worst 5.0 × 10⁻¹⁹)
Mismatches0
Phase E ladder rungs (Step 20)1,085 across 15 (difficulty, k) cells (worst 9.63 × 10⁻¹⁵)
Config table cells (E07)61 / 61
tests/steps/payouts.ts · Step 8 · lines 42–53 · Verified
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++;}
Result: Every served multiplier matches the formula. The k > 1 values carry Duel’s fixed-precision rounding (each step’s win chance is rounded to 14 decimals), at most 9.63 × 10⁻¹⁵ relative, far inside the bound. One flat 0.8% edge applies at every difficulty.
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.

3 columns
ScopeCoverageVerified
Primary dataset (Phases A–D)6,000 single-step rounds6,000 / 6,000
Phase E multi-step rounds450 rounds, 1 to 5 steps450 / 450
Phase E cash-outs at k > 1 (Step 22)202 winning rounds202 / 202
tests/steps/payouts.ts · Step 9 · lines 74–90 · Verified
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}`);  }}
Result: The win rule holds on all 6,450 rounds: a win only when every stepped tile is safe, and every loss ends on its first death point. No off-by-one errors and no position-specific logic.
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.

Result: Phase C: 200 / 200 death-point sets recomputed at $10, 165 wins, 0 formula or payout errors.
Variance context: At MEDIUM the first-step win chance is 85%. Phase C won 165 of 200 against 170 expected, about one standard deviation, and returned 96.28% of its stake. At 200 bets the empirical return is not a measure of fairness; the theoretical 99.2% is derived in S4.
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
3 columns
StepProcessOutput
1Backward Fisher-Yates: 19 HMAC-SHA256 drawsShuffled tile array
2The first slot (m = 1) → death-point set{6}
3Steps on tiles 0, 1, 2, 3, 4 — none is a death point5 safe steps
4Raw ladder C(20,k) / C(19,k) for k = 1 … 51.0526× → 1.1111× → 1.1765× → 1.2500× → 1.3333×
5Cash-out at k = 5: 1.3333… × 0.992, × $0.01$0.0132267 ✅
Recomputation and multiplier chain (worked) · Verified
// 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... ✅
Parity verified: Round 7843993: the death-point set, the step path, the multiplier ladder and the cash-out payout all match. This one round exercises Steps 9, 20, 21 and 22 end to end, and the two verifier checks in Step 5.
Live GameSET = {6}, payout = 0.0132267
VerifierSET = {6}, payout = 0.0132267
Technical Evidence & Verification5 sections
3.10Evidence Coverage Summary12 checks
3 columns
Verification AreaCoverageResult
Death-point recomputation (Step 5)6,000 / 6,000 primary roundsPass
Player-verifier parity (Step 5)ProvablyFair.org’s verifier code on 6,450 / 6,450 roundsPass
Payout math (Step 7)6,000 / 6,000 bets at relative 1e-12Pass
Multiplier formula (Step 8)4,337 winning bets, exact fractionsPass
Win condition (Step 9)6,450 / 6,450 rounds against recomputed death pointsPass
Phase C bet-size invariance (Step 10)200 / 200 at $10, 165 winsPass
Config completeness (Step 11)All 4 difficulties ≥ 1,000 bets; 15 of 61 cells observedPass
Population and phases (Step 13)6,000 bets, 125 seed records, phases A–DPass
Phase D client seeds (Step 17)800 / 800 on 16 player-set seedsPass
Multi-step multiplier chain (Step 20)1,085 rungs across 15 cellsPass
Phase E recomputation (Step 21)450 / 450 multi-step roundsPass
Cash-out payouts (Step 22)202 cash-outs (k=2: 27, k=3: 67, k=5: 108); 248 losses credit 0Pass
3.11Code References7 source files
2 columns
FilePurpose
tests/steps/determinism.tsStep 5: recomputation, ProvablyFair.org’s verifier code and Duel’s Verify-tab code
tests/steps/payouts.tsSteps 7–12: payout math, multiplier formula, win condition, Phase C, coverage, house edge
tests/steps/dataset.tsSteps 13–17: population, dataset hash, epoch size, anti-circularity, Phase D
tests/steps/multireveal.tsSteps 20–22: multi-step chain, Phase E recomputation, cash-out payouts
src/exact.tsExact-fraction multipliers and the relative-deviation measure
src/site-verifier.tsPins and loads ProvablyFair.org’s verifier code (derive.js, hmac-sha256.js)
scripts/check-config-table.mjsChecks the 61 cells of Duel’s config table (E07) against the formula
3.12Datasets UsedSource artifacts
Primary dataset: data/beef-master-6000bets.json — 6,000 live rounds across Phases A–D (121 bet-bearing epochs)
Phase E dataset: data/beef-phaseE-450bets.json — 450 multi-step rounds across 4 sub-phases (10 epochs)
Game config: evidence/E07-cross-road-config-2026-10-05.json — Duel’s Beef config, fetched 5 October 2026: 61 payout cells, no stake tiers
Verification output: outputs/verification-results.json — Steps 5, 7–12, 17 and 20–22
3.13Verified Invariants11 invariants
2 columns
InvariantResult
Recomputed death-point set equals the served mines_positions for all 6,450 roundsPass
ProvablyFair.org’s verifier code and Duel’s Verify-tab code agree with the recomputation on all 6,450 roundsPass
amount_won = amount × no_house_edge_multiplier to relative 1e-12; every loss credits 0Pass
Paid multipliers equal C(20,k) / C(20−m,k) × 0.992 and raw multipliers the ratio alone, at relative 1e-12Pass
Win only when no stepped tile is a death point; every loss ends on its first death pointPass
$10 bets pay by the same formula as $0.01 betsPass
No inputs beyond (serverSeed, clientSeed, nonce, difficulty) affect the death pointsPass
All 4 difficulty levels present, each above the 1,000-bet floorPass
Phase D: 800 / 800 rounds on 16 player-set client seeds recomputePass
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 5Pass
3.14Reproduction InstructionsRun locally
reproduce-s3.sh · 5 lines · Verified
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 S3
Steps 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)
04

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.

Return to Player Verification

99.2%theoretical RTP

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
99.2%theoretical RTP
  • 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
INDEPENDENT DERIVATION
winChance(m, k) × multiplier(m, k)= 0.992
Combinatorial cancellation · All 4 difficulties · All 61 difficulty and cash-out settings

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

99.2%Theoretical RTP (all 61 settings)
99.147%Simulated (4M rounds)
0.8%House Edge (flat)
61/61Settings within the claim
CheckResultEvidence
Theoretical RTP (anti-circularity)Passsurvival(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 rulePassPublished 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 tiersPasseffective_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 exactPassAll served multipliers equal the formula at relative 1e-12; all 61 config cells match it (E07)
Simulated RTP (Pass 1)Pass4M 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)Pass121 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 monotonicityPassAll 61 cells strictly increase with depth and difficulty; no max-odds cap is declared (Step 24)
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 rulePass
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 tiersPass
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 exactPass
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 monotonicityPass
All 61 cells strictly increase with depth and difficulty; no max-odds cap is declared (Step 24)
✓  RTP matches the published 99.2%

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.

Theoretical RTP — Anti-Circularity (Step 16) — illustrated flow
3 columns
ComponentFormulaSource
Survival after k stepssurvival(m, k) = C(20−m, k) / C(20, k)Combinatorics of the shuffle, not the casino
Paid multipliermultiplier(m, k) = C(20, k) / C(20−m, k) × 0.992Duel’s formula and config table
RTPsurvival × multiplierIndependent probability × paid multiplier
Result= 0.992 at all 4 difficulty levels and every valid kExact cancellation
5 columns
Difficulty (m)Survival (k=1)Multiplier (with edge)Survival × MultiplierRTP
EASY (1)19/20 = 0.95000020/19 × 0.992 = 1.044211124/12599.2%
MEDIUM (3)17/20 = 0.85000020/17 × 0.992 = 1.167059124/12599.2%
HARD (5)15/20 = 0.75000020/15 × 0.992 = 1.322667124/12599.2%
EXPERT (10)10/20 = 0.50000020/10 × 0.992 = 1.984000124/12599.2%
Result: All 61 settings: RTP = 99.200000%, exactly 124/125. The largest floating-point deviation from 0.992 is 2.22 × 10⁻¹⁶, two units in the last place (EASY, k = 17). The counting anchor agrees at every setting and the negative control is rejected at all 61.

Anti-Circularity Verification:

tests/steps/dataset.ts · Step 16 · lines 156–177 · Verified
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.

5 columns
DifficultySettingsTrue RTP (exact)Gap to 99.2%Outcome
EASY (m=1)k = 1 … 19 (19 settings)124/125 = 99.200000% at every k0.000000 ppPass
MEDIUM (m=3)k = 1 … 17 (17 settings)124/125 = 99.200000% at every k0.000000 ppPass
HARD (m=5)k = 1 … 15 (15 settings)124/125 = 99.200000% at every k0.000000 ppPass
EXPERT (m=10)k = 1 … 10 (10 settings)124/125 = 99.200000% at every k0.000000 ppPass
src/rtp-settings.ts · computeRtpClaim · lines 44–54 · Verified
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();}
Result: PASS. True minimum and maximum 99.200000%; 0 settings beyond the band on the house side, 0 on the player side. The full per-setting table is 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%.

Result: House edge confirmed flat at 0.8%: the formula on every primary win (Step 8) and multi-step cash-out (Step 22), payouts reconciled (Step 7) and effective_edge 0.8 on all 6,000 primary bets (Step 12). No stake tiers in the config.
Variance note: Beef is high-variance at high difficulty. EXPERT (m = 10) pays 1.984× at k = 1, 61.03× at k = 5 and 183,277.952× for the full traversal at k = 10, while the chance of reaching each falls from 50% to 1 in 184,756. Empirical returns from small samples will move far from 99.2%; the derivation in 4.1 is the RTP evidence. No max-odds cap is declared for Beef, and a server-side payout cap was not tested.
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.

4 columns
DifficultyTheoretical RTPSimulated 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
Result: Mean simulated RTP 99.147% across the 4 difficulty levels, consistent with 99.2%. All 4 pass the position chi-squared and serial tests.
Variance note: Pass 1 simulates single-step rounds, so EXPERT pays 1.984× half the time; its per-round standard deviation is the largest of the four, and so is its deviation. Low difficulties stay close to 99.2% because wins are frequent and small.
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.

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

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.

src/simulate.ts · Pass 1 core loop · lines 158–171 · Verified
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);}
Result: 4M rounds. Mean simulated RTP 99.1468%. 0 / 4 chi-squared and 0 / 4 serial failures. Step 18 reads Pass 1’s statistics from the pinned simulation artifact; Step 19 recomputes its own and replays the early windows.

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

Disclosed: Pass 1 scores each round on a rotating tile, 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.

5 columns
RuleMoves the step toTriggers atFalse alarm (model / exact)This dataset
Test A: full window off at p < 0.01FAIL5 or more seeds0.76% / 0.89%0
Test B: early off, late not (p < 0.05)FLAG11 or more4.0% / 1.3%2
Test B, same countFAIL13 or more0.77% / 0.18%2
Off in both windows at p < 0.05FLAG2 or more3.7% / 2.9%1
Off in both windows, same countFAIL3 or more0.36% / 0.25%1
Off in both windows at p < 0.001FAIL1 or more0.012% / 0.024%0
tests/steps/simulation.ts · Step 19 · lines 127–151 · Verified
  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++;}
Result: PASS. No count reaches its trigger: 0 of 5 for Test A, 2 of 11 for Test B, 1 of 2 for seeds off in both windows. The test finds no sign of seed pre-selection. Without a beacon, the risk is screened statistically, not excluded.
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.

3 columns
MetricPhase A ($0.01)Phase C ($10)
Bets4,000 (all 4 difficulties, 1,000 each)200 (MEDIUM, m=3)
Stake$0.01$10.00
Death-point recomputation4,000 / 4,000200 / 200
Multiplier formulaC(20,k)/C(20−m,k) × 0.992C(20,k)/C(20−m,k) × 0.992
effective_edge0.80.8
Result: Same RNG, same formula and same edge at both stakes. The config lists no stake tiers above them.
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%.

3 columns
ItemValueContext
Phase A empirical RTP99.088%4,000 bets at $0.01, all 4 difficulties
Phase B empirical RTP101.978%1,000 bets at $0.01, EXPERT
Phase C empirical RTP96.282%200 bets at $10, MEDIUM
Phase D empirical RTP98.630%800 bets at $0.01, random difficulty, player-set seeds
Phase E empirical RTP108.650%450 multi-step bets at $0.01, cash-outs at k = 2, 3 and 5
5 columns
GroupBetsWinsExpectedp (exact binomial)
EASY (m=1), k = 11,2001,1321,1400.320
MEDIUM (m=3), k = 11,4001,1981,1900.579
HARD (m=5), k = 11,2009039000.872
EXPERT (m=10), k = 12,2001,1041,1000.881
E1: EASY to k = 51007675.00.923
E2: MEDIUM to k = 31006759.60.160
E3: HARD to k = 51503229.10.602
E4: EXPERT to k = 21002723.70.500
Win rates: Every group’s win count fits the binomial (Step 25, two-sided exact test; all above the Bonferroni bound 0.01 / 12). The per-difficulty chi-squared on the primary bets fails 0 / 4 at α = 0.01 (smallest p = 0.2893).
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                = 5

Step 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

3 columns
StepProcessOutput
1Backward Fisher-Yates: 19 HMAC drawsDeath-point set = {6} ✅
2Win check: is any stepped tile a death point?{0, 1, 2, 3, 4} ∩ {6} = ∅ → win
3Multiplier: C(20,5) / C(19,5) × 0.9921.322667×
4RTP check: survival × multiplierC(19,5)/C(20,5) × C(20,5)/C(19,5) × 0.992 = 0.992
5Payout: 0.01 × 1.3226670.0132267 ✅
RTP derivation for EASY (m = 1), k = 5 (worked) · Verified
// 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.992
Parity verified: Round 7843993: death-point set, win, multiplier and cash-out payout all match. The RTP of EASY at k = 5 is 99.200% by the same cancellation, independent of any casino data.
Live GameSET = {6}, win, payout = 0.0132267
VerifierSET = {6}, win, payout = 0.0132267
Technical Evidence & Verification5 sections
4.10Evidence Coverage Summary9 checks
3 columns
Verification AreaCoverageResult
Anti-circularity (Step 16)61 settings; exact 992/1000 by counting all 2^20 sets; negative control rejectedPass
RTP claim rule (Step 16)Flat 99.2% claim: 0 of 61 settings outside ±0.1 ppPass
House edge audit (Step 12)effective_edge 0.8 on 6,000 / 6,000 betsPass
Multiplier formula (Steps 8, 20)4,337 winning bets and 1,085 ladder rungsPass
Monotonicity and bounds (Step 24)57 / 57 depth and 42 / 42 difficulty pairs increase; no cap declaredPass
Simulation Pass 1 (Step 18)4M rounds, 0 / 4 chi-squared, 0 / 4 serialPass
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 $10Pass
Multi-step payouts (Steps 20, 22)1,085 rungs and 202 cash-outs at k = 2, 3 and 5Pass
4.11Code References8 source files
2 columns
FilePurpose
tests/steps/dataset.tsStep 16: anti-circularity, counting anchor and negative control
src/rtp-settings.tsThe RTP claim and the exact RTP of all 61 settings
src/rtp-claim.tsThe framework’s RTP claim rule, version 1.2.0
tests/steps/payouts.tsSteps 8, 10, 12: multiplier formula, bet-size invariance, house edge
tests/steps/simulation.tsSteps 18–19: simulation integrity and the cherry-pick test
tests/steps/monotonicity.tsStep 24: multiplier monotonicity and bounds
src/simulate.tsTwo-pass Monte Carlo simulation
src/rng.tssurvivalProbability and theoreticalMultiplier, exact binomials
4.12Datasets UsedSource artifacts
Simulation output: outputs/simulation-results.json — Pass 1 (4M rounds, 1M per difficulty) and Pass 2 (121 seeds × 10,000 nonces), pinned
RTP claim table: outputs/rtp-claim-table.json — exact RTP of all 61 settings against the flat 99.2% claim, pinned
Operator payout table: evidence/E07-cross-road-config-2026-10-05.json — 61 cells, every one equal to C(20,k)/C(20−m,k) × 0.992 (worst 3.0 × 10⁻¹⁹)
Primary dataset: data/beef-master-6000bets.json — house edge, Phase C stakes and empirical returns
Phase E dataset: data/beef-phaseE-450bets.json — multi-step multipliers and cash-outs
4.13Verified Invariants12 invariants
2 columns
InvariantResult
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 settingPass
The published flat 99.2% holds within ±0.1 pp on all 61 settingsPass
Flat 0.8% house edge: × 0.992 in the formula, effective_edge 0.8 on all 6,000 primary betsPass
Every served multiplier matches the formula; Duel’s config table matches on 61 / 61 cellsPass
Multipliers strictly increase with depth and with difficultyPass
Mean simulated RTP 99.1468% over 4M rounds, consistent with 99.2%Pass
0 / 4 position chi-squared failures at Bonferroni α/4 = 0.0025Pass
0 / 4 serial independence failures (lag-1 and runs test)Pass
No count of the cherry-pick test reaches its trigger across 121 casino seedsPass
$10 bets pay by the same formula as $0.01 betsPass
Multi-step cash-outs at k = 2, 3 and 5 pay the formula (202 / 202)Pass
4.14Reproduction InstructionsRun locally
reproduce-s4.sh · 6 lines · Verified
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 formula
Steps 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 pin
05

Fairness Integrity Testing

Does the implementation maintain fairness under non-standard conditions?

Sections 1–4 prove the game is mathematically fair. Section 5 proves the implementation maintains integrity under non-standard conditions. We applied 16 fairness integrity tests covering nonce integrity, seed commitment, outcome determinism, cross-player isolation, and payout integrity (including Beef-specific multi-step game-state checks). All 16 tests passed, including one Beef-specific multi-step state integrity test.

Fairness Integrity Testing

16pass

What we verified

  • Nonce tampering — can the sequence be forced, replayed, or skipped?
  • Seed injection — can server or client seed fields be overridden via API?
  • Outcome replay — can a completed bet be replayed for duplicate payouts?
  • Cross-player isolation — can one player's seeds or outcomes affect another's?
  • Payout tampering — can multiplier or payout values be injected client-side?
  • Parameter limits — can invalid 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
16pass
  • Nonce tampering — can the sequence be forced, replayed, or skipped?
  • Seed injection — can server or client seed fields be overridden via API?
  • Outcome replay — can a completed bet be replayed for duplicate payouts?
  • Cross-player isolation — can one player's seeds or outcomes affect another's?
  • Payout tampering — can multiplier or payout values be injected client-side?
  • Parameter limits — can invalid difficulty levels or grid sizes be submitted?
  • Beef-specific — can a round that has already been cashed out be stepped on again?
4 / 4Nonce Integrity
5 / 5Seed Commitment
2 / 2Outcome Determinism
2 / 2Player Isolation
3 / 3Payout Integrity

Category Coverage

Nonce Integrity4/4
Seed Commitment5/5
Outcome Determinism2/2
Player Isolation2/2
Payout Integrity3/3
CheckResultEvidence
Nonce integrityPassSequential, server-controlled, no duplicates across all 131 epochs (2 rounds our capture missed, reconstructed from the revealed seeds)
Seed commitment integrityPassLocked at bet acceptance, unique per epoch — 131/131 epochs verified
Outcome determinismPassIdentical inputs produce identical death-point sets — 6,450/6,450 confirmed including multi-step
Round & player isolationPassPer-user seeds, serial independence confirmed (0/4 fail in 4M-round simulation)
Payout integrityPassParameter limits enforced (4/4 invalid difficulty rejected); injected payout fields ignored (0 honoured); post-settlement step injection blocked
Nonce integrityPass
Sequential, server-controlled, no duplicates across all 131 epochs (2 rounds our capture missed, reconstructed from the revealed seeds)
Seed commitment integrityPass
Locked at bet acceptance, unique per epoch — 131/131 epochs verified
Outcome determinismPass
Identical inputs produce identical death-point sets — 6,450/6,450 confirmed including multi-step
Round & player isolationPass
Per-user seeds, serial independence confirmed (0/4 fail in 4M-round simulation)
Payout integrityPass
Parameter limits enforced (4/4 invalid difficulty rejected); injected payout fields ignored (0 honoured); post-settlement step injection blocked
✓  All Fairness Guarantees Verified

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.

3 columns
CategoryTestsWhat It Catches
Nonce Integrity4Sequence gaps, server-side nonce manipulation, session continuity
Seed Commitment5Mid-epoch seed changes, seed reuse, predictable seed generation
Outcome Determinism2Non-deterministic outputs, outcome replay, cash-out manipulation
Player Isolation2Cross-round correlation, cross-user outcome dependence
Payout Integrity3Parameter enforcement, server-side computation, duplicate-step idempotency
5.2Severity Framework & Hard Fail Criteria

Findings are classified by severity. Hard fail criteria — any one triggers a NOT PROVABLY FAIR verdict.

3 columns
SeverityMeaningAction
PASSTest passed — no issue detectedNone
N/ATest not applicable to this game typeNone
FLAGAnomaly detected, documented for transparencyDisclosed
HARD FAILFairness guarantee cannot be confirmedCertification blocked until remediated
2 columns
ConditionConsequence
Nonce gap or duplicate within epochOutcome sequence integrity broken
Server seed changed mid-epochCommit-reveal guarantee broken
Death-point recomputation mismatchUndisclosed inputs affecting placement
Client seed not used in HMACPlayer has no influence on outcomes
Death-point set changes during step sequencePer-step manipulation possible
Duplicate step advances payout multiplierMulti-step state corruption
Hard fail criteria: Any single hard fail = NOT PROVABLY FAIR. The audit cannot proceed past a hard fail without operator remediation and re-verification.

16 tests · 16 pass

Nonce Integrity4/4
FI-NONCE-003Pass

Submitting an invalid or out-of-sequence nonce does not produce a game outcome — the server rejects the request

API probe — 7 adversarial nonce values (−1, 0, 999999999, 'abc', INT32_MAX, INT32_MAX+1, 9e18) injected into beef-start requests. All 7 silently ignored; server assigned valid sequential nonces. Continuity preserved (baseline 9 → post-test 17); no stack traces leaked.

Seed Commitment5/5
FI-SEED-001Pass

Empty, null, or invalid client seeds are handled deterministically — the server enforces input requirements

API probe — 6/7 invalid client seeds rejected (empty, null, special chars, emoji, CJK, whitespace-only). Oversized seed (>1000 chars) accepted — permissive but safe (long entropy). All Beef bets after each rejection remained functional; no stack traces leaked.

FI-SEED-004Pass

No shared seed pool across users — each player's seeds are independently generated and isolated

API probe — 10 concurrent seed rotations on Account A and 10 on Account B. Zero hash collisions across 20 rotations; all hashes within each account distinct. Full account isolation confirmed.

FI-SEED-005Pass

Server seeds show no correlation with timestamps, sequential patterns, or other predictable inputs

API probe — 10 rotations spaced 5 seconds apart over ~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-002Pass

A 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

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

Player Isolation2/2
FI-ISO-002Pass

One player's seeds, nonces, and outcomes cannot be observed or influenced by another player — complete cross-user isolation

Follows from seed uniqueness (FI-SEED-003) — if each user has a unique server seed, outcomes are isolated by construction. Confirmed by FI-SEED-004 — zero hash collisions across 20 cross-account rotations.

Payout Integrity3/3
FI-PAYOUT-001Pass

Game parameters cannot exceed defined limits — only valid 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-002Pass

Multiplier and payout fields in the API request are ignored — the server computes all values from the combinatorial formula, not from client-supplied values

API probe — 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-001Pass

A 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
4 columns
Test IDCategoryVerification SourceStatus
FI-NONCE-001NonceS1, Step 4 (data-driven)Pass
FI-NONCE-002NonceS1, Step 4 (data-driven)Pass
FI-NONCE-003NonceAPI probePass
FI-NONCE-004NonceS1, Step 4 (data-driven)Pass
FI-SEED-001SeedAPI probePass
FI-SEED-002SeedS1, Steps 3 & 6 (data-driven)Pass
FI-SEED-003SeedS1, Step 1 (data-driven)Pass
FI-SEED-004SeedAPI probePass
FI-SEED-005SeedAPI probePass
FI-OUTCOME-001DeterminismS3, Steps 5 & 21 (data-driven)Pass
FI-OUTCOME-002DeterminismS3, Steps 21 & 22 (data-driven)Pass
FI-ISO-001IsolationS2, Step 18 (simulation)Pass
FI-ISO-002IsolationStructural — seed uniquenessPass
FI-PAYOUT-001PayoutAPI probePass
FI-PAYOUT-002PayoutAPI probePass
FI-BEEF-STATE-001PayoutAPI probePass
Method breakdown: 9 tests verified via verification suite steps and structural analysis, 7 tests verified via direct API probes against the running game. The Beef-specific game-state test (FI-BEEF-STATE-001) covers the multi-step step/cash-out surface and is grouped under Payout Integrity alongside the standard parameter-enforcement and field-injection tests. All 16 tests pass.
5.4Additional Integrity Evidence (S1–S4)8 records
3 columns
PropertySourceFinding
131/131 seed hashes verifiedS1, Step 1Commit-reveal chain intact
125/125 next-seed promotionsS1, Step 2Seed rotation chain intact
6,000/6,000 exact parity (primary) + 450/450 Phase ES3, Steps 5 & 21No post-RNG conditional logic, death-point set fixed at round start
Anti-circularity proven (algebraic)S4, Step 160.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 6Player entropy is genuine
202 cash-outs verified at k ∈ {2, 3, 5}S3, Step 22Multi-step payout integrity intact
1,085 step-multiplier pairs verified across 15 (difficulty, k) combosS3, Step 20Multi-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.

reproduce-s5-data.sh · 4 lines · Verified
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm cinpm test
Expected 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 18

API Probe Tests (completed):

fi-api-probes.sh
[PASS] FI-NONCE-003      — Invalid nonce handling      → 7/7 invalid nonces ignored (HTTP 200)[PASS] FI-SEED-001       — Invalid client seed handling → 6/7 rejected; oversized accepted[PASS] FI-SEED-004       — Cross-user seed pool check  → 0/20 collisions across 2 accounts[PASS] FI-SEED-005       — Seed timing analysis        → 10 distinct hashes, no time correlation[PASS] FI-PAYOUT-001     — Invalid 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)
API probes: All 7 API probe tests completed. Per-test evidence — requests, server responses, HTTP status codes, server-assigned nonces and seed hashes, multiplier values — is retained in our private adversarial-testing archive and summarised in the integrity test review document. The testing harness itself is kept private; per-test evidence is available to operators and regulators on request.
06

Player Verification

Can a player verify their own bets without trusting anyone?

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

Independent Result Verification

4 Stepsto verify any round

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)
4 Stepsto verify any round
  • 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
From Bet to Independent Verification — 4-step flow — illustrated flow
Server SeedRevealed after rotation
Client SeedPlayer-controlled input
NonceRecorded bet sequence
Difficulty LevelEASY, MEDIUM, HARD or EXPERT
  1. 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. 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. 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. 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
6.1Step 1: Play a Beef Round

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.

Duel.com Beef — the road with its difficulty selector and step multipliers. The death points are fixed before the first step.

6.2Step 2: Open the Provably Fair Panel

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.

Provably Fair modal — active client seed, hashed server seed, nonce, customisable new client seed, next pair pre-commitment, and Rotate seed action.

6.3Step 3: Open a Past Round to Find the Seed

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.

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

6.4Step 4: Recompute & Confirm

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.

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.

3 columns
#CheckCompare
1Reveal the server seedRotate your seed pair in the Beef Provably Fair panel
2Collect the fieldsserverSeed, seed.serverSeedHashed (the commitment shown before the round), seed.clientSeed, seed.nonce (from 0), request.difficulty_level and the served response.* fields
3Commitment encodingSHA-256(hex_decode(serverSeed)) equals seed.serverSeedHashed
4Recompute the shufflecomputeDeathPoints(serverSeed, clientSeed, nonce, m) (6.9)
5Death-point countm = 1 / 3 / 5 / 10 for difficulty 1 / 2 / 3 / 4; the set equals response.mines_positions
6Path and win ruleYou stood on tiles 0 … k−1 (response.current_step); a win has no death point among them
7SettlementWin: 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"
Losses: A loss is not settled by the cash-out equations. Its 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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledProvablyFair.org
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Trust modelRequires trusting the casinoNot controlled by the casino
Checked by this audit: Duel’s Verify-tab code (E06), run unmodified on all 6,450 captured rounds: its death points match. ProvablyFair.org’s verifier code, pinned by SHA-256, agrees on every round, with its multiplier within 1e-12 on every win (Step 5).
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:

verify-beef.js · Standalone Node.js · Tested
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]));
Tested: Run on the captured data, 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):

verify-beef.py · Standalone Python · Tested
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]))
Tested: Run on the captured data, 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
2 columns
EvidenceDescription
E02Provably 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
E03Duel.com fairness page: what provably fair means, seed generation and the hash commitment
E04Fairness verification page: game selector, client seed, server seed and nonce inputs, and the published verification code
E05Duel.com’s live JavaScript, annotated: the default client seed is generated in the browser with rejection-sampled crypto.getRandomValues
From Bet to Independent Verification — 4-step flow — illustrated flow
How it works
  1. 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. 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. 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. 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
6.1Step 1: Play a Beef Round

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.

Duel.com Beef — the road with its difficulty selector and step multipliers. The death points are fixed before the first step.

6.2Step 2: Open the Provably Fair Panel

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.

Provably Fair modal — active client seed, hashed server seed, nonce, customisable new client seed, next pair pre-commitment, and Rotate seed action.

6.3Step 3: Open a Past Round to Find the Seed

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.

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

6.4Step 4: Recompute & Confirm

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.

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.

3 columns
#CheckCompare
1Reveal the server seedRotate your seed pair in the Beef Provably Fair panel
2Collect the fieldsserverSeed, seed.serverSeedHashed (the commitment shown before the round), seed.clientSeed, seed.nonce (from 0), request.difficulty_level and the served response.* fields
3Commitment encodingSHA-256(hex_decode(serverSeed)) equals seed.serverSeedHashed
4Recompute the shufflecomputeDeathPoints(serverSeed, clientSeed, nonce, m) (6.9)
5Death-point countm = 1 / 3 / 5 / 10 for difficulty 1 / 2 / 3 / 4; the set equals response.mines_positions
6Path and win ruleYou stood on tiles 0 … k−1 (response.current_step); a win has no death point among them
7SettlementWin: 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"
Losses: A loss is not settled by the cash-out equations. Its 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.

3 columns
Duel.com VerifierProvablyFair.org Verifier
SourceCasino-controlledProvablyFair.org
Accessduel.com/provably-fair/verifyprovablyfair.org/verify-bets/duel
Trust modelRequires trusting the casinoNot controlled by the casino
Checked by this audit: Duel’s Verify-tab code (E06), run unmodified on all 6,450 captured rounds: its death points match. ProvablyFair.org’s verifier code, pinned by SHA-256, agrees on every round, with its multiplier within 1e-12 on every win (Step 5).
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:

verify-beef.js · Standalone Node.js · Tested
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]));
Tested: Run on the captured data, 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):

verify-beef.py · Standalone Python · Tested
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]))
Tested: Run on the captured data, 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
2 columns
EvidenceDescription
E02Provably 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
E03Duel.com fairness page: what provably fair means, seed generation and the hash commitment
E04Fairness verification page: game selector, client seed, server seed and nonce inputs, and the published verification code
E05Duel.com’s live JavaScript, annotated: the default client seed is generated in the browser with rejection-sampled crypto.getRandomValues
✓  Any Player Can Reproduce Beef Results

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.

07

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.

Open-Source Audit Repository

v1.2.1release audited

Repository Details

Prerequisites

  • Node.js 22.x (pinned in package.json and .nvmrc)
  • npm
  • Git
  • About 40 seconds for npm test on a 12-core laptop
v1.2.1release audited
github.com/ProvablyFair-org/duel-beefRelease v1.2.1 · original audit 05530ee

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.

sh
git clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm ci # Run the entire audit end to endnpm test

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
3 columns
FileContentsSize
verification-results.jsonSteps 1–25 with per-step details, profile mappings and the verdict59 KB
simulation-results.jsonPass 1 (4M rounds, pinned seeds) and Pass 2 (121 casino seeds × 10,000 nonces)58 KB
determinism-log.jsonSummary of the primary recomputation: 6,000 verified, 0 mismatches, 0 skipped<1 KB
chi-squared-results.jsonPer-difficulty live win counts and chi-squared p-values1 KB
rtp-claim-table.jsonExact RTP of all 61 settings against the published 99.2% (RTP claim rule)10 KB
rtp-convergence.htmlSelf-contained RTP convergence chart206 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
4 columns
StepTest NameReport SectionResult
1Seed Hash IntegrityS1Pass
2Next-Seed Promotion + Forward Commitment ChainS1Pass
3Hash Consistency Within EpochS1Pass
4Nonce AuditS1, S5Capture flag
5Outcome Recomputation (Death Points)S1, S2, S3Pass
6Client Seed InfluenceS1, S2Pass
7Payout MathS3, S4Pass
8Multiplier Formula (C(20,k)/C(20−m,k) × edge)S3, S4Pass
9Win Condition (all stepped tiles not in mines)S3Pass
10Phase C Bet-Size Invariance ($10 bets)S3, S4Pass
11Config Completeness & Payout-Table CoverageS3Pass
12House Edge Audit (effective_edge = 0.8%)S4Pass
13Population & Phase LabelsS3Pass
14Dataset HashS7Pass
15Epoch SizeS1Pass
16Probability Independence (Anti-Circularity)S4Pass
17Phase D — Client Seed VariationS1, S3Pass
18Simulation Results — Pass 1 IntegrityS2, S4Pass
19Simulation Results — Pass 2 Cherry-Pick TestS4Pass
20Multi-Step Multiplier Chain (Phase E)S3Pass
21Death-Point Recomputation (Phase E)S3, S5Pass
22Cash-Out Payout Correctness (k>1)S3, S5Pass
23Artifact Integrity (pinned artifacts of record)S7Pass
24Multiplier Monotonicity & BoundsS4Pass
25Live-Sample Fit (informational)S2, S4Pass
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.

3 columns
Profile checkCovered byCoverage
BEEF-01Step 1 (Seed Hash Integrity)Full
BEEF-02Step 2 (Next-Seed Promotion + Forward Commitment Chain)Full
BEEF-03Step 3 (Hash Consistency Within Epoch) + Step 4 (Nonce Audit)Full
BEEF-04Step 4 (Nonce Audit) · capture flag, verdict-neutralFull
BEEF-05Step 13 (Population & Phase Labels) + Step 15 (Epoch Size)Full
BEEF-06Step 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 CSPRNGPartial
BEEF-07Step 5 (Outcome Recomputation) + Step 21 (Death-Point Recomputation)Full
BEEF-08Step 5 (Outcome Recomputation)Full
BEEF-09Package 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 5Full
BEEF-10Step 9 (Win Condition)Full
BEEF-11Step 7 (Payout Math) + Step 22 (Cash-Out Payout Correctness)Full
BEEF-12Step 10 (Phase C Bet-Size Invariance)Full
BEEF-13Step 8 (Multiplier Formula) + Step 20 (Multi-Step Multiplier Chain)Full
BEEF-14Step 24 (Multiplier Monotonicity & Bounds)Full
BEEF-15Step 11 (Config Completeness & Payout-Table Coverage)Full
BEEF-16n/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-17Step 20 (Multi-Step Multiplier Chain) + Step 21 (Death-Point Recomputation) + Step 22 (Cash-Out Payout Correctness)Full
BEEF-18Step 16 (Probability Independence)Full
BEEF-19Step 12 (House Edge Audit) + Step 16 (Probability Independence) · RTP claim rule scored hereFull
BEEF-20Step 18 (Simulation Results — Pass 1 Integrity) · partial: the simulation p-values are read from the pinned artifact, not re-derived on every runPartial
BEEF-21Step 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 statedPartial
BEEF-22Step 25 (Live-Sample Fit)Full
BEEF-23Package check: the S5 matrix in MANIFEST.md, each row tied to the scored steps that decide itFull
BEEF-24Step 5 (Outcome Recomputation)Full
BEEF-25Package check: The seven-step “Verify a bet” guide in MANIFEST.md, linked from the READMEFull
BEEF-26Step 14 (Dataset Hash)Full
BEEF-27Step 23 (Artifact Integrity)Full
BEEF-28Package check: npm test and the reproduction gate: runs write to outputs/run/ and are compared with the committed resultsFull
BEEF-29Package check: The mutation battery: 45 counterexamples, each rejected by a named scored stepFull
BEEF-30Package check: The evidence register E01–E07, the declared limitations and the load-bearing premises in MANIFEST.mdFull
Source: The mapping is emitted by the package into outputs/verification-results.json (profileCoverage and each step’s profileChecks).
Release Historyv1.0.0 → v1.2.1
3 columns
ReleaseWhat changedVerdict
v1.0.0The original audit, June 2026Full Pass
v1.1.0Re-certification under Framework 1.1: the RTP claim rule, two new scored steps and a mutation battery; dataset unchangedUnchanged
v1.2.0RNG code rebuilt from a written spec; Duel’s Verify-tab code kept as a second checkUnchanged
v1.2.1A .gitattributes file keeps a Windows clone byte-identical; no audit content changedUnchanged
reproduce-audit.sh
reproduce-audit.sh
# Clone the releasegit clone https://github.com/ProvablyFair-org/duel-beef.gitcd duel-beefgit checkout v1.2.1npm ci # Run the audit (25 unit tests + 25 scored steps, Node 22.x)npm test # Optional: regenerate the simulation into outputs/run/ and diff itnpm run test:full # Check Duel’s config table and the release manifestnode scripts/check-config-table.mjsnode scripts/release-manifest.mjs --check
provablyfair.org/verify-bets/duel
This is an open-source audit. The datasets, the verification code and every scored result are public. You don’t have to take our word or the casino’s: check out the release, run the tests, and the run is compared with the committed results.
✓  Fully Reproducible

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.