How we run our draws

This page sets out exactly how Jambala selects winners for our prize draws. We use a process that produces verifiably random and auditable results — anyone with internet access can re-run our algorithm and confirm that we did not influence the outcome. This satisfies the alternative path in Clause 2.2 of the DCMS Voluntary Code of Good Practice for Prize Draw Operators, without depending on any commercial vendor.

The mechanism in plain English

1. Each competition has a scheduled draw time published in advance on the product page.
2. After that time has passed, we take the cryptographic hash of the first Bitcoin block mined after the scheduled draw time. Bitcoin block hashes are produced by a worldwide network through proof-of-work; they are random, public, and impossible for anyone — including us — to predict or manipulate in advance.
3. We feed the block hash into a published algorithm, alongside the product identifier and the total number of tickets sold. The algorithm computes a single winning ticket number.
4. We publish the inputs (block hash, block height, product details, ticket count) and the output (winning ticket number) for every draw.
5. Anyone can independently verify the result by looking up the same block on any Bitcoin block explorer and re-running our algorithm.

The algorithm, exactly

Inputs:
  block_hash       (64-character hexadecimal string from Bitcoin)
  product_id       (Jambala's internal product GID, e.g. gid://shopify/Product/123)
  total_tickets    (positive integer)

Steps:
  1. input  = block_hash + "|" + product_id + "|" + total_tickets
  2. h      = SHA-256(input), treated as a 256-bit hex integer
  3. index  = h modulo total_tickets             (0 .. total_tickets-1)
  4. winning_ticket_number = index + 1           (tickets are 1-indexed)

Worked example

Suppose:

• block_hash = 000000000000000000022d6195ee05a07921c7d3a4d1a7d6c4f8d3b9a2c5f1e7
• product_id = demo-product
• total_tickets = 750

Then:

• input = 000000000000000000022d6195ee05a07921c7d3a4d1a7d6c4f8d3b9a2c5f1e7|demo-product|750
• SHA-256(input) = a specific 64-character hex value (any SHA-256 implementation produces the same one)
• index = that hex value, interpreted as a number, modulo 750
• winning_ticket_number = index + 1

You can reproduce this in any programming language, in any spreadsheet with a SHA-256 add-on, or with the standard shasum -a 256 command on macOS / sha256sum on Linux.

How to verify any of our real draws

For every draw we publish (after May 20, 2026) on the Winners page, the underlying record contains:

• Product identifier
• Announced draw time
• Bitcoin block height + block hash used as the seed
• Link to that block on a public block explorer
• The exact algorithm input string
• The SHA-256 hash of the input
• The winning ticket number

To verify any draw:

1. Open the block explorer link, or any other Bitcoin explorer (such as mempool.space, blockstream.info, or blockchain.com), and look up the published block height.
2. Confirm the block’s hash matches the value we published.
3. Confirm the block’s timestamp is after the announced draw time.
4. Take that block hash, the product identifier, and the total tickets, and run them through SHA-256 (separated by “|” as shown above).
5. Take the resulting hex value as a number, modulo the total tickets. Add 1.
6. The result is the winning ticket number. It must match what we published.

Why this is fair

• We don’t choose the seed. Bitcoin block hashes are produced by an open global network of miners. The hash of a future block cannot be predicted; it is only known once the block is mined.
• We don’t choose when the seed is locked in. The seed is whichever block first appears after the publicly-announced draw time. The draw time is published in advance on each competition page.
• The algorithm is published and deterministic. Given the same three inputs, anyone produces the same output. There is no “random number generator” sitting on a Jambala server that we control.
• Free postal entries and paid online entries occupy the same ticket pool with the same allocation rules. Both routes have an equal chance of winning each prize.

What about Live Draws?

For competitions categorised as Live Draws, the draw itself is conducted publicly during a livestream — a member of our team selects the winning ticket number using a physical or digital randomiser, on camera. The livestream recording is the public audit. The recording is published alongside the winner on the Winners page.

Why Bitcoin, and not a random number service?

We chose to use the Bitcoin blockchain as our source of randomness because:

• It is genuinely random (the proof-of-work process produces uniformly distributed hashes).
• It is publicly verifiable by anyone with internet access — no Jambala account or vendor account required.
• It does not depend on a commercial service that could shut down, change terms, or be influenced by us.
• The mechanism is straightforward to explain and to reproduce by hand.

If at some future point Bitcoin became unavailable as a source, we would migrate to another public, verifiable source (for example: the NIST Randomness Beacon, drand, or the UK National Lottery published results) and document the change here. The principle — that the seed is independent of Jambala and publicly verifiable — would remain.

Questions

If anything on this page is unclear, or you would like help verifying a specific past draw, email hello@jambala.co.uk.

Last updated: 21 May 2026.