Every wallet starts as a random number. Software cannot make one: a pseudo-random generator is a formula, and whoever learns its starting state can replay every key it will ever produce. That has already cost real money, more than once.
A flaw in the platform's random number generator let attackers recover the private keys of Bitcoin wallets made on Android.
wallets emptiedA vanity-address tool seeded its keys from 32 bits. Addresses it made were brute-forced, including one that held Wintermute's funds.
about $160M takenA widely used command-line wallet tool seeded its generator from 32 bits of clock time. Every wallet it made could be recomputed.
about $900K takenQuantum measurement is different in kind. The outcome of measuring a photon is not hidden in any earlier state, so there is nothing to learn and nothing to replay. VOID takes those measurements and puts them where Web3 can use them.
You should not need a physics lab to use quantum randomness. VOID is Quantum-as-a-Service: the hardware sits behind the node, and you call it over HTTP. No key, no account, no SDK required.
A signed, chained round every 10 seconds that anyone can recompute.
GET /api/beacon/latest
Up to 1,024 bytes nobody else receives, with a signed receipt.
GET /api/entropy
Device output with no processing. Each byte is served once.
GET /api/quantum
Numbers and shuffles from a round and a seed you choose.
GET /api/draw
Build a circuit, then measure it with quantum randomness.
POST /api/sim
Wallets and post-quantum keys made in your browser.
/forge
Raw bytes come from an ID Quantique Quantis device, a quantum random number generator that measures single photons.
Quantum bytes wait in a reservoir. A byte leaves it once, into one beacon round or one API response, and is never served again.
Everything the node receives is hashed into 64 bytes of secret state with SHA3-512. A weak input can only add to it.
Every 10 seconds the node publishes a round: its inputs, a 512-bit output, a signature and a link to the round before.
The node commits to its own contribution a round early, then mixes in NIST and drand values it could not have known.
Dice, lotteries and shuffles are computed from a round and a seed you choose. Anyone can recompute the result.
Wallets are made in your browser from node entropy mixed with your device's own. The node never sees the result.
A beacon round publishes everything that went into it, so the output is a calculation you can repeat. The panel shows the latest round from the running node, and the check runs in this page.
The quantum source returns raw bytes over HTTPS. The node runs frequency, runs, chi-square and correlation tests on what arrives and shows the results in the console.
Each round carries the hash of the value the node will contribute to the round after it. Once that hash is public, the node cannot swap the value for a luckier one.
32 fresh quantum bytes, the committed node value, the latest NIST Randomness Beacon pulse and the latest drand round are hashed together with the previous output using SHA3-512.
The node signs the round with its ed25519 key, and each round names the output of the one before it, so history cannot be rewritten without breaking every later round.
Name a future round and a seed before it exists, then draw from it once it does. Neither you nor the node could have known the result, and everyone can recompute it.
Most on-chain randomness is one of two things. Here is how each compares with a quantum-seeded public beacon on the question that matters: could someone have known the number first?
These figures come from the node serving this page and refresh as rounds are produced.
Signed, chained rounds published, one every 10 seconds.
Raw bytes pulled from the photonic source since this node started counting.
Shannon estimate on the latest quantum sample. A perfect source scores close to 8.
A quantum byte leaves the reservoir once. No response ever repeats another.
The node. Quantum-seeded pool, public beacon, entropy and draw APIs, raw quantum bytes, the circuit simulator, the console and the Key Forge.
$VOID. The token launches on Solana and carries the protocol forward.
On-chain feed. Beacon rounds posted to a Solana program, so other programs can read a round and check its signature themselves.
More sources, more nodes. A second quantum device on a different physical principle, and independent operators whose rounds are combined.
SDKs. Small client libraries for JavaScript, Python and Rust that fetch, verify and draw in one call.
It means the quantum hardware is somebody else's problem and the result is an HTTP call. The node holds the connection to the device, tests what comes out of it, and exposes six services: a public beacon, private entropy, raw quantum bytes, provably fair draws, a circuit simulator and the Key Forge. Any app, on any chain or none, can call it today without a key or an account, and every response says how many fresh quantum bytes went into it.
The raw bytes come from an ID Quantique Quantis quantum random number generator operated by the Laboratory for Digitalisation at OTH Regensburg, which serves them over a public API. The device measures single photons. The console shows every pull from it, the byte counts and the statistical tests the node runs on what arrives. Each beacon round states how many quantum bytes it contains and prints them.
Because a good design does not depend on one party. A quantum source proves the bytes were unpredictable when measured; it does not prove the operator relayed them honestly. The node commits to its own value one round early, then mixes in the NIST Randomness Beacon and drand, which are public, signed and outside its control. The output is unpredictable as long as any one input is.
Anything that needs a number nobody could know in advance: raffles and airdrop draws, game loot and matchmaking, validator or committee selection, shuffled mints, tie-breaks. Commit to a future round and a seed, wait for the round, call the draw endpoint, and publish the round number so anyone can recompute it. For secrets such as keys and nonces, use the entropy endpoint, which returns bytes no one else receives.
It runs quantum circuits exactly. You place gates on up to 12 qubits, and the page computes every amplitude and the probability of each outcome. Measuring is the one random step in quantum mechanics, and that step is handed to the node, which draws every shot from quantum entropy and signs the counts. The page then re-derives the same counts from the sampling key, so nothing is taken on trust. It ships with Bell pairs, GHZ states, Grover search and the quantum Fourier transform ready to run.
No. The Forge asks the node for 64 bytes, then hashes them together with 64 bytes from your own device before deriving anything. The node knows only its half. The recovery phrase, the Ethereum and Solana addresses and the post-quantum key pairs are computed in your browser and never sent anywhere. The node signs a receipt for the bytes it gave you, which you can check.
The Forge also derives an ML-DSA-65 signing key pair and an ML-KEM-768 key pair, the lattice schemes NIST standardised as FIPS 204 and FIPS 203. Chains do not accept them for transactions yet. They are for applications that want quantum-resistant signatures or key exchange today, such as signed messages, encrypted backups and off-chain identity.
$VOID is the token of the protocol. It funds the node, the sources and the work on the roadmap: the on-chain feed, additional quantum devices and independent operators. The API is open to use while the network is one node.
Protocol rules, API and FAQ in the docs.