Not yet certified. Pre-launch tests passed; final certification requires public launch and an independent recheck of live bets using anonymous, self-funded accounts.
Executive summary
LIQD.com · Independent pre-launch audit of 6 in-house gamesAll 6 games passed the full pre-launch test suite.
July–October 2026 audit
Issued October 23, 2026
ProvablyFair.org conducted an independent pre-launch audit of 6 provably fair games LIQD.com operates in-house, between July and October 2026. All 6 games passed the full pre-launch test suite. Certification has not yet been issued: it is gated on LIQD's public launch and an anonymous live-bet recapture, described below.
All 6 games passed the full pre-launch test suite
Path to Certification
Provisional · certification pending
The pre-launch audit is complete. Certification awaits public launch and an anonymous, self-funded bet recapture.
Complete Pre-launch audit
Full pre-launch test suite passed. Results and evidence are published.
Pending — operator Public launch
LIQD.com opens to the public. The audit work is ready.
After launch Recapture & certification
We fund anonymous accounts, recapture bets and re-run the checks.
Run these audits yourself
Every scored check ships as code. Each game includes its verifier, captured bets and simulation harness.
Browse all 6 repositories
npm testReproduction guide ↗How to runIndependent rebuild, real-bet verification
These conclusions are not assertions. Each game is independently rebuilt from a written specification, published in its audit repository — not from LIQD's source code. An executable test suite then runs every live result against that rebuild. A pass was required in every area, for every game — a failure in any single one would have blocked this provisional verdict, and certification holds the anonymous recapture to the same bar. Each game is verified across five areas:
Five areas. Every game must pass.
Seed, Nonce & DeterminismThe commit-reveal chain is checked end to end — every outcome is cryptographically sealed before the bet, recomputes exactly from its revealed seed, and sits in a nonce sequence that can't be altered or replayed.
RNG & Entropy ModelThe randomness is independently reimplemented and confirmed to derive from an input the operator can't control, then tested statistically for genuine randomness.
Verifier ParityEvery captured bet is recomputed against the rebuild and must match the live result exactly, down to intermediate states.
RTP & Payout LogicThe RTP is derived from first principles — never from the operator's RTP figure — confirmed by large-scale two-pass simulation, and tested for cherry-picked seeds.
Each game's running service is tested with malformed, duplicate, concurrent and edge-case requests to confirm it holds up under non-standard conditions.
One divergent check fails the run
Coverage scales with the game, from 21 scored steps to 31, and the suite fails the run if a single check diverges. The suite, datasets, and verification code are published open-source, re-runnable and inspectable by anyone.
How the audit follows a live outcome
ProvablyFair.org captures LIQD's live outcomes and re-derives every one independently.
Provable fairness requires that any third party can take an operator's published inputs and arrive at the same outcome the player saw. This audit tests exactly that — independently, for every game and every captured bet.
Scope of certification
What the certification covers, and where its boundaries sit.
This certification covers the cryptographic and statistical correctness of game outcomes in LIQD's in-house provably fair games. It does not extend to other aspects of the platform. Both boundaries are stated below.
Games covered: 6 games, all built and operated in-house by LIQD — Blackjack, Mines, Plinko, Dice, Limbo, and Keno. Third-party or licensed titles available on LIQD.com are not LIQD's own implementations and are outside the scope of this audit.
Covered
Covered- Provably fair RNG logic and entropy architecture
- Deterministic reproducibility of every audited bet
- RTP mathematical correctness from first principles
- Commit-reveal chain integrity across seed rotations
- Round, player, and seed-session isolation
- Payout integrity within the audited game logic
Not covered
Not covered
Not covered- Operator solvency, treasury, or wallet custody
- Regulatory licensing in any jurisdiction
- Infrastructure or server-side security posture
- Cross-account outcome consistency
- Max-win cap enforcement at payout time — platform-level, not game logic
- KYC, AML, responsible gambling controls
- Rakeback and promotional programs — operator-side, outside the audited game logic
What this means
What this meansThis certification concerns whether LIQD's in-house games produce the outcomes they are specified to produce — whether the randomness is genuine, the odds match the stated figures, and a result cannot be altered after a bet is placed. It is not an assessment of the casino's finances, licensing, or security infrastructure. Those are separate matters this audit does not measure.
What was tested, and how
Each audit answers five questions, applied independently to every game in scope.
01Can the casino change your outcome after you bet?
We verify that each result is sealed before you play, fully determined by the inputs, and locked into a sequence the casino can't alter or replay.
02Is the randomness genuinely random, or could it be rigged?
We re-implement the exact randomness algorithm and prove the outputs are unbiased and driven only by the disclosed inputs — nothing hidden, and nothing the operator can steer.
03Does the live game actually follow its own rules?
We rebuild the game and recompute every captured bet — outcome, payout, and intermediate steps, not just win or loss. All 39,400 must match; one fails the game.
04Is the house edge what the casino claims?
We prove the RTP from first principles — never the casino's own RTP figure — then confirm it across millions of simulated rounds and test whether favourable seeds were cherry-picked.
05Does the implementation maintain fairness under non-standard conditions?
We run a fixed suite of integrity tests against each game's running service — nonce and seed handling, replay and isolation, payout enforcement — to confirm fairness holds under pressure.
An independent implementation
We rebuilt each game from a written specification in an independent implementation. Re-running an operator's own code only establishes that the operator is internally consistent; rebuilding from an independent specification tests whether the running game matches what is publicly stated. Bets were script-captured on LIQD's pre-launch (whitelist) environment — the anonymous-account capture that certification requires happens after public launch (see Path to Certification). Every game's audit was independently reviewed before finalisation, and every dataset, result, and line of verification code is published open-source. The complete framework, including per-section pass criteria, is documented on the methodology page.
Entropy architecture
LIQD's 6 games share one cryptographic architecture: a server seed sealed by hash before play, paired with a player-supplied client seed — the appropriate construction wherever one player faces the house, since the player contributes an input the operator cannot predict. The server publishes SHA-256 of the server-seed text (SHA-256(utf8(serverSeed hex string))), and the hash of the next epoch's seed, before the client seed is known; outcomes derive from HMAC-SHA256(serverSeed, clientSeed:nonce:cursor) with unbiased draws: rejection sampling where the range needs it, while Plinko's one-bit draw is exact without it.
The games differ only in how much of that randomness they consume and how they map it: Blackjack shuffles the full 416-card shoe with a backward Fisher–Yates, one uniform draw per swap (415 draws, cursor 415 → 1); Mines runs a forward Fisher–Yates over its 25 tiles, one uniform draw per position, and takes the first mineCount in draw order; Plinko takes a single bit per peg row (cursor = row + 1, first uint32 mod 2); Dice takes one uint32 from a single digest (cursor = 0, the first chunk below the rejection ceiling, mod 10,000) for a 0.00–99.99 roll; Limbo takes one uint32 the same way (the first chunk below the rejection ceiling, mod 100,000,000) and maps it to a two-decimal result of at least 1×; Keno runs a ten-step Fisher–Yates over 1–40 for its ten numbers (WTF mode draws its lightning number first). One construction, six consumption patterns — each independently rebuilt and verified in its own audit.
Server Seed + Client Seed
Blackjack · Mines · Plinko · Dice · Limbo · Keno
HMAC-SHA256Construction and evidence
Construction. Server commits SHA-256 of the server-seed text — and the next epoch's hash — before the client seed is supplied. Outcome = HMAC-SHA256(serverSeed, clientSeed:nonce:cursor), drawn without bias (rejection sampling where the range needs it; Plinko's one-bit draw is exact without it).
Verified. 39,400 live bets reproduced · 778 commit-reveal epochs with all 772 next-seed links intact · client seed player-controlled and customisable — the rotation call submits the player's seed after the server's commitment is published.
The architecture was rebuilt once per game and verified against that game's own captured bets. The audit confirmed the client seed is genuinely consumed — every bet reproduces under its recorded seeds and diverges under a tampered one: a wrong client seed changed 99.9% of Mines layouts, 99.8% of Plinko paths, and 97.4% of Blackjack first cards, each consistent with the chance-collision rate for that outcome space (a first card collides 1 time in 52 by chance alone), and changed the roll in every one of Dice's 8 sensitivity checks while all 500 custom-client-seed Dice bets reproduced; it also changed the draw on all 6,700 Limbo rounds and the drawn numbers on all 2,400 Keno rounds tested, while all 500 custom-client-seed Limbo rounds reproduced. Every revealed seed was checked against both its own commitment and the previous epoch's next-seed pledge — 778 epochs, 772 chain links plus each game's pre-capture link, zero breaks.
Results
Exact live-bet reproduction, independently derived RTP and large-scale simulation.
What exact reproduction establishes
Every live bet matched
Across all 6 games, the independent implementation reproduced every one of the 39,400 captured bets exactly, with no conditional divergence, rounding drift, or fallback path. Parity was checked at the natural granularity of each game, not only the final win or loss: 34,734 Blackjack cards in strict shoe order across 6,000 hands, 92,010 mine positions in draw order across 6,900 Mines boards, 131,970 Plinko path bits across 10,100 drops, all 6,700 Dice rolls and all 6,700 Limbo results on their 0.01 grids, and 30,000 Keno numbers in served order across 3,000 rounds, with all 600 WTF lightning numbers. Because every captured bet recomputes exactly from its disclosed inputs, the reconstruction surfaced no hidden entropy inputs, fallback paths, or conditional RNG branches in the audited implementations; in every construction the random value is committed before the player's input is known. The capture environment was pre-launch (whitelist); the same parity bar applies to the anonymous recapture at certification.
RTP validation
Derived independently, then simulated
RTP was established independently for each game — by closed-form derivation or an exact expected-value solver, depending on the game — and corroborated by Monte Carlo totalling 228M rounds across the suite. Anti-circularity was enforced: every derivation and simulation operates from the game's rules and paytables, not from operator-supplied RTP figures or simulation output.
Game rules & paytablesExact finite-shoe EV solver over the real 416-card, 8-deck shoe under LIQD's rules (S17, 3:2, DAS, peek), solved for no re-split, no surrender and insurance declined, anchored by an exact-rational oracle and cross-validated against Wizard of Odds for this exact rule set.
Combinatorial identity win chance × exact multiplier = 0.99 at all 300 (mine count, reveals) settings, verified algebraically against the payout formula.
Binomial B(rows, 0.5) against the hash-pinned payout tables across all 28 configurations (27 standard + WTF), verified per configuration.
Grid identity win chance × multiplier = (b / 10,000) × (9900 / b) = 0.99 for every half-open band, proven by cancellation and anchored by a literal 10,000-point tally on all 5,304 captured bands; the integer form 100 · winCount · 9900 = 99 · 10,000 · b is asserted with no tolerance on every one of the 6,700 bets.
Win-chance identity — a target m wins on ⌊9,900,000,000 ÷ 100m⌋ of the 100,000,000 equally likely draws — evaluated exactly at every target from 1.01× to 10,000× (999,900 targets), returning 98.990018%–99.000000%, and anchored by literal 100,000,000-draw tallies at four targets.
Hypergeometric hit probabilities C(n,k) · C(40−n,10−k) / C(40,10), computed independently and applied to LIQD's declared paytable across all 50 settings (five risk levels including WTF, one to ten picks); every setting returns 98.9031%–99.0689%, within 0.1 percentage points of the advertised 99%.
Every game converged within tolerance
Empirical RTP converged on the independently derived theoretical value within statistical tolerance for every game. The per-game breakdown — RNG model, live bet count, simulation volume, simulated RTP (committed run), and proven RTP — is presented in the Dashboard game validation matrix.
What this means
We recreated each game ourselves and checked it against real bets placed on LIQD's pre-launch environment. Every result matched — so the running game isn't doing anything different from what we audited. After launch, the same check is repeated on the public site through anonymous accounts before certification is issued.
Findings
A fixed matrix of integrity tests against LIQD’s running service, with each game’s findings and their remediation.
Section 5 of each game report sets out its integrity tests against LIQD's running service — 201 are reported across the 6 games, from a fixed matrix of replayed and duplicate requests, outcome and parameter injection, parallel-request races, malformed payloads, and seed and nonce tampering, with game-specific extensions for surfaces such as Blackjack's per-round action handler, Mines' multi-step reveal and cash-out state, Dice's band boundaries and win-region fields, Limbo's target limits, and Keno's pick selections and paytable return. Each test is published with the control it assessed, the broad testing approach, the observed result, its impact and any limitations.
The checks group into five integrity categories
- Nonce integrity — monotonic, server-controlled, no gaps or duplicates.
- Seed commitment lifecycle — commit-reveal chain intact across rotations; revealed seeds match commitments.
- Outcome determinism & replay resistance — identical inputs → identical outcomes; bets cannot be replayed for duplicate payout.
- Round & player isolation — no cross-player or cross-round state leakage.
- Payout & parameter enforcement — payouts match published table; server cannot silently override bet parameters.
Ten findings came from fifteen tests. A critical concurrency defect in Blackjack: LIQD's per-round action handler let parallel doubles or splits attach extra stakes to a single hand (two tests, graded Critical and High). LIQD made per-round placement atomic, and ProvablyFair.org re-verified the fix. The defect never changed the shuffle or the order cards are dealt in.
Retries and delayed actions in Blackjack: a retried in-round action could apply twice, adding a card or repeating a bet, and an action delayed past the end of a round could change the next one (three tests, graded Medium). LIQD added round and idempotency keys and now refuses stale and round-less requests; the re-tests of 23 October 2026 found no retried action applied twice and every delayed request refused.
A Medium payout-precision deviation in Mines: the original build credited the multiplier floored to two decimals, delivering 98.78% average single-reveal RTP against the advertised 99%. ProvablyFair.org derived the gap during RTP verification and LIQD moved to full-precision crediting; every win in the audited capture is credited at the exact multiplier. It is the one finding whose complete working is published rather than withheld (Mines S4.3).
A Medium paytable-return finding in Keno: the paytable in place at testing missed the displayed 1.00% edge by more than 0.1 percentage points on 10 settings. LIQD corrected it, and ProvablyFair.org re-verified the corrected table: all 50 settings now return within 0.1 percentage points of 99%.
Low-severity input, recovery and overload items: wrong-type or sub-precision values were converted at the boundary instead of refused in Blackjack, Mines and Plinko — every range held — and Blackjack defaulted malformed currency identifiers; aggressive client disconnects drew server errors from Mines' recovery path, with no orphaned debit, and recovery was clean on a broader re-test; and in Dice, extreme bursts drew generic server errors instead of structured overload responses. Each is remediated, and ProvablyFair.org re-verified every one.
All ten were fixed by LIQD and re-verified by ProvablyFair.org before this report. That is the advantage of auditing pre-launch: each fix was made and re-verified before any player was exposed, and Mines pays the exact advertised 99%. In each of these ten findings the cryptographic core and the RNG operated correctly — seed values, commitments and the shuffle or draw were never altered. Integrity-test procedures are withheld by policy; each game's Section 5 publishes, for each test it lists, the control assessed, the broad testing approach, the observed result, its impact and any limitations.
CriticalConcurrent doubles and splitsFixed
Parallel doubles or splits could attach extra stakes to one hand. LIQD made per-round placement atomic; fixed and re-verified.
MediumDelayed actions across roundsFixed
An action delayed past the end of a round could change the next one. Stale and round-less requests are now refused; fixed and re-verified.
MediumRetried in-round actionsFixed
A retried in-round action could apply twice, adding a card or repeating a bet. LIQD added round and idempotency keys; fixed and re-verified.
LowStake and currency validationFixed
Grey-area stakes and malformed currency identifiers were accepted or defaulted instead of refused. Fixed by LIQD and re-verified.
MediumPayout precisionFixed
The original build credited wins with the multiplier floored to two decimals, returning 98.78% against the advertised 99%. LIQD moved to full precision; fixed and re-verified.
LowMine-count and stake validationFixed
Wrong-type mine-count and stake values were converted instead of refused, inside the valid ranges. Fixed by LIQD and re-verified.
LowDisconnect recoveryFixed
Some aggressive client disconnects drew a server error from the recovery path, with no orphaned debit. Remediated: recovery was clean on a broader re-test.
LowRow, risk and stake validationFixed
Wrong-type and sub-precision values were converted into valid bets instead of refused, inside the valid ranges. Fixed by LIQD and re-verified.
LowOverload handlingFixed
Extreme bursts drew some generic server errors instead of structured overload responses. Fixed by LIQD and re-verified.
MediumPaytable returnFixed
The paytable in place at testing missed the displayed 1.00% edge by more than 0.1 percentage points on 10 settings. LIQD corrected it; all 50 settings are now within 0.1 percentage points of 99%.
What this means
The audit reports ten issues. The serious ones were in Blackjack's bet handling — parallel requests could stack extra stakes on one hand, and a retried or delayed action could apply twice or reach the next round — in Mines, where the original build paid about 0.2% less than advertised, and in Keno, where ten settings returned more than 0.1 percentage points below the advertised 99%. None touched the games' randomness. Because this audit ran before launch, LIQD fixed all ten and we re-verified each fix; Mines pays the exact advertised 99%, and every Keno setting is now within 0.1 percentage points of 99%.
What this audit establishes for players
For the 6 in-house games covered, this audit establishes what a player can rely on.
- A game's outcome is cryptographically locked before a bet is placed and cannot be altered afterward.
- The randomness comes from an input the operator can't control, so the outcome is not generated from the operator's input alone.
- The house edge a player is shown is checked against our own derivation from the game's rules, not an estimate supplied by the operator: no setting returns more than 0.1 percentage points less than the published figure.
- Every captured outcome was reproduced, bet for bet, by an independent implementation — every audited result is provably identical to the live game that produced it.
- Any single result can be recomputed by anyone from its public inputs. A player does not have to trust the operator, this audit, or ProvablyFair.org — only the math.
Across the 6 games, the audit ran a scored verification suite per game and reports 201 integrity tests — 39,400 live bets reproduced, and 228 million simulated rounds.
Fairness and the chance of winning
The audit confirms these games are provably fair and operate as specified. It does not change what they are: a provably fair game is one that behaves exactly as its published rules state — not one a player is assured of winning. This audit verifies the games are what they claim to be; it does not eliminate variance, and it does not guarantee a profitable session.
Independence and reproduction
An independently reviewed audit that anyone can inspect and re-run.
This audit was conducted independently. Findings are binding and were not negotiated with the operator; the audit outcome does not depend on the result. One dependency is disclosed: the current bet datasets were captured on the operator's pre-launch environment through operator-provisioned accounts — which is exactly why certification waits for an anonymous, self-funded recapture on the public site. The complete framework and every per-game audit are published open-source, so the audit can be examined and re-run by any third party rather than taken on assertion.
Conditions of the result
The result covers the audited implementation as deployed during the review period, on two conditions:
Code-to-deployment parity. The launched production build must match the audited, remediated implementation. Each per-game repository pins the exact commit the audit was performed against, and the anonymous recapture after launch re-runs every dataset check on live bets.
Operator-published parameters. The audit covers the payout tables and rule sets LIQD published; a change to either requires re-audit.
This provisional report reflects the 6 in-house games as audited at the commit hashes recorded in each per-game repository, against datasets captured on the pre-launch (whitelist) environment. Certification is issued after LIQD's public launch, once ProvablyFair.org recaptures the live-bet datasets through anonymous, self-funded accounts and every dataset-gated check passes. Material changes to a game's RNG construction, payout tables, or logic before launch require re-audit; pinned commit hashes make any such change verifiable against the audited baseline.
Each game has its own audit page carrying the complete methodology, datasets, simulation logs, and verifier code for that game. See the sidebar for individual reports, or the Dashboard for the cross-game validation matrix.
Inspect the evidence. Run the audit yourself.
Independent implementations, pinned commits, datasets and simulation artifacts.
