Testing Your Integration

import assert from 'node:assert/strict';
import { createHmac } from 'node:crypto';
import { commit, deriveDigest, play, toHex } from '@galabet/fair';

const seeds = {
  serverSeed: '5c1f7d3e8a2b4c6d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d',
  clientSeed: 'galabet',
  nonce: 42,
};

assert.equal((await play({ game: 'dice', ...seeds })).result, 56.12);
assert.equal((await play({ game: 'roulette', ...seeds })).result, 20);
assert.equal((await play({ game: 'limbo', params: { houseEdge: 0.01 }, ...seeds })).result, 1.76);
assert.equal((await commit(seeds.serverSeed)).commitment, 'ab37723062965715c5e6eeb54816f909a8e787bd3bfaee67a3cc0a3b90707de7');

// An oracle that shares no code with what it checks.
const expected = createHmac('sha256', seeds.serverSeed).update('galabet:42:0').digest('hex');
assert.equal(toHex(await deriveDigest(seeds, 0)), expected);

console.log('5 assertions held');

import { readFile } from 'node:fs/promises';
import { isDeepStrictEqual } from 'node:util';
import { play } from '@galabet/fair';

// Replace with the function your server calls to turn a bet into an outcome.
const deriveOutcome = ({ game, params, serverSeed, clientSeed, nonce }) => play({ game, params, serverSeed, clientSeed, nonce });

const { games } = JSON.parse(await readFile('vectors/gfs-1.0.json', 'utf8'));
const failed = [];
const perGame = {};

for (const vector of games) {
  const { result, cursor } = await deriveOutcome(vector);
  const ok = isDeepStrictEqual(result, vector.result) && cursor === vector.cursor;
  perGame[vector.game] = (perGame[vector.game] ?? 0) + 1;
  if (!ok) failed.push(vector);
}

for (const vector of failed.slice(0, 5)) console.error(`mismatch: ${vector.game} ${vector.clientSeed} nonce ${vector.nonce}`);
console.log(Object.entries(perGame).map(([game, count]) => `${game} ${count}`).join(', '));
console.log(`${games.length - failed.length} of ${games.length} vectors match`);
if (failed.length > 0) process.exitCode = 1;

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import { play } from '@galabet/fair';

const { games } = JSON.parse(await readFile('vectors/gfs-1.0.json', 'utf8'));

test(`all ${games.length} GFS 1.0 vectors`, async () => {
  for (const vector of games) {
    const { result, cursor } = await play(vector);
    assert.deepEqual({ result, cursor }, { result: vector.result, cursor: vector.cursor }, `${vector.game} nonce ${vector.nonce}`);
  }
});

import assert from 'node:assert/strict';
import { commit, createServerSeed, play, verifyCommitment, verifyRecord } from '@galabet/fair';

// A stand-in for your service. In your suite, import the real one and hand it an in-memory store.
function createService() {
  let session;
  const records = [], revealed = {};
  const fresh = async () => {
    const serverSeed = await createServerSeed();
    return { serverSeed, commitment: (await commit(serverSeed)).commitment, nonce: 0 };
  };
  return {
    async open(clientSeed) {
      session = { clientSeed, ...(await fresh()) };
      return { commitment: session.commitment };
    },
    async bet(game, params = {}) {
      const { serverSeed, commitment, clientSeed } = session;
      const nonce = session.nonce++;
      const { result, cursor } = await play({ game, params, serverSeed, clientSeed, nonce });
      const record = { spec: 'GFS/1.0', profile: 'single-player', game, params, commitment, clientSeed, nonce, cursor, result, at: Date.now() };
      records.push(record);
      return record;
    },
    async rotate() {
      const retired = { serverSeed: session.serverSeed, commitment: session.commitment };
      revealed[retired.commitment] = retired.serverSeed;
      Object.assign(session, await fresh());
      return retired;
    },
    history: () => records.map((r) => (revealed[r.commitment] ? { ...r, serverSeed: revealed[r.commitment] } : r)),
  };
}

const service = createService();
const shown = await service.open('galabet');
for (const game of ['dice', 'roulette', 'mines']) await service.bet(game, game === 'mines' ? { mines: 5 } : {});

// Before rotation: no seed anywhere, and verification says why it can't run.
const early = await Promise.all(service.history().map((r) => verifyRecord(r)));
assert.ok(service.history().every((r) => !('serverSeed' in r) && r.commitment === shown.commitment));
console.log('before rotation:', early.map((v) => v.ok).join(' '), '|', early[0].reasons[0]);

// After rotation: every record verifies, and the seed fits the commitment shown before the first bet.
const retired = await service.rotate();
assert.equal(await verifyCommitment(retired.serverSeed, shown.commitment), true);
const late = await Promise.all(service.history().map((r) => verifyRecord(r)));
assert.ok(late.every((v) => v.ok));
console.log('after rotation:', late.map((v) => v.ok).join(' '));

// Negative controls. A suite that never sees a failure hasn't shown it can.
const [first] = service.history();
const tampered = await verifyRecord({ ...first, result: first.result === 1 ? 2 : 1 });
const wrongSeed = await verifyRecord({ ...first, serverSeed: await createServerSeed() });
assert.equal(tampered.ok, false);
assert.equal(wrongSeed.ok, false);
console.log('tampered result:', tampered.ok, tampered.reasons);
console.log('someone else\'s seed:', wrongSeed.ok, wrongSeed.commitmentOk);

const next = await service.bet('dice');
assert.equal(next.nonce, 0);
assert.notEqual(next.commitment, shown.commitment);
console.log('first bet on the new seed: nonce', next.nonce, '| waiting for a seed:', !('serverSeed' in service.history().at(-1)));

test("Active Mines hides positions from responses/history and blocks seed reveals and changes", async () => {
  const { redis, demo, mines, id } = await setup();
  const started = await mines.start(id, 100, 3);
  assert.equal(started.record.result, undefined);
  assert.deepEqual(await demo.history(id), []);
  await assert.rejects(() => demo.rotate(id), /finish the active Mines/);
  await assert.rejects(() => demo.setClientSeed(id, "new-client"), /finish the active Mines/);
  // ...
  await mines.pick(id, await safeTile(redis, id));
  const finished = await mines.cashout(id);
  assert.ok(Array.isArray(finished.record.result));
  await demo.rotate(id);
  const history = await demo.history(id);
  assert.equal(history.length, 1);
  assert.equal((await verifyRecord(history[0]!)).ok, true);
});

import { test } from 'node:test';
import assert from 'node:assert/strict';
import Redis from 'ioredis';

test('500 reservations over two connections give 500 nonces', async () => {
  const a = new Redis(), b = new Redis(), key = 'test:nonce:burst';
  await a.del(key);
  const reserve = async (redis) => Number((await redis.multi().incr(key).expire(key, 60).exec())[0][1]) - 1;

  const nonces = await Promise.all(Array.from({ length: 500 }, (_, i) => reserve(i % 2 ? a : b)));

  assert.equal(new Set(nonces).size, 500);
  assert.equal(Math.max(...nonces), 499);
  await a.del(key);
  a.disconnect();
  b.disconnect();
});

import { test } from 'node:test';
import assert from 'node:assert/strict';

const base = 'http://localhost:3000';

test('a burst of bets never shares a nonce', async () => {
  const session = await (await fetch(`${base}/api/demo/session`, { method: 'POST' })).json();
  const headers = { 'content-type': 'application/json', 'x-demo-session': session.id };
  const bet = () => fetch(`${base}/api/demo/bet`, { method: 'POST', headers, body: JSON.stringify({ game: 'dice' }) });

  const responses = [];
  for (let wave = 0; wave < 5; wave++) {
    responses.push(...(await Promise.all(Array.from({ length: 8 }, bet))));
    await new Promise((resolve) => setTimeout(resolve, 1100)); // the demo allows 5 bets a second
  }

  const accepted = await Promise.all(responses.filter((r) => r.ok).map((r) => r.json()));
  const nonces = accepted.map((body) => body.record.nonce).sort((x, y) => x - y);

  assert.ok(accepted.length > 1, 'at least two bets must get through, or the test proves nothing');
  assert.deepEqual(nonces, Array.from({ length: accepted.length }, (_, i) => i)); // 0 to k-1, no repeat, no gap
  const after = await (await fetch(`${base}/api/demo/session`, { headers })).json();
  assert.equal(after.nonce, accepted.length);
});

import { play } from '@galabet/fair';

const serverSeed = '5c1f7d3e8a2b4c6d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d';
const N = 20000, EDGE = 0.01;

const results = [];
for (let nonce = 0; nonce < N; nonce++) {
  const { result } = await play({ game: 'limbo', params: { houseEdge: EDGE }, serverSeed, clientSeed: 'galabet', nonce });
  results.push(result);
}

function check(label, sample) {
  for (const target of [2, 10]) {
    const p = (1 - EDGE) / target;               // the published chance of reaching the target
    const expected = N * p, sd = Math.sqrt(N * p * (1 - p));
    const hits = sample.filter((r) => r >= target).length;
    const z = (hits - expected) / sd;
    console.log(`${label} | ${target}x or more: ${hits}, expected ${expected} give or take ${sd.toFixed(0)} | z ${z.toFixed(1)} | ${Math.abs(z) < 4 ? 'pass' : 'FAIL'}`);
  }
  console.log(`${label} | return of a bet on 2x: ${((sample.filter((r) => r >= 2).length * 2) / N).toFixed(4)}`);
}

check('as shipped', results);
check('planted x100', results.map((r) => r * 100));

// In-memory Redis command double. Validates service sequencing and retry behavior,
// not Redis connectivity or Lua parsing; the Lua operation is modeled explicitly.
class RedisDouble {
  data = new Map<string, string>();
  hashes = new Map<string, Record<string, string>>();
  lists = new Map<string, string[]>();
  failNextBoardSave = false;
  // get, set (with NX), del, hgetall, lrange, multi().incr/incrby/expire/hset/lpush/ltrim, eval
}