A plain-English and a technical explanation of how BaseComp's FairLock draws work, how the grand prize winner is picked, and how anyone can check a draw for themselves.
FairLock is the draw system behind every competition on BaseComp. It lets anyone, player or operator, check for themselves that a draw was run fairly, without taking the operator's word for it.
Before a competition opens, the instant win positions are generated at random and sealed away, so nobody knows which tickets will win them. The method for picking the grand prize winner is fixed in advance too, but the winner can't be known until the competition closes, because it depends on a public random number that is only published after the last ticket is sold. After the draw, everything is revealed, and anyone can confirm that what was revealed is exactly what was sealed.
This article explains how that works twice: once in plain English, and once with the maths, for anyone who wants to check it properly. For the short version, see the FairLock page.
Most competition sites can show you that their grand prize winner was picked randomly. Some use a third-party random number tool, some record a live draw. That is better than nothing, but it only covers one prize.
In a modern competition, instant wins often make up most of the prize value. A £10,000 competition might have one £600 grand prize and thousands of instant wins. The random draw at the end proves nothing about those. It can't show that:
So players are trusting the operator on the part that matters most. FairLock was built to remove that trust. For the background on why this matters for the category, see Publicly Verifiable Draws Explained.
Instant win positions and grand prize seed generated at random and sealed. Fingerprint published.
Tickets sell. Wins detected without opening the seal. Nothing can change.
Seed combined with a public random number published after the last ticket.
Seed, positions and random number revealed. Anyone can recompute the fingerprint and check it matches.
Fingerprint recorded on Bitcoin via OpenTimestamps.
Think of it as a sealed envelope, posted to a post office the operator doesn't own.
Before sales open. FairLock rolls the dice for every instant win position and puts the results in a sealed envelope. It also writes a random number on a second slip of paper, for the grand prize, and seals that too. Then it takes a fingerprint of both envelopes and publishes it. Everyone can see the fingerprint. No operator or player can see inside the envelopes.
During sales. When you buy a ticket, the system checks whether your position is in the envelope, and tells you straight away if you've won an instant prize. It does this without opening the envelope, using a one-way lookup. So the operator never sees the list of winning positions while tickets are on sale. The envelopes can't be swapped, because the fingerprint wouldn't match.
At the draw. The grand prize needs a second random number that nobody holds in advance. It comes from drand, a public service run by a group of independent organisations including Cloudflare, which publishes a new signed random number every three seconds. FairLock uses the first one published after the last ticket was sold. The number from the envelope and the public number are mixed together, divided by the number of valid tickets, and the remainder says how far along the list of valid tickets the winner sits. While tickets were on sale that public number didn't exist yet, so nobody, the operator and BaseComp included, could have known which ticket would win.
After the draw. Both envelopes are opened and everything inside is published: every instant win position, the random number for the grand prize, the public random number it was mixed with, and the calculation. Anyone can take that data, run it through a standard fingerprint tool, and check it matches the fingerprint published before sales opened. If anything had been changed, added or removed, the fingerprints wouldn't match.
The post office. Since October 2026, the fingerprint is also sent to OpenTimestamps, a free public service that records it on the Bitcoin blockchain. Within a few hours of the competition being published, the fingerprint has a date nobody can alter, so "sealed long before the draw" is proven by a clock the operator doesn't control.
That's it. Play remains a game of chance throughout. The envelope doesn't decide who wins. It just proves afterwards that nobody cheated.
For anyone who wants to check the claims above with a hash calculator.
Three things are created when a competition is published, before any ticket can be bought.
1. Instant win positions. For each instant win prize, a position between 1 and the total number of tickets is chosen with a cryptographically secure random number generator. Each position is encrypted (AES-256-CBC, with a MAC on every value) under a dedicated draw key, and indexed by a keyed hash: HMAC-SHA256(competition_id + "|" + position, secret). The index is what lets the system detect an instant win at purchase time with a single lookup, without decrypting anything.
2. The grand prize seed. A random 128-bit seed (32 hex characters) is generated and encrypted, along with a random salt. Only its hash is published: seed_hash = SHA256(seed_salt + ":" + seed). No winning position is generated at this stage, because the winner depends on the final ticket count and on a public random number that doesn't exist yet. Which public source will be used is fixed now, inside the commitment.
3. The commitment hash. Everything is combined into one public fingerprint. The parts are joined with nothing between them:
commitment_hash = SHA256(
canonical_instant_wins_json
+ "|SEED:" + seed_hash (only when there is a grand prize)
+ "|BEACON:drand-quicknet:52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971"
(grand prize competitions published since 12 October 2026)
+ verification_salt
+ competition_id
)
The beacon segment names drand's quicknet chain by its chain hash, so the source of the public random number can't be swapped after publishing.
The canonical JSON has the shape {"instant_wins":[{"position":N,"prize_id":"..."},...],"main_prize":null}, sorted by position, so the commitment covers which prize sits at which position, not just how many there are. The hash and its creation time are published before sales open.
Tickets are given draw positions in purchase order. When a ticket is bought, the system computes the HMAC of its position and looks for a match in the index. If there's a match, it's an instant winner. The plaintext positions and the seed stay encrypted for the whole sales period.
For competitions published since June 2026, the ticket references customers see (for example TKT-033212) are a scrambled one-to-one mapping of draw positions, which makes sales volume hard to read off ticket numbers while a competition is live. The mapping seed is shown on the Verify page after the draw, so anyone can work out the draw position behind every reference. It isn't part of the commitment hash; it only decides how numbers are displayed.
When the competition closes, FairLock picks a drand round: the first round of the quicknet chain published at least a minute after the ticket list became final (the close, the 12-minute payment settlement window and any open checkout, whichever is latest). It records that round number as soon as sales close, before the round exists, fetches it once it is published, and checks its BLS signature against the chain's public key. Then:
winner_index = int(SHA256(seed + ":" + randomness), 16) mod active_ticket_count
where seed and randomness are the lowercase hex strings shown on the Verify page and active_ticket_count excludes refunded and voided tickets. winner_index counts from zero along the valid tickets in draw-position order: index 0 is the first valid ticket, index 1 the second, and so on. Three properties make this sound:
The draw runs once. The system refuses to regenerate the seed once any ticket has sold, the round is recorded before its value is known so a retried draw can't try a different one, a closed competition's end date can no longer be moved, and the draw refuses to run if any ticket was issued after the round was published.
Competitions published before 12 October 2026 used the seed alone: winner_index = int(seed, 16) mod active_ticket_count. Their Verify pages show that formula.
The Verify page publishes:
SHA256(salt:seed) = seed_hashmatchesSHA256(input string) = commitment_hashmatchesdrand round N = randomness, after last ticketmatchesSHA256(seed:randomness) mod tickets = indexmatchesSHA256(seed_salt + ":" + seed) with any SHA-256 tool and confirm it equals the seed_hash published before sales.commitment_hash published before sales.int(hashlib.sha256(f"{seed}:{randomness}".encode()).hexdigest(), 16) % active_ticket_count. Count that many valid tickets along in draw-position order, starting from zero, and confirm it lands on the announced winner.If all four hold, the instant win positions and the grand prize seed are exactly what was sealed before the competition opened, the public random number is genuine and came after every ticket, and the winner was computed correctly from them.
A commitment hash proves the sealed data hasn't changed since the hash was made. On its own, it doesn't prove when the hash was made, because the timestamp comes from the operator's database. A sceptic can say "you could have made it after the draw and backdated it".
Since October 2026, every BaseComp competition's commitment hash is submitted to OpenTimestamps by a scheduled job within a couple of minutes of the competition being published. OpenTimestamps aggregates hashes from around the world into a Bitcoin transaction. Once that transaction is in a block, usually within a few hours, the receipt proves the hash existed by that block's time, and nobody can alter a Bitcoin block after the fact. The Verify page shows the block number and date, and the receipt can be downloaded and checked at opentimestamps.org. Competitions that were already live when this launched on 8 October 2026 were stamped that day; competitions drawn before then were not.
Only the hash is sent, never the sealed data, so nothing is revealed early. The FairLock page shows where to find all of this on a real competition.
| FairLock proves | FairLock doesn't prove |
|---|---|
| The instant win positions and prize allocation haven't changed since the commitment was made | That the operator isn't buying tickets under other names (the public entrant list on every competition exists to make that visible) |
| Every advertised instant win was available to be won, because every sealed position is published, claimed or not | That the commitment was made before the very first sale: its creation time comes from BaseComp's database, and the Bitcoin record lands a few hours after publishing, so the independent claim is "sealed by block X", which is still before any draw |
| The grand prize seed wasn't chosen to favour anyone | Anything independent about competitions drawn before timestamping went live (a timestamp can only prove "existed by now") |
| The winner was computed correctly from the sealed seed, the public random number and the final ticket count | That nobody at BaseComp could read the sealed instant win positions early: they are encrypted with keys the platform holds, and operators and players have no access to them |
| Nobody, BaseComp included, could know the grand prize winner while tickets were on sale | The same for the grand prize on competitions published before 12 October 2026, which used the seed alone |
| Every published winning position, and the prize at it, matches the sealed data |
Random number generators and live draws were a reasonable standard when competitions had one prize. They aren't a reasonable standard now that most of the value sits in instant wins. Any system that can't show a player every winning position, and prove the list hasn't changed since before they bought, is asking for trust it hasn't earned.
We built FairLock so that the question a player asks stops being "do I trust this operator?" and becomes "did I check?". We think that should be the baseline for the category, not a differentiator, and we'd rather every platform offered it than keep it as a selling point. Until they do, operators who can't offer it should expect to be asked why.
No. The instant win positions are generated at random and sealed, so nobody knows which tickets will win them, and your ticket is as likely to land on one as anyone else's. The grand prize winner can't be known until the competition closes, because it depends on a public random number published after the last ticket is sold. What's fixed in advance is the method, not the outcome. The sealing exists so that afterwards you can prove nothing was tampered with.
No. The positions are encrypted, and the instant win check at purchase uses a one-way keyed hash that matches a position without revealing the list. The operator sees a win at the same moment the player does.
The sealed seed is mixed with a public drand random number published after the last ticket, and the result is divided by the number of valid tickets, with the remainder saying how far along the list of valid tickets the winner sits. The seed is fixed before sales. The public number doesn't exist until sales are over. Together they produce a winner nobody could have predicted or aimed at.
Because "secret" means somebody holds it. The seed is encrypted with keys the platform holds, so on its own it asks you to trust that nobody with those keys used them to buy the right ticket near the close. The drand number removes that trust: it is published by independent organisations after sales end, so even someone who knew the seed couldn't know the winner until it was too late to buy a ticket.
They're generated with a cryptographically secure random number generator, the same class used for encryption keys. The verification check doesn't require you to trust that, though. It only requires you to confirm that what was revealed matches what was sealed.
OpenTimestamps uses Bitcoin because it's the most widely replicated, hardest-to-alter public ledger available, and the service is free. No cryptocurrency is bought, held or used by BaseComp or by operators. Only a hash is recorded.
No. The seed cannot be regenerated once any ticket has sold, the drand round is recorded before its value is published, and the draw computation is deterministic, so running it again gives the same result. An interrupted draw reveals the winner already computed.
Every competition published on BaseComp, yes. Grand-prize-only competitions commit an empty instant win list and a seed. Instant-win-only competitions commit their positions and no seed. Competitions with both commit both. The verification steps are the same. Competitions a store imported from its previous platform were never sealed by FairLock, so their Verify page has no proof to show.
Create a free BaseComp account
Create a free BaseComp account and see FairLock on a competition of your own. Every draw you run is verifiable by your customers from day one. No card required. Or book a call with Ryan.
Get the latest tips, product updates, and industry news delivered to your inbox. No spam, unsubscribe any time.
