Tilt Docs Play
Docs

Fairness

Check a round yourself

On this page
  1. Before you start
  2. The quick way: Your rounds
  3. Real rounds: independent house-game check
  4. Overhang: check a round
  5. Crash Tower: check a round
  6. Pinwheel: check a round
  7. Tilt Hold'em (Coming soon)
  8. Wick (Coming soon)
  9. If a check fails
  10. Compare with Elysium

Check a completed Real round from its proof: the seed must reproduce the onchain commit, and the same seed must reproduce the result. See How fairness works.

Before you start

  • Run a snippet in your browser's developer console on any https page, such as the game itself, or save it as check.js and run node check.js (Node 18 or later).
  • Define the function, then call it with your completed proof object. Copy every input exactly. Chain links hash raw seed bytes, not hex text.
  • Proofs use their returned table ID and zero-based chain index; do not substitute a visible display counter.

The quick way: Your rounds

The Dice, Blob Flip and Blackout pages offer Your rounds next to Provably fair. They read up to 200 shared browser records. Each record fetches its proof and seed from the server during a check. This local list is not a complete permanent chain archive. Open a round and press Check this round. The helper asks the game server to recompute its revealed seed and salt; its success label is not independent verification. The recipe below performs a local reconstruction. Download CSV saves the whole list.

Compare independently reconstructed outputs with the saved result and onchain records. Randomness reconstruction alone does not verify all financial allocations or manual action timing.

Real rounds: independent house-game check

  1. Open a completed round under Your rounds. Save its proof, including seed, root, table ID, index, salt, client seed and nonce. In browser network tools, the live verification response contains a proof object; use that complete object.
  2. Run the function below, then call it with that proof. It hashes raw seed bytes and reconstructs the random crash point, Dice roll, Flip side or Blackout shorts.
  3. Compare the returned result with the saved round. Check the monetary allocation separately: stake, accepted action, win rule and payout flooring. For Blackout, use ordered picks and the exact rational ladder.
  4. Compare the root, named beacon salt and settlement with Elysium, as described under Compare with Elysium. This function does not fetch or authenticate chain records.
// Define this function in a secure browser console or Node 18+.
// Pass the proof object from a completed live round's verification response.
async function checkLiveProof(p) {
  const { subtle } = globalThis.crypto ?? (await import("node:crypto")).webcrypto;
  const bytes = h => {
    if (!/^0x[0-9a-f]{64}$/.test(h)) throw Error("Expected bytes32 hex");
    return Uint8Array.from(h.slice(2).match(/../g), x => parseInt(x, 16));
  };
  const hex = buf => "0x" + [...new Uint8Array(buf)]
    .map(b => b.toString(16).padStart(2, "0")).join("");
  if (!Number.isInteger(p.index) || p.index < 0 || p.index >= 10000)
    throw Error("Unexpected house-chain index");
  if (typeof p.tableId !== "string" || !p.tableId ||
      typeof p.clientSeed !== "string" || p.clientSeed.includes(":") ||
      !Number.isSafeInteger(p.nonce) || p.nonce < 0)
    throw Error("Invalid canonical input");
  bytes(p.commit); bytes(p.salt);
  let link = bytes(p.seed);
  for (let k = 0; k <= p.index; k++) link = await subtle.digest("SHA-256", link);
  const matchesCommit = hex(link) === p.commit;
  const key = await subtle.importKey("raw", bytes(p.seed),
    { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
  const top52 = async cursor => {
    const message = `tilt:v1:${p.game}:${p.tableId}:${p.index}:${p.salt}:${p.clientSeed}:${p.nonce}:${cursor}`;
    const mac = await subtle.sign("HMAC", key, new TextEncoder().encode(message));
    return BigInt(hex(mac).slice(0, 15)); // 0x plus the first 13 hex digits
  };
  const two52 = 2n ** 52n, h = await top52(0);
  let result;
  if (p.game === "crash") {
    result = { crashCents: Math.max(100, Math.min(4000,
      Number(9800n * two52 / (100n * (two52 - h))))) };
  } else if (p.game === "dice") {
    result = { roll100: Number(h * 10000n / two52) };
  } else if (p.game === "flip") {
    result = { side: h < 2n ** 51n ? "heads" : "tails" };
  } else if (p.game === "blackout") {
    if (p.blackoutEntropy !== "drand-hmac-v1" || /^0x0{64}$/.test(p.salt))
      throw Error("Not a salted live grid proof");
    const shorts = [], limit = two52 - two52 % 49n;
    for (let j = 0; shorts.length < 3; j++) {
      const draw = await top52(j), cell = Number(draw % 49n);
      if (draw < limit && !shorts.includes(cell)) shorts.push(cell);
    }
    result = { shorts: shorts.sort((a,b) => a-b) };
  } else throw Error("Use the Hold'em recipe");
  return { matchesCommit, result };
}
// Example after obtaining a completed round's response:
// console.log(await checkLiveProof(response.proof));

Overhang: check a round

Every Overhang round publishes a proof, and this function checks it on your own machine from the proof alone. Its result does not depend on the server's answer.

  1. Save the completed round's proof object: commit, index, seed, salt, table ID, overhangRules, round key, stake, drops, topple drop, cash-out floor and payout.
  2. Run the function below, then call it with the proof. It hashes the seed's raw bytes up to the commit, rebuilds the round key from the seed, salt, table and index, replays every drop and recomputes the payout from the exact ladder.
  3. To check the salt as well, pass the named drand round's signature (hex) as the second argument. matchesBeacon must be true.
  4. Compare the commit and salt with Elysium, as described under Compare with Elysium. The function refuses any table terms other than the two signed tables.
// Define this function in a secure browser console or Node 18+.
// Pass a completed live Overhang round's proof. Optional: the named drand beacon's signature (hex).
async function checkOverhangProof(p, beaconSignature) {
  const { subtle } = globalThis.crypto ?? (await import("node:crypto")).webcrypto;
  const text = s => new TextEncoder().encode(s);
  const bytes = h => {
    if (!/^0x[0-9a-f]{64}$/.test(h)) throw Error("Expected bytes32 hex");
    return Uint8Array.from(h.slice(2).match(/../g), x => parseInt(x, 16));
  };
  const hex = buf => "0x" + [...new Uint8Array(buf)]
    .map(b => b.toString(16).padStart(2, "0")).join("");
  const hmac = async (key, message) => new Uint8Array(await subtle.sign("HMAC",
    await subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]), text(message)));
  // The two signed tables. Any other terms are refused.
  const TABLES = {
    "overhang-normal": { level: "normal", version: "overhang-v2-normal-12", landNum: 3, landDen: 4,
      mod: 4, top: 12, maxPayoutBps: 309380, maxStake: 5000000 },
    "overhang-hard": { level: "hard", version: "overhang-v2-hard-8", landNum: 1, landDen: 2,
      mod: 2, top: 8, maxPayoutBps: 2508800, maxStake: 800000 },
  };
  if (p.game !== "overhang" || p.overhangEntropy !== "drand-hmac-key-v1")
    throw Error("Not a live Overhang proof");
  const t = Object.hasOwn(TABLES, p.tableId) ? TABLES[p.tableId] : null;
  if (!t) throw Error("Unknown Overhang table");
  for (const k of ["version", "landNum", "landDen", "mod", "top", "maxPayoutBps", "maxStake"])
    if (p.overhangRules?.[k] !== t[k]) throw Error("Rules differ from the signed table: " + k);
  if (!Number.isInteger(p.index) || p.index < 0 || p.index >= 10000)
    throw Error("Unexpected chain index");
  if (p.clientSeed !== "" || p.nonce !== 0) throw Error("Live Overhang uses an empty client seed and nonce 0");
  bytes(p.commit); bytes(p.salt);
  if (/^0x0{64}$/.test(p.salt)) throw Error("Unsalted chain");
  // 1. The seed hashes (raw bytes) index + 1 times to the committed root.
  let link = bytes(p.seed);
  for (let k = 0; k <= p.index; k++) link = await subtle.digest("SHA-256", link);
  const matchesCommit = hex(link) === p.commit;
  // 2. Optional: the salt is SHA-256 of the named beacon's signature bytes.
  const matchesBeacon = beaconSignature === undefined ? null :
    hex(await subtle.digest("SHA-256", Uint8Array.from(beaconSignature.match(/../g), x => parseInt(x, 16)))) === p.salt;
  // 3. roundKey = HMAC-SHA256(seed bytes, canonical live message).
  const roundKey = await hmac(bytes(p.seed), `tilt:v1:overhang:${p.tableId}:${p.index}:${p.salt}::0:0`);
  const matchesRoundKey = hex(roundKey) === p.roundKey;
  // 4. The per-drop draw on roundKey, with round number index + 1: top 52 bits, reject the biased tail, mod m; 0 topples.
  const two52 = 2n ** 52n, limit = two52 - two52 % BigInt(t.mod);
  let toppleDrop = 0, sequence = "";
  for (let drop = 1; drop <= t.top && toppleDrop === 0; drop++) {
    for (let cursor = 0; ; cursor++) {
      const h = await hmac(roundKey, `tilt:v1:overhang:${t.level}:${p.index + 1}:${drop}:${cursor}`);
      const x = BigInt(hex(h).slice(0, 16)) >> 4n; // first 7 bytes, top 52 bits
      if (x >= limit) continue;
      if (x % BigInt(t.mod) === 0n) { toppleDrop = drop; sequence += "F"; } else sequence += "L";
      break;
    }
  }
  // 5. Payout: 0 after a topple, else floor(stake × 0.98 / p^k) at the cash-out floor k.
  const okStake = Number.isSafeInteger(p.stake) && p.stake >= 100000 && p.stake <= t.maxStake && p.stake % 10000 === 0;
  const toppled = toppleDrop !== 0 && p.drops >= toppleDrop;
  let payout = null;
  if (okStake && Number.isInteger(p.drops) && p.drops >= 1 && p.drops <= t.top) {
    if (toppled && p.drops === toppleDrop && p.cashedAt === null) payout = 0;
    else if (!toppled && p.cashedAt === p.drops) {
      const k = BigInt(p.drops);
      payout = Number(BigInt(p.stake) * 98n * BigInt(t.landDen) ** k / (100n * BigInt(t.landNum) ** k));
    }
  }
  const ok = matchesCommit && matchesBeacon !== false && matchesRoundKey &&
    toppleDrop === p.toppleDrop && payout !== null && payout === p.payout;
  return { ok, matchesCommit, matchesBeacon, matchesRoundKey, toppleDrop, sequence, payout };
}
// End of checkOverhangProof
// Example: console.log(await checkOverhangProof(response.proof));

The drops are drawn from the round key with the round number index + 1, so the Overhang page's own engine gives the same topple drop: toppleDrop(roundKey without 0x, level, index + 1). A tower that topples pays 0. A cash-out at floor k, or the automatic one at the top floor, pays floor(stake × 98 × d^k / (100 × n^k)) in micro-USDC, where a block lands with chance n/d: 3/4 on Normal, 1/2 on Hard.

Worked example (public test chain)Value
Table, indexoverhang-normal, 0
Commit0xdc8054706651e84bf39aebdf9e4bc75b85adb8974d52d5c9c6ee20e6cac410a0
Seed0xc4fc484aa5fa3d2bd8e2e5dbbed877ea031e033cc208590ddb0c327d5b650a09
Salt (test value, not a beacon)0x2105c44d723c2002dd0355621125c9615ebaf91eb61659172f16798f4fec1ade
Round key0x8c2b381dec07e1e4a2b28cde1f369e937582a90307c884600e5b6f05f2515628
DropsLLLLF: topple drop 5
Cash-out at floor 4, stake 5.0015.486419 USDC (payout 15486419)

Crash Tower: check a round

Every Crash Tower round publishes a proof after its settlement confirms. The Crash Tower page shows the server's own recompute, which is not an independent check. The function below checks the proof on your own machine from the proof alone, and can check the beacon and your bet too. Its result does not depend on the server's answer.

  1. Save the completed round's proof object: round ID, commit, index, seed, salt, table ID, client seed, nonce and outcome (crash point and bust time). From your round record, also save your stake, cash-out multiplier (cashedAt) and payout.
  2. Run the function below, then call it with the proof. It hashes the seed's raw bytes up to the commit, then recomputes the crash point and bust time from the seed, salt, table and index.
  3. To check the salt as well, pass the named drand round's signature (hex) as the second argument. matchesBeacon must be true.
  4. To check your bet, pass { stake, cashedAt, payout } as the third argument, with the stake and payout in micro-USDC. Use cashedAt: null for a lost bet. betMatches must be true.
  5. Compare the commit, salt and settlement with Elysium, as described under Compare with Elysium.
// Define this function in a secure browser console or Node 18+.
// Pass a completed Crash Tower round's proof. Optional: the named drand beacon's
// signature (hex), and your bet { stake, cashedAt, payout } in micro-USDC.
async function checkCrashProof(p, beaconSignature, bet) {
  const { subtle } = globalThis.crypto ?? (await import("node:crypto")).webcrypto;
  const bytes = h => {
    if (!/^0x[0-9a-f]{64}$/.test(h)) throw Error("Expected bytes32 hex");
    return Uint8Array.from(h.slice(2).match(/../g), x => parseInt(x, 16));
  };
  const hex = buf => "0x" + [...new Uint8Array(buf)]
    .map(b => b.toString(16).padStart(2, "0")).join("");
  if (p.game !== "crash" || p.tableId !== "crash-main") throw Error("Not a Crash Tower proof");
  if (!Number.isInteger(p.index) || p.index < 0 || p.index >= 10000)
    throw Error("Unexpected chain index");
  if (p.clientSeed !== "" || p.nonce !== 0) throw Error("Crash Tower uses an empty client seed and nonce 0");
  bytes(p.commit); bytes(p.salt);
  if (/^0x0{64}$/.test(p.salt)) throw Error("Unsalted chain");
  // 1. The seed hashes (raw bytes) index + 1 times to the committed root.
  let link = bytes(p.seed);
  for (let k = 0; k <= p.index; k++) link = await subtle.digest("SHA-256", link);
  const matchesCommit = hex(link) === p.commit;
  // 2. Optional: the salt is SHA-256 of the named beacon's signature bytes.
  const matchesBeacon = beaconSignature === undefined ? null :
    hex(await subtle.digest("SHA-256", Uint8Array.from(beaconSignature.match(/../g), x => parseInt(x, 16)))) === p.salt;
  // 3. Crash point: HMAC-SHA256(seed bytes, message), top 52 bits,
  //    raw = floor(9800 * 2^52 / (100 * (2^52 - h))), kept between 100 (1.00x) and 4000 (40x).
  const key = await subtle.importKey("raw", bytes(p.seed), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
  const message = `tilt:v1:crash:crash-main:${p.index}:${p.salt}::0:0`;
  const mac = await subtle.sign("HMAC", key, new TextEncoder().encode(message));
  const two52 = 2n ** 52n, h = BigInt(hex(mac).slice(0, 16)) >> 4n; // first 7 bytes, top 52 bits
  const raw = Number(9800n * two52 / (100n * (two52 - h)));
  const crashCents = Math.min(4000, Math.max(100, raw));
  // 4. Bust time: the first whole millisecond at which floor(100 * e^(0.00006 t)) reaches the crash point.
  const cents = t => t <= 0 ? 100 : Math.floor(100 * Math.exp(0.00006 * t));
  let bustMs = 0;
  if (crashCents > 100) {
    bustMs = Math.ceil(Math.log(crashCents / 100) / 0.00006);
    while (cents(bustMs) < crashCents) bustMs++;
    while (bustMs > 0 && cents(bustMs - 1) >= crashCents) bustMs--;
  }
  // 5. Optional bet: a win cashed at or below the crash point pays floor(stake * cashedAt / 100).
  let betMatches = null;
  if (bet !== undefined) {
    const s = bet.stake, c = bet.cashedAt;
    betMatches = Number.isSafeInteger(s) && s >= 100000 && s <= 5000000 && (c === null
      ? bet.payout === 0
      : Number.isInteger(c) && c >= 101 && c <= crashCents && bet.payout === Number(BigInt(s) * BigInt(c) / 100n));
  }
  const o = p.outcome ?? {};
  const ok = matchesCommit && matchesBeacon !== false && betMatches !== false &&
    o.game === "crash" && o.crashCents === crashCents && o.bustMs === bustMs;
  return { ok, matchesCommit, matchesBeacon, betMatches, crashCents, bustMs };
}
// End of checkCrashProof
// Example: console.log(await checkCrashProof(response.proof));

A cash-out exactly at the crash point is only possible with an auto target. A manual press must land below it. The function cannot tell the two apart, so it accepts any cash-out up to the crash point. The full rule is in the fairness specification.

Worked example (public test chain)Value
Table, indexcrash-main, 16
Commit0x3c53730f24a28a110a6c22a9c1817a37d31402214214fa686895b90eaa603654
Seed0xef507437d8ced8df7446bcf38a42d0a469f77d6a1ab134d9e8861940163132fd
Salt (drand round 21302527)0xca25ade0c98fbe9a233a2cc4351f251b7920d369f7e23cf77c5071339408227d
Beacon signature1286caf9a4dc29a0ff739e44e129b7d83d95afcb256970779c54706104b4592f26dc218eee13a16dc407f33af78e6ce4e453bdcc2c8f885e72b44be5551c778e
Crash point, bust timeraw 6286, capped to 4000 (40×), bustMs 61482
Auto target 40×, stake 2.50cashedAt 4000, 100 USDC (payout 100000000)
Index 67 on the same chainseed 0x29c5a37c4c618eed6263d06bca8efc7a8857ebf9e8b0fde8cb971548ff48b35d: crash point 100 (instant crash), bustMs 0; every bet loses

Pinwheel: check a round

Every Pinwheel round publishes a proof. The Pinwheel page checks it after the round, but it does not check the drand beacon. The function below checks the proof on your own machine from the proof alone, and can check the beacon too. Its result does not depend on the server's answer.

Pinwheel has two rules versions. Rounds opened from the 97% release on use version 2, which returns 97%. Earlier rounds use version 1, which returns 98%. The proof names its version in pinwheelRules.version, and the function uses that version's ladder. It refuses any other version.

  1. Save the completed round's proof object: commit, index, seed, salt, table ID, pinwheelRules and outcome (slots, clash shot, pins fired, pins stuck, result, multiplier, stake and payout).
  2. Run the function below, then call it with the proof. It hashes the seed's raw bytes up to the commit, draws the clash slots from the seed, salt, table and index, and recomputes the result and payout from the pins you fired and the exact ladder for the proof's version.
  3. To check the salt as well, pass the named drand round's signature (hex) as the second argument. matchesBeacon must be true.
  4. Compare the commit, salt and stake with Elysium, as described under Compare with Elysium. Also compare pinwheelRules.maxPayoutBps with the cap the vault froze for the round. The function refuses any terms other than the four signed rule sets.
// Define this function in a secure browser console or Node 18+.
// Pass a completed live Pinwheel round's proof. Optional: the named drand beacon's signature (hex).
async function checkPinwheelProof(p, beaconSignature) {
  const { subtle } = globalThis.crypto ?? (await import("node:crypto")).webcrypto;
  const bytes = h => {
    if (!/^0x[0-9a-f]{64}$/.test(h)) throw Error("Expected bytes32 hex");
    return Uint8Array.from(h.slice(2).match(/../g), x => parseInt(x, 16));
  };
  const hex = buf => "0x" + [...new Uint8Array(buf)]
    .map(b => b.toString(16).padStart(2, "0")).join("");
  // The four signed rule sets, keyed by version. rtp is the return in percent.
  // v2 (97%) is for rounds opened from the 97% release on; v1 (98%) for earlier rounds.
  const RULES = {
    "pinwheel-v2-steady-20": { tableId: "pinwheel-steady", rtp: 97n,
      rules: { version: "pinwheel-v2-steady-20", shots: 20, clashes: 1, top: 19, maxPayoutBps: 194000, maxStake: 5000000 } },
    "pinwheel-v2-wild-10": { tableId: "pinwheel-wild", rtp: 97n,
      rules: { version: "pinwheel-v2-wild-10", shots: 10, clashes: 2, top: 8, maxPayoutBps: 436500, maxStake: 4640000 } },
    "pinwheel-v1-steady-20": { tableId: "pinwheel-steady", rtp: 98n,
      rules: { version: "pinwheel-v1-steady-20", shots: 20, clashes: 1, top: 19, maxPayoutBps: 196000, maxStake: 5000000 } },
    "pinwheel-v1-wild-10": { tableId: "pinwheel-wild", rtp: 98n,
      rules: { version: "pinwheel-v1-wild-10", shots: 10, clashes: 2, top: 8, maxPayoutBps: 441000, maxStake: 4640000 } },
  };
  if (p.game !== "pinwheel" || p.entropy !== "drand-hmac-v1") throw Error("Not a live Pinwheel proof");
  const version = p.pinwheelRules?.version;
  const set = typeof version === "string" && Object.hasOwn(RULES, version) ? RULES[version] : null;
  if (!set) throw Error("Unknown Pinwheel rules version");
  if (p.tableId !== set.tableId) throw Error("Rules version does not belong to this table");
  const t = set.rules;
  for (const k of Object.keys(t))
    if (p.pinwheelRules[k] !== t[k]) throw Error("Rules differ from the signed version: " + k);
  if (!Number.isInteger(p.index) || p.index < 0 || p.index >= 10000)
    throw Error("Unexpected chain index");
  if (p.clientSeed !== "" || p.nonce !== 0) throw Error("Live Pinwheel uses an empty client seed and nonce 0");
  bytes(p.commit); bytes(p.salt);
  if (/^0x0{64}$/.test(p.salt)) throw Error("Unsalted chain");
  // 1. The seed hashes (raw bytes) index + 1 times to the committed root.
  let link = bytes(p.seed);
  for (let k = 0; k <= p.index; k++) link = await subtle.digest("SHA-256", link);
  const matchesCommit = hex(link) === p.commit;
  // 2. Optional: the salt is SHA-256 of the named beacon's signature bytes.
  const matchesBeacon = beaconSignature === undefined ? null :
    hex(await subtle.digest("SHA-256", Uint8Array.from(beaconSignature.match(/../g), x => parseInt(x, 16)))) === p.salt;
  // 3. Clash slots (same in both versions): HMAC-SHA256(seed bytes, message with cursor j),
  //    top 52 bits, reject the biased tail and repeats, slot = v mod shots. clashShot = min(slots) + 1.
  const key = await subtle.importKey("raw", bytes(p.seed), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
  const two52 = 2n ** 52n, n = BigInt(t.shots), limit = two52 - two52 % n, slots = [];
  for (let j = 0; slots.length < t.clashes; j++) {
    const message = `tilt:v1:pinwheel:${p.tableId}:${p.index}:${p.salt}::0:${j}`;
    const mac = await subtle.sign("HMAC", key, new TextEncoder().encode(message));
    const v = BigInt(hex(mac).slice(0, 16)) >> 4n; // first 7 bytes, top 52 bits
    if (v >= limit) continue;
    const slot = Number(v % n);
    if (!slots.includes(slot)) slots.push(slot);
  }
  const clashShot = Math.min(...slots) + 1;
  // 4. Settlement: the last pin fired is the clash shot (pays 0), or a cash-out at that many pins.
  const o = p.outcome ?? {}, fired = o.pinsFired;
  const okStake = Number.isSafeInteger(o.stake) && o.stake >= 100000 && o.stake <= t.maxStake;
  let result = null, pinsStuck = null, multiplier = null, payout = null;
  if (okStake && Number.isInteger(fired) && fired >= 1 && fired <= t.top && fired <= clashShot) {
    if (fired === clashShot) { result = "clash"; pinsStuck = clashShot - 1; multiplier = { num: 0, den: 1 }; payout = 0; }
    else {
      // M(k) = rtp * C(n, b) / (100 * C(n - k, b)), reduced. rtp comes from the version.
      const C = (a, b) => { let r = 1n; for (let i = 0n; i < BigInt(b); i++) r = r * (BigInt(a) - i) / (i + 1n); return r; };
      const gcd = (a, b) => b === 0n ? a : gcd(b, a % b);
      let num = set.rtp * C(t.shots, t.clashes), den = 100n * C(t.shots - fired, t.clashes);
      const g = gcd(num, den); num /= g; den /= g;
      result = "cashout"; pinsStuck = fired; multiplier = { num: Number(num), den: Number(den) };
      payout = Number(BigInt(o.stake) * num / den);
    }
  }
  const ok = matchesCommit && matchesBeacon !== false &&
    JSON.stringify(o.slots) === JSON.stringify(slots) && o.clashShot === clashShot &&
    payout !== null && o.result === result && o.pinsStuck === pinsStuck &&
    o.multiplier?.num === multiplier.num && o.multiplier?.den === multiplier.den && o.payout === payout;
  return { ok, version, matchesCommit, matchesBeacon, slots, clashShot, result, pinsStuck, multiplier, payout };
}
// End of checkPinwheelProof
// Example: console.log(await checkPinwheelProof(response.proof));

Pin p lands on slot p - 1, so pin number clashShot is the first pin that clashes. A clash pays 0. A cash-out after k stuck pins, or the automatic one at the top, pays floor(stake × M(k)) in micro-USDC, using the ladder of the proof's version. Both ladders are in the fairness specification.

Worked example (public test chain)Value
Table, indexpinwheel-steady, 3
Commit0xaa746801e117563edd7a12848efde4c4e1b8f43636f31e426021749d1dbbc449
Seed0xc5d880db8746cd1e7df0b00d006a8b0408895676f0a0e7c496e8886381b9cdaf
Salt (drand round 21302527)0xca25ade0c98fbe9a233a2cc4351f251b7920d369f7e23cf77c5071339408227d
Beacon signature1286caf9a4dc29a0ff739e44e129b7d83d95afcb256970779c54706104b4592f26dc218eee13a16dc407f33af78e6ce4e453bdcc2c8f885e72b44be5551c778e
Slots, clash shot[17], 18
Cash-out at 4 pins, stake 3.00, version 2 (pinwheel-v2-steady-20)multiplier 97/80, 3.6375 USDC (payout 3637500)
Same round and play, version 1 (pinwheel-v1-steady-20)multiplier 49/40, 3.675 USDC (payout 3675000)
Cash-out at 17 pins, stake 0.10, version 2multiplier 97/15, 0.646666 USDC (payout 646666)
Same chain index on pinwheel-wildslots [2, 8], clash shot 3; pin 3 clashes, payout 0 in both versions

A cash-out proof relabelled from version 2 to version 1, or the reverse, fails. Either its terms do not match the version, or its multiplier and payout do not match that version's ladder. A clash pays 0 on both ladders, so a clash proof cannot show its version by itself. For a clash, compare maxPayoutBps with the vault's frozen cap for the round.

Tilt Hold'em Coming soon

Wick Coming soon

If a check fails

Check that you copied the whole seed and commit, and used the proof's own table ID and index.

Compare with Elysium

For a live proof, compare its chain root and salt with the corresponding Elysium records, then inspect its settlement receipt. The seed must reproduce the committed root, and the salt must come from the exact drand round named by that commitment. The result is published after twelve canonical L2 confirmations; those are not irreversible HyperEVM finality. The fairness specification gives the encodings and financial limits.