Fairness
Verify the RTP
181 outcomes and one formula: the RTP can be checked exhaustively, by arithmetic, by enumeration and on the live system.
Nothing here has to be taken on trust. The game has 181 outcomes and one formula, so it can be checked exhaustively rather than statistically.
#Method 1: by arithmetic (minutes)
For any market: RTP = (count / 181) x multiplier. Worked examples at the 96 variant:
| Market | count | Multiplier | RTP = count / 181 x multiplier |
|---|---|---|---|
| OVER 5.50 | 91 | 1.9095 | 96.002% |
| UNDER 3.40 | 49 | 3.5461 | 95.999% |
| BAND 7's | 20 | 8.6880 | 96.000% |
| EXACT 9.45 | 1 | 173.7600 | 96.000% |
The only deviations from the nominal RTP are the 4-decimal rounding of line multipliers, less than 0.005 percentage points either way, and the floor-to-minor-unit rounding of cash wins described in Markets and prices.
#Method 2: by enumeration
The reference program below is short. It lists every market of every variant, recomputes the multiplier from the formula, and sums the return over all 181 outcomes. Your reviewers can run it, or re-implement it in any language in under an hour, and compare the output with the PAR sheet and with the pay table shown in the game's rules page.
#Method 3: on the live system
Pay table shown to players. The rules page inside the game displays the multipliers for the variant configured for your wallet. They must match the PAR sheet for that variant.
Per round. The round replay shows the drawn score and the market. The multiplier for that market is in the PAR sheet; multiplier x stake, floored, must equal the deposit your wallet received.
In aggregate. Total stakes and total wins for the game are in your own wallet ledger. Observed RTP converges on the configured variant; Risk and exposure gives the expected spread so a short-term deviation is not misread.
Simulation. The game module implements the platform's simulation interface, with a strategy for each market type. A simulation run on the platform for your configured variant: Confirmed at staging.
#What our automated test suite proves on every build
The build does not start unless all 127 tests in the delivered repository pass. They include:
Exhaustive sweep: all 181 outcomes x every market x every variant through the real settlement code. That is 273,672 settled rounds, none sampled.
Payout parity against an exact integer reference: more than one million stake x multiplier combinations at 2 decimals, and every multiplier of every variant at every currency precision from 0 to 8. Payout uses integer arithmetic; there is no floating-point rounding of money.
Exactly one RNG draw per round, asserted for every market of every variant.
The inclusive-sides rule at every line of every variant: the line's own score wins the side called, the far neighbour loses.
The client's displayed prices and the server's settlement prices come from the same source file and cannot diverge.
The PAR sheet is generated from the code; a build stops if the published sheet and the code differ by a single byte.
Every chip value, the minimum and the default the client offers is a stake the server accepts, at every currency precision from 0 to 6 decimals. Half, double, MAX, the typed amount and AUTO's stake changes are clamped by the client to the same limits, and the server refuses any stake outside them, off the currency's minor-unit grid, or paying above the exposure cap.
The rounding floors in Markets and prices hold for every stake in each range, on every market of every variant.
The platform adapter is tested against a simulation of the platform's documented client interface: bet limits, win capping, refused bets, lost replies (including free bets), unfinished rounds and replay launches.
A build for real-money play is rejected automatically if any shipped file holds a score next to a clip name, if it contains the demo wallet, or if a clip has a sequential name. The same check runs inside the bundler itself, so no build command can skip it.
#Checked by hand before each release
The complete client is also run end to end against the same simulation, with the real server game module behind it, to exercise what unit tests cannot: an ended session, a free-bet stake lock, a pause by the host, a restricted feature profile, a zero-decimal currency, a replay launch and each lost-reply outcome. This simulation is built from the platform's documentation. The same scenarios on the live platform: Confirmed at staging.
#Reference program
Self-contained JavaScript (Node 18+ or any browser console). It reproduces every multiplier in the PAR sheet and proves the RTP of every market by enumeration. It restates the published rules; the production source is separate.
const N = 181, MIN = 1.00, STEP = 0.05;
const score = i => +(MIN + i * STEP).toFixed(2); // i = 0..180
const mult = (rtp, count) => Math.round(rtp * N / count * 1e4) / 1e4;
// markets: each returns the number of winning outcomes ("count")
const under = L => Array.from({length: N}, (_, i) => score(i)).filter(s => s <= L).length; // inclusive: the line's own score wins UNDER
const over = L => Array.from({length: N}, (_, i) => score(i)).filter(s => s >= L).length; // inclusive: the line's own score wins OVER
const band = () => 20; // bands 1's to 9's, 20 scores each; 10.00 is an EXACT pick
const exact = () => 1;
for (const rtp of [0.96, 0.94, 0.92]) {
// a line is offered only if BOTH sides pay at least 1.01X
const lines = Array.from({length: N}, (_, i) => score(i))
.filter(L => under(L) > 0 && over(L) > 0 && mult(rtp, under(L)) >= 1.01 && mult(rtp, over(L)) >= 1.01);
console.log(`RTP ${rtp}: lines ${lines[0].toFixed(2)} to ${lines.at(-1).toFixed(2)} (${lines.length})`,
`EXACT ${mult(rtp, 1)}X BAND ${mult(rtp, 20)}X`);
let lo = 1, hi = 0;
for (const L of lines) for (const c of [under(L), over(L)]) {
const r = c / N * mult(rtp, c); lo = Math.min(lo, r); hi = Math.max(hi, r);
}
console.log(` line RTP range ${(lo * 100).toFixed(3)}% to ${(hi * 100).toFixed(3)}%`);
}
// cash win: floor to the currency's minor unit, integer arithmetic only
const payout = (stakeMinor, m) => Number(BigInt(stakeMinor) * BigInt(Math.round(m * 1e4)) / 10000n);
console.log(payout(1000, 1.9095)); // stake 10.00 on OVER 5.50 at 96 -> 1909 (19.09)Expected output:
RTP 0.96: lines 1.45 to 9.55 (163) EXACT 173.76X BAND 8.688X
line RTP range 95.996% to 96.004%
RTP 0.94: lines 1.65 to 9.35 (155) EXACT 170.14X BAND 8.507X
line RTP range 93.996% to 94.004%
RTP 0.92: lines 1.85 to 9.15 (147) EXACT 166.52X BAND 8.326X
line RTP range 91.996% to 92.004%
1909From the FACECARD Game Specification 2.8 (25 October 2026) and the PAR sheet generated from the game's pricing source.