Prove. Commit. Verify.
The operator cannot bias which holder wins. The roll is an RFC 9381 ECVRF output keyed by our on-chain frozen key, its input bound to the resolved slot hash so it cannot be precomputed, and the winner is the holder whose weighted slice of the snapshot covers the roll. Recompute AND verify everything — the binding, the ECVRF proof, the roll — right here in your browser.
- FreezeWe froze our VRF key on-chain before any drawOur ECVRF public key is registered + FROZEN on-chain (Collector Crypt VRF program) under a fixed owner + label. Once frozen it cannot be swapped — every proof verifies against this one key.vrf_authority: frozen(pk, owner, label)
- SnapshotEvery holder balance is recorded at the close slotWhen the window closes we record a Merkle root of every eligible $GACHA balance at that exact Solana slot. Nobody touches your balance — we just take a tamper-evident snapshot the weighted pick runs over.snapshotMerkleRoot = MerkleRoot(holders[closeSlot])
- Provealpha binds the slot, we publish the ECVRF proofThe proof input alpha = sha256(slotHash ‖ drawId) binds the FUTURE slot blockhash — nobody (including us) can precompute it. We produce the ECVRF proof and commit sha256(proof) on-chain.alpha = sha256(slotHash ‖ drawId)
- Rollbeta[0:32] picks the winnerThe roll is the first 32 bytes of the VRF output (beta). We walk the prefix-sum of weights — first holder whose slice covers the offset wins the whole pot. verifyVRF confirms the proof; the roll is forced by it.roll = beta[0:32] (beta = ECVRF output)
Recompute the roll. Right here. In your browser.
The widget recomputes the VRF input alpha = sha256(slotHash ‖ drawId), verifies the ECVRF proof itself (verifyVRF, RFC 9381) against the operator key, and confirms the published roll IS beta[0:32] — the entire chain, in your browser. Collector Crypt is an independent cross-check that the operator key is the one frozen on-chain.
- VRF authority
- 13R5zhNirknRrskNyEmyZuC5NNEQWcSwN5w8BUn6qnp8
- Slot
- 433839573
- Slot hash
- 213e290f63b018c8de115800ff8d575d5bc5322501805ef4cda0bd1d83f61d02
- alpha (published)
- e606b9aead530c2b2a2be4f5e3038be4b07e843dc4d522ac1de13fc4b15cb574
- alpha (recomputed)
- e606b9aead530c2b2a2be4f5e3038be4b07e843dc4d522ac1de13fc4b15cb574
- Alpha binds slot
- ✓ alpha === sha256(slotHash ‖ drawId)
- Operator VRF key
- e75d1717431b1c691084425d0a0d96f094c7e72fb9d35a49b7052326d8f48f0e
- ECVRF proof valid
- ✓ verifyVRF(operatorKey, alpha, proof) === true (in-browser)
- beta (VRF output)
- 4d2553acc8ffe88933952273c94e4de7fb9db0fbeb834318db0f131e8602a297409ba2cf605ba884cfd48facb0d84422c62d0134d51c03fb6a32f431a7ba1f00
- Published roll
- 0x4d2553acc8ffe88933952273c94e4de7fb9db0fbeb834318db0f131e8602a297
- Roll is beta[0:32]
- ✓ rollHex === beta[0:32]
- Snapshot root
- 22fa1bddb8a32acd170909f3b72640a69dd5114a50210849c611adc685783475
- Holders
- 2,087
- Eligible total
- 878,342,570 GACHA
- Winner balance
- 12,506,945 GACHA
- Winner odds
- ✓ balance / eligible = 1.4239% (matches published)
- On-chain commit
- 12oxGtnJ9UojUALoKMRYDeVognVfZutfDB1uvT1NqHwX
- Owner (verify input)
- HuTNYccZn2U3sNpJnVTgyi9XZFRo9GjbJHBjc1F2tWYL
- Label (verify input)
- raffle
- Memo (verify input)
- pg-raffle-1534
- Proof (verify input)
- 32f016f4ef5065fd9a1a16754be4ce89e8ac42341cb6fa300af8105b7cce5f89277e4f07fd055966b4d70825753c8f47243a02f7ef9ec25298ed98fac2be86754387ec6fdf2c7381079d0c936a999800
Verified in your browser: alpha binds the public slot, the ECVRF proof checks out under the published operator key, and the roll IS beta[0:32]. The winner is then the balance-weighted pickWinner(snapshot, roll) walk — the snapshot itself is committed by the Merkle root above (not downloaded here), so the winner + odds rows are informational.
1 card worth $29 opened this window — vany held 1.42% of the eligible snapshot and won the pot.
Copy-paste. Run it locally. Same answer.
import { verifyVRF, vrfProofToHash } from '@collectorcrypt/vrf-client';
import { sha256 } from '@noble/hashes/sha2';
// alpha binds the resolved slot hash + draw id (32B slot hash || utf8 id)
const alpha = sha256(concat(slotHashBytes, utf8(String(drawId))));
// 1. the ECVRF proof must verify under our FROZEN operator key
const ok = verifyVRF(operatorPubkey, alpha, proof); // RFC 9381 -> true
// 2. the published roll must be the first 32 bytes of the VRF output
const roll = vrfProofToHash(proof).slice(0, 32); // === published rollHex
// 3. the winner: map roll into [0,1), walk the snapshot's weight
// prefix-sum — the first holder whose slice covers it wins.Node ≥ 20 · no dependencies · same output as the browser widget.