No single operator
drand's randomness is produced jointly by many independent organisations (the League of Entropy). No one party — Jambala included — can bias it.
Jambala · Provably fair draws
Every winner is drawn in the open.
Jambala doesn't pick winners behind closed doors. Each draw is seeded by the drand public randomness beacon — a signed random number produced every few seconds by a network of independent organisations. Nobody, us included, can predict or change it. Give this page the round number and the ticket list and it will re-draw the exact same winner, right here in your browser.
Chain
drand quicknet
Committed round
fixed by each competition's published close time — announced before entries close, so we can't shop for a result.
01 — 02 — 03
How a Jambala draw works
Three public inputs, one reproducible result. There is nothing else in the box.
01 · COMMIT
We lock the round before close
The moment a competition's close time is set, the exact drand round that will seed its draw is already fixed by the clock. We publish that round number in advance.
round = first beacon at/after close time
02 · BEACON
drand produces the randomness
At close, the drand network publishes that round: a random value with a BLS signature, identical across every mirror. It cannot exist before its time, and cannot be forged.
randomness = SHA-256(signature)
03 · DERIVE
The winner falls out by maths
We hash the randomness against the published ticket list to land on a ticket. Same inputs, same output — for us, for you, for anyone.
shuffle pool by SHA-256(seed | … | i), take first N The exact method
The method, in full
This is the whole algorithm. It is the same code that runs our draws and the same code running in the verifier below.
# 1. Canonical ticket pool — every entered ticket number, unique, ascending pool = sort(unique(entered_ticket_numbers)) poolStr = pool joined by "," # e.g. "1,2,3,...,1300" poolHash = SHA256(poolStr) # published, so the pool can't be swapped # 2. Seed — the drand randomness for the committed round seed = drand.round(R).randomness # 64 hex chars, publicly signed # 3. Shuffle the pool with the beacon; the first N tickets are the winners for i = 0, 1, ..., N-1 : input = seed | product_id | poolHash | pool_size | i j = i + ( SHA256(input) mod (pool_size - i) ) swap pool[i], pool[j] winner_i = pool[i]
Verify it yourself
Re-draw any Jambala competition
Everything below runs in your own browser. Fill in a draw's public values — or leave the worked example as-is and press Verify to see it reproduce winners 46, 51 and 851.
drand verifier · quicknet
SHA-256 · local
Round—
Randomness—
Signature ✓—
Pool—
Pool SHA-256—
Winning tickets—
Tip: to check a real draw, enter the round and ticket pool published with that
competition's result, then press Fetch round from drand to pull the signed randomness and reproduce the winners.
Why a beacon, not a black box
Why we use drand
Committed in advance
The round is fixed by the close time. We announce it before entries close, so we can't shop for a result we like.
Signed & identical everywhere
Every round carries a BLS signature and reads the same on every public mirror. We check several and they must agree.
Reproducible forever
Past rounds are permanent and public. This draw can be re-checked next week or next year and will always give the same winner.
Independently anchored, too: each draw also records the first Bitcoin block after close as a second timestamp. The compliance basis is the DCMS Code of Practice for Prize Draw Operators (Clause 2.2) — a computer process producing verifiably random, auditable results.
Questions
Common questions
Could Jambala rig which ticket wins?
No. The seed is a drand value we can't produce or predict, fixed to a round that's public before entries close. The winner is a pure function of that seed and the published ticket list. Change either and the pool hash won't match — which anyone can see.
What if the ticket list were swapped after the draw?
The SHA-256 of the ticket pool is published with every draw. Alter one ticket and the hash changes, so a tampered list fails verification instantly.
What happens if the beacon is briefly unreachable at close?
The draw waits. It never falls back to an unverifiable method — if a signed round can't be confirmed, the draw simply runs a little later once the beacon responds. A result we can't prove is a result we won't publish.
Do I have to trust this page's code?
No. The round comes straight from drand.love and its mirrors, and the algorithm above is short enough to run with any SHA-256 tool. This page is just a convenience.
Jambala · draws seeded by the drand quicknet beacon · chain 52db9ba7…c84e971