export function

getProvablyFairHmacSalt(clientSeed: string,

nonce: number, cursor: number): string {

return `${clientSeed}:${nonce}:${cursor}`;

}

​

export function generateProvablyFairNumber(

serverSeed: string, clientSeed: string, nonce:

number, cursor: number, range: number,

): number {

const key = Buffer.from(serverSeed, 'hex');

const digest = createHmac('sha256',

key).update(getProvablyFairHmacSalt(clientSeed,

nonce, cursor)).digest();

const maxFair = Math.floor(0x1_0000_0000 /

range) * range;

for (let offset = 0; offset + 4 <=

digest.length; offset += 4) {

const chunk = digest.readUInt32BE(offset);

if (chunk < maxFair) return chunk % range;

}

return generateProvablyFairNumber(serverSeed,

clientSeed, nonce, cursor + 1_000_000,

range);

}

import type { StepResult } from './context';

import { step } from './context';

import type { VerifyContext } from './context';

import { EXPECTED_BETS } from '../../src/pins';

import { revealMines, sameMines } from

'../../src/rng';

​

export function run(ctx: VerifyContext):

StepResult[] {

const { bets, seedMap } = ctx;

​

let mismatches = 0, skipped = 0;

for (const b of bets) {

const ss = seedMap.get(b.hashedServerSeed);

if (!ss) { skipped++; continue; }

const mines = revealMines(ss, b.clientSeed,

b.nonce, b.mineCount);

if (!sameMines(mines, b.mineTiles))

mismatches++;

}

​

const s5PopulationOk = bets.length ===

EXPECTED_BETS;

function floor8CreditUnits(betAmount: number,

mineCount: number, k: number): bigint | null {

if (k < 1 || k > GRID - mineCount) return null;

const stakeUnits = BigInt(Math.round(betAmount

* 1e8));

let num = EDGE_NUM, den = EDGE_DEN;

for (let i = 0; i < k; i++) { num *=

BigInt(GRID - i); den *= BigInt(GRID -

mineCount - i); }

return (stakeUnits * num) / den;

}

​

if (Number.isFinite(winAmt) &&

Number.isFinite(bet)) {

const credUnits = floor8CreditUnits(bet,

b.mineCount, b.openTiles.length);

if (credUnits === null ||

BigInt(Math.round(winAmt * 1e8)) !==

credUnits) floor8Violations++;

}

const FIXED_TILE = 1;

​

let wins = 0;

for (let nonce = 0; nonce < ROUNDS_PER_CONFIG; nonce++) {

const mines = revealMines(

serverSeed, clientSeed, nonce, mineCount);

​

let fixedIsMine = false;

for (const t of mines) if (t === FIXED_TILE) {

fixedIsMine = true; break;

}

if (!fixedIsMine) wins++;

​

// Simulated k=1 RTP (informational aggregate).

const winRate = wins / ROUNDS_PER_CONFIG;

const theoRTP = theoreticalRTP(mineCount, 1);

const multiplier1 = theoRTP /

((GRID - mineCount) / GRID);

const simRTP = winRate * multiplier1;

​

const meanSimRTP = pass1Results.reduce(

(s, r) => s + r.simRTP, 0) / pass1Results.length;