How We Draw a Winner We Cannot Know Yet

Most competition sites eventually show you a winner and ask you to trust that everything happened fairly behind the scenes.

We decided that was not quite enough.

Legion Comps is still a new business. We cannot point to twenty years of trading history and a warehouse full of dusty awards. If we want people to trust our draws, we need to give them something better than a confident paragraph and a photograph of somebody holding a clipboard.

So we built a draw system where the information needed to select the winner does not all exist when the draw begins.

Not even we can know the result in advance.

That sentence is the short version. The longer version involves sealed secrets, frozen ticket pools, a public randomness beacon and an unnecessarily large number of hashes.

We will try to keep this painless.

Random is only part of the problem

Picking a random number is easy. Computers have been doing it for a long time, usually while pretending not to know exactly where the missing sock went.

The harder problem is proving that the number was selected from the correct tickets, using information that nobody quietly changed after seeing the result.

There are several questions a fair draw should answer:

• Was the secret used for the draw created before tickets were sold?
• Which tickets were actually included?
• Could the organiser know the random value before fixing the ticket pool?
• Can somebody else repeat the calculation and get the same winner?

Our draw process is designed to leave evidence for each of those questions.

The important bit is the timing. The ticket pool and beacon round are fixed before the beacon publishes its random value.

We begin with a secret

When a competition is created, the platform generates a long random secret.

We do not publish the secret at this point. Instead, we publish its SHA-256 hash. You can think of the hash as a digital fingerprint. It identifies the secret without revealing it.

This is called a commitment.

Once the fingerprint has been published, we cannot swap the secret later without being caught. Any different secret would produce a different fingerprint.

The commitment is also submitted to OpenTimestamps, which anchors it to the Bitcoin blockchain. That gives us independent evidence that the fingerprint existed by a particular point in time.

In less technical terms, we put the secret in a locked box and show everyone the seal before ticket sales begin. After the draw, we open the box. Anyone can check that the seal matches.

It is considerably cheaper than employing a solemn-looking person to guard an actual box.

We freeze the ticket pool

When the competition closes, the platform builds the final draw pool.

Every valid entry is included, whether it came from a paid order or the free postal route. The ticket numbers are sorted, saved as a permanent snapshot and turned into another digital fingerprint called the pool hash.

The draw uses that saved snapshot. It does not return later and ask the live database which tickets happen to be there at the time.

The platform then creates a pool-freeze commitment. This binds together three things:

• The fingerprint of the frozen ticket pool
• The identity of the public randomness network
• The exact future round we are going to use

At that moment, we have fixed both the entries and the source of future randomness.

We still do not have a winner.

We borrow randomness from the future

The next ingredient comes from drand, a public randomness network operated independently of Legion Comps.

Drand publishes a fresh round of randomness every few seconds. Before a round happens, nobody knows what value it will produce. Once it happens, the result is public and can be checked by anyone.

Our platform chooses a round roughly 30 seconds into the future. The ticket pool and target round are fixed before that round's value exists.

When the round arrives, the platform retrieves it from public drand relays. It also checks the round's BLS cryptographic signature against the network's public key before accepting it.

That signature matters. A relay can fail to return a result, but it cannot invent a convincing replacement without the network's private key.

This gives us something we cannot create, predict or secretly reroll: a signed public value from outside Legion Comps.

Then we combine the ingredients

Once the beacon round has arrived, the platform has everything it needs:

• The original draw secret
• The fingerprint of the frozen ticket pool
• The signed randomness from the chosen drand round
• A counter beginning at zero

Those values are combined and passed through SHA-256 to create a very large number.

That number is used to select a position in the frozen ticket list.

There is one small wrinkle. Simply dividing a huge number by the number of tickets and taking the remainder can introduce a tiny mathematical bias when the numbers do not divide evenly.

We use rejection sampling instead. Values in the uneven portion are discarded and the counter moves on until a value fits the fair range.

You can check it without asking us

Every completed automatic draw has a public verification page.

The page publishes the values needed to inspect the result and includes a browser-based check. When you run it, your browser recomputes the fingerprints and winner locally, then fetches the selected drand round from the public relays.

The check does not send the calculation back to Legion Comps for approval. That would rather defeat the point.

For anyone who wants to go further, the page also provides the complete ticket list, downloadable timestamp proofs and a ready-to-run Python reproduction command.

You do not need to understand the code to enter a competition. It is there for customers, developers or determined internet strangers who would like to check our work.

We actively encourage that.

What this proves, and what it does not

Cryptography is useful, but it should not be treated like magic dust.

The published draw commitment lets people confirm that the original secret was not replaced after tickets were sold.

The frozen pool record shows exactly which ticket numbers formed the draw.

The future drand round provides randomness that Legion Comps could not know when the pool and target round were fixed. Its signature confirms that the response really came from the pinned drand network.

The published calculation lets anyone reproduce the winning position.

OpenTimestamps adds independent evidence that a commitment existed before the Bitcoin block that later confirmed it. Bitcoin confirmations take much longer than the few seconds between freezing a pool and receiving the beacon value, so the pool-freeze timestamp alone does not prove that short ordering. That ordering is supported by the published commitment and our audit records, and the verification page says so plainly.

The system does not ask you to believe that software can make every business decision honest. It makes a narrower and more useful promise: the recorded winner follows from the published ticket pool and the published cryptographic inputs, and you can check that claim yourself.

Why build all of this?

We could have selected a random ticket, recorded the winner and moved on.

That would have been much easier to build and considerably easier to explain.

But Legion Comps asks people to trust us with their money and their chance of winning. We think the draw deserves more care than a hidden button in an admin screen.

Fairness should not depend entirely on us saying, "Trust me."

So we publish the evidence.

The result is a system where the ticket pool is fixed, the final randomness comes from outside Legion Comps, the winner cannot be known in advance and the calculation can be repeated afterwards.

It took much longer to build and test than a random-number button.

Most worthwhile things do.