You don’t have to take our word for it.
Every Monoloci competition winner is picked by a calculation you can run yourself, from two things we publish, using a number nobody on earth can predict.
The problem
Any draw can be rigged. The question is whether anyone would ever know.
When you finish a Monoloci journey and unlock a competition reward, the app issues you a nine-character code — something like A2B4C6D8E. Every code is generated on our server, recorded with a timestamp, and limited to one per person per reward. That list of codes is the draw.
We could tell you we shuffled it fairly. You’d have no way to check. So instead the draw is built from two published artefacts, released in a fixed order, and either one on its own is useless for cheating.
The entry list
Every code in the draw, in order, with a SHA-256 fingerprint of the whole list. Codes only — no names, no accounts.
Published the moment entries close, before the seed exists. Change one character afterwards and the fingerprint no longer matches.
f5817a3ab59752b850eac877c2ad99e0
The seed
The hash of a specific Bitcoin block — a 64-digit number that appears roughly every ten minutes and cannot be predicted or influenced.
We announce which block before entries even open. At that point the number it will produce does not yet exist, for us or for anyone.
18293a4b5c6d7e8f90a1b2c3d4e5f607
Check it yourself
Paste the two published values. Get the winner.
This runs entirely in your browser — nothing is sent anywhere, and it works with the page saved offline. It is the same arithmetic our draw script runs, so if your answer differs from ours, one of us has some explaining to do.
Draw verifier
Loaded with example data — replace it with a published drawPaste the entries file, or just the codes — one per line, in the published order.
The seed
How to get the block hash for yourself
You don’t need to know anything about Bitcoin, and you don’t need any of it — a block hash is just a public number that arrives on a schedule nobody controls. Every block ever mined stays readable forever, on dozens of independent sites.
-
01
Take the block height from the competition post. It’s a plain number, something like 968,500. We publish it before entries open, which is the whole point — at that moment the block hasn’t been mined and its hash doesn’t exist yet.
-
02
Look it up on a block explorer. Open
mempool.space/block-height/968500in any browser, swapping in the announced height. The page it lands on shows that block’s hash at the top — a 64-character string starting with a long run of zeros. -
03
Check it somewhere else too. Blockchair and Blockchain.com list the same block. Independent sites showing the same hash is what makes this checkable rather than something you’re asked to believe.
-
04
Paste it into the verifier above, along with the published entry list. Capitalisation and stray spaces don’t matter — the seed is tidied the same way on both sides.
Every draw, every time
What we publish with each result
- The entry listAll codes in the draw, in order. Codes only — yours identifies you to you, and to nobody else.
- The list fingerprintPosted at close, before the seed exists. This is the part that stops the list being edited later.
- The block height and its hashWith links to two independent explorers, so you never have to take the number from us.
- The winning code and the reserves in orderAnnounced as codes, not names. If you’re holding it, you’ll know.
- The verifierThis page, plus a command-line version for anyone who’d rather not trust a webpage either.
Under the hood
The calculation, in one paragraph
The entry list is shuffled with Fisher–Yates — the standard shuffle — but instead of random numbers, each swap uses SHA-256(seed + ":" + step), taking the first six bytes as an integer. That makes the shuffle completely determined by the seed: the same list and the same seed always produce the same order, on any computer, in any year. Position one wins.
Because the shuffle is fixed by the seed, the only way to steer the result is to change the entry list after seeing the seed — which is exactly what publishing the fingerprint first prevents.
If you’d rather run it away from a browser we can’t be audited on, the same draw runs in about twenty lines of plain Node.js with no packages installed:
node verify-draw.mjs entries.json <block-hash> 5
Our own draw script imports its shuffle from that same file, so the official result and your check are not two implementations that ought to agree — they’re one implementation, run twice.
The rules
Terms worth knowing before you enter
Entry is free and one code is issued per person per reward. There is no way to buy extra entries, and no way to earn them — a hundred journeys gets you the same single chance in any one draw as anybody else. Every entry weighs the same.
Entry is automatic. Reaching the reward enters you — there is nothing to send in and no form to fill. Screenshot your coupon and keep it: that is your evidence when claiming a prize, not your entry. One entry per person per draw, so if the same account holds more than one code only the earliest goes into the list.
Winners are drawn by chance, not judged on merit, and the draw happens on the announced date using the announced block. If that block runs late, we wait for it rather than substituting another.
We announce the winning code publicly and contact the holder in the app. If a winner can’t be reached inside the claim window stated in the competition post, the prize passes to the next reserve code in the published order — which was drawn at the same time as the winner, not afterwards.