Every day holders choose one of three entanglement experiments, an IBM quantum computer runs it, and the result, locked on Solana before anyone can know it, picks one holder to receive 30% of the day's creator fees.
Results marked real were measured on IBM quantum hardware on 10 Oct 2026. Everything else (past days, holders, votes, buybacks) is example data until the first draw. Times and drand round numbers use your clock.
Holders vote in the morning, the quantum computer runs in the evening, and ten minutes before 18:00 UTC the result picks one holder. Point at any event to see what happens.
Each experiment is a different test that no classical system can pass. The draw works the same whichever runs; what changes is the physics measured, the proof published that day and the look of the winner's certificate. All three already ran on real IBM hardware.
Results marked real were measured on IBM quantum hardware on 10 Oct 2026. Vote with your wallet on each card: a free signature, no transaction. Voting for a draw closes at 12:00 UTC; the final count at 17:50 UTC is weighted by the tokens each wallet holds, and with no votes the three experiments take turns.
Two neighbouring qubits on the processor's lattice. A Hadamard puts the first in superposition, a CNOT entangles the second with it. Each qubit is then measured at an angle picked at random, thousands of times. The joint counts give the Bell value S, and the raw outcomes, sealed with a drand round, become the day's number on Solana.
H on q₀, then CNOT q₀→q₁: the pair is now in the Bell state |Φ⁺⟩.
q₀ is read at 0° or 90°, q₁ at 45° or −45° on the Bloch sphere: the CHSH settings.
Resonators read each qubit as 0 or 1. Thousands of shots build the joint counts.
Counts give S. The outcomes are hashed with a future drand round and written to the Solana oracle.
Stylised processor view. Real runs use IBM's native gates (the CNOT is compiled from them) and the backend available that day, for example a Heron-class chip.
For two qubits in |Φ⁺⟩ measured at angles θ₀ and θ₁, the correlation is cos(θ₀ − θ₁). Any classical model stays on or inside the straight line. At the CHSH angles the gap adds up to S = 2√2 ≈ 2.83 in theory; real hardware lands lower because of noise, and anything above 2 shows quantum entanglement.
Bars: live illustrative counts with about 6% hardware noise (sample S 2.64). The value on the right and the points on the curve were measured on IBM hardware.
The rule is fixed before the qubits are measured. Neither the qubits nor the drand round can be chosen by us, so the winner can't be either. Prizes come from creator fees.
Every day one 1/1 NFT is minted on Solana from that day's record and sent to the winner. Its artwork is drawn from the counts measured on the chip, so each experiment, and each day, looks different. The three certificates below come from real runs, one per experiment.
Each day's job becomes an account on Solana: the backend, the job id, the raw counts, the measured S, the drand round that sealed it and the final value. Any program can read it.
The same Bell test runs on every IBM processor we can reach. The daily S per chip shows how clean each machine's entanglement is, and over months it tracks how fast quantum hardware is improving.
History starts today and is posted daily on X with the chart.
20% of every creator fee goes to the buyback wallet, and it buys the token back once a day. When it happens is decided round by round: after the draw, every new drand round is hashed with the day's quantum value, and the buyback fires on the first round that falls under a fixed threshold.
Every input is published. Recompute the value from the raw counts and the drand round, compare it with the oracle, then recompute the winner from the snapshot.
// 1. the day's published run: backend, job id, raw outcomes in shot order const run = await fetch("/runs/2026-10-10.json").then(r => r.json()) const raw = run.settings.map(k => k + ":" + run.raw_outcomes[k].join("")).join(";") // settings order, not object key order // 2. the commit stored on Solana BEFORE the drand round existed must match the raw outcomes const rec = await oracle.account.dailyRecord.fetch(recordPda(run.day)) assert(hex(sha256(raw)) === hex(rec.commit)) // 3. the drand quicknet round that sealed it (nobody controls drand) const QUICKNET = "52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971" const beacon = await fetch(`https://api.drand.sh/${QUICKNET}/public/${rec.drandRound}`).then(r => r.json()) // 4. value = SHA-256(raw outcomes ‖ drand randomness bytes), must match the oracle assert(hex(sha256(concat(utf8(raw), fromHex(beacon.randomness)))) === hex(rec.value)) // 5. the winner from the published snapshot (rejection sampling keeps every entry equal) const winner = pickUniform(rec.value, snapshot.holders)
Most quantum coins borrow the word. Here two qubits are entangled on real hardware every day, the Bell value is measured and published, and the result is sealed so nobody can pick it.
| Server random | One-off quantum number | Entanglement | |
|---|---|---|---|
| Source | Software | A single quantum job | Daily Bell test on IBM quantum hardware |
| Proof of quantum | None | None | Measured S above 2, published each day |
| Can the team pick it? | Yes | Could rerun until it likes the result | No: sealed with a drand round fixed in advance |
| On Solana | No | One-off at best | Every day, as an oracle any program can read |
The oracle is open: any Solana program can read the daily record or request its own random number from the day's quantum entropy pool. Lotteries, NFT reveals, whitelists, tournaments and DAOs get a number that nobody, including us, can choose.
Two ways to use it: read the daily value (free, one number per day), or request a fresh number from the pool (many per day, each sealed with its own future drand round).
One PDA per day, seeds ["record", day], where day is days since 1970-01-01 as u32 little-endian.
| Field | Type | Meaning |
|---|---|---|
| experiment | u8 | 0 CHSH, 1 Mermin GHZ, 2 sweep (the holders' choice) |
| backend · job_id | [u8;16] · [u8;20] | IBM processor and job |
| shots | u32 | total shots across settings |
| stat_milli | i32 | Bell statistic × 1000 (S, M or V) |
| commit | [u8;32] | SHA-256 of the raw outcomes, written before the seal |
| drand_round · drand_randomness | u64 · [u8;32] | the quicknet round that sealed the day |
| value | [u8;32] | SHA-256(outcomes ‖ drand), the day's number |
| pool_root · pool_chunks | [u8;32] · u32 | Merkle root of the entropy pool and its size |
| status | u8 | Announced → Committed → Sealed |
// TypeScript (Anchor client) const [pda] = PublicKey.findProgramAddressSync([Buffer.from("record"), u32le(day)], ORACLE_ID) const rec = await oracle.account.dailyRecord.fetch(pda) if (rec.status.sealed) use(rec.value) // Rust, inside your program let rec = DailyRecord::try_deserialize(&mut &ctx.accounts.record.data.borrow()[..])?; require!(rec.status == Status::Sealed, MyError::NotSealedYet); let i = uniform(&rec.value, entries); // rejection sampling, no modulo bias
request_randomness(seed). A Request PDA stores your seed, the next unused pool chunk and a target drand round about 6 seconds in the future.result = SHA-256(chunk ‖ drand ‖ seed).result.let req = request_randomness(CpiContext::new(oracle, accounts), my_seed)?; // … later, once status == Fulfilled let r: [u8; 32] = ctx.accounts.request.result;
Each chunk is used once. The chunk was fixed when the pool was committed, the drand round did not exist when you asked, and your seed separates you from everyone else.
Commit the entry list (Merkle root) before requesting. Winner = uniform(result, entries). Several winners: hash-chain the result.
Store a request at mint; at reveal, traits = f(result, token index). Nobody, the creator included, knows the traits at mint time.
Pick k of n with a Fisher–Yates shuffle seeded by the result. Publish the list and the proof with it.
Brackets, seeding, map picks and tie-breaks, one request per round so nothing is known in advance.
Draw a council or jury from token holders: one per wallet or weighted by balance, from a snapshot committed before the request.
Loot, dice and card shuffles for turn-based games. Fulfilment takes seconds, so it does not fit real-time action.
commit. The commit transaction must be older than the drand round and the first commit of that day in the oracle wallet's history.value. For pool requests, check the chunk's Merkle proof and SHA-256(chunk ‖ drand ‖ seed).stat_milli; the IBM job id is published too.node oracle.mjs verify-draw draw.json --oracle <address>, no key needed.Plain answers about what this is and what it is not.
From two qubits entangled and measured on an IBM quantum processor through the public IBM Quantum Platform, combined with a public drand round. We are not affiliated with IBM.
No. It runs on one chip, so it shows quantum correlations (S above 2) but does not close the loopholes of a lab experiment with distant stations. The drand seal is what stops anyone, us included, from choosing the result.
The value is sealed by the first drand round after the commit, which nobody can know in advance, and it changes the final value completely. Rerunning the quantum job can't predict or steer it. The hash of the raw outcomes is committed on Solana before that drand round exists, and only the first commit of the day signed by the oracle wallet counts. Its full history is public, so a second attempt would show.
Yes. The daily record is a public Solana account any program can read, and the entropy pool serves on-demand requests. See the Docs section. The API is a draft until the program is deployed.
No. It depends on drand rounds that don't exist yet, hashed with the day's value. Once a round is out everyone can see whether it fired at the same moment we do.
Which experiment runs tomorrow: the CHSH test on two qubits, the Mermin test on a three-qubit GHZ state, or a sweep that draws the correlation curve. The draw works the same way whatever wins.
No. The randomness comes from a quantum processor. The token, the wallets and Solana use ordinary cryptography.
From pump.fun's creator fee sharing: pump.fun pays every creator fee directly in three parts: 30% to the prize vault, 20% to the buyback wallet, 50% to the team. The split is set once and the team's right to edit it is revoked on chain, so we can never lower it (pump.fun keeps its own community-takeover process). The vault is an address of the Entanglement program: only the program can pay out of it, and only to the winner it computes.
No. Holding the token above the minimum balance is the only entry, and your odds are proportional to how many tokens you hold. Spreading them over several wallets gives exactly the same odds. Prizes come from creator fees and depend on trading volume, so they can be small.
No. Memecoins can lose all their value. Only use money you can afford to lose.