NOBODY PICKS THE RESULT.
NOT EVEN US.

Every roll in the battle is a Collector Crypt VRF output (ECVRF, RFC 9381), each one individually provable on the public verifier and created only after all entries were locked, so nobody, us included, can predict or grind it. We hash the battle id together with every roll into one fingerprint:

seed = sha256( battleId | "seat:round:ccRoll:ccMemo" | ... for every roll, seat-then-round order )

This is the exact string the Verify panel shows as seed. Because it is built only from public VRF outputs, there is zero extra transaction and no hidden input.

Each seat's settled cash-out (buyback) total becomes its HP pool. In team formats the team's pools combine. Your win chance is exactly your share of the total HP, so a smaller stack still has a real, provable shot. That is the whole point of the mode.

The seed drives a deterministic RNG. Sides swing in round-robin order (the first swing is a seeded pick). The rules, tuned by simulation so the win rate tracks the HP share:

• Accuracy: each swing hits with probability 0.75, otherwise it is a miss.
• Damage: on a hit, uniform in [1 … maxHit] where maxHit = C · pairPool · (2 · targetHP₀ / pairPool)^γ. The smaller stack swings proportionally harder.
• Crit: a top-15% damage roll is labelled a crit. It is a label only, never a multiplier, so it cannot distort the tuned balance.
• Bounded: sudden-death escalation past a swing threshold caps every fight (~13-24 swings) and the formula is scale-invariant, so $25 packs and $10k chase pulls pace identically.
• Result: last side standing takes the whole pot.

This is exactly what your browser runs when you open Verify on a settled fight, using the same functions the app ships. Feed it the public rolls and seat totals from any battle and it lands on the seat that got paid, or it does not, and you have caught us.

import {
  deriveFightSeedHex,
  fightSidesFromTotals,
  rngFromSeedHex,
  simulateFight,
} from '@workspace/types'; // fight spec v1

// 1) Re-derive the seed from the public on-chain rolls
const seed = deriveFightSeedHex(
  battle.id,
  battle.rolls.map((r) => ({
    seat: r.participantSeat,
    roundIndex: r.roundIndex,
    ccRoll: r.ccRoll,   // Collector Crypt VRF roll
    ccMemo: r.ccMemo,   // its memo (verify at /api/vrf/verify?memo=...)
  })),
);
// seed === battle.fightSeed   (the "Seed check")

// 2) Turn each seat's settled buyback total into HP
const sides = fightSidesFromTotals({
  seatCount: battle.seatCount,
  teamMode: battle.teamMode,
  totalsBySeat: new Map(
    battle.participants.map((p) => [p.seat, p.totalValueCents]),
  ),
});

// 3) Replay the fight deterministically from the seed
const { events, winner } = simulateFight(sides, rngFromSeedHex(seed));
// winner === the seat/side that got paid   (the "Fight check")

The battle id, rolls, seat totals and stored seed are all in the public battle snapshot (GET /battles/<id>). Each roll's ccMemo verifies independently on the VRF verifier, and each seat's NFT transfer is on Solscan, so the entire chain, from randomness to payout, is inspectable end to end.