Qubitensor
A daily mining race on two problems used to benchmark quantum algorithms: Max-Cut and the ground state of a small quantum magnet. The contract draws the problems from block randomness and scores every answer itself, with no oracle and no validator.
Case study 03 of 04 · Ethereum mainnet · live since 15 October 2026 · block 26,200,922
- Role
- Design, solver lab, economic model, Solidity, testing, launch and browser miner
- Launched
- 15 October 2026, 22:30 UTCBlock 26,200,922, through Programmable’s Custom Launch
- Contracts
- Seven of mine, all verifiedEtherscan, exact match; plus the platform’s fee vault
- Testing
- 67 Foundry tests on a mainnet forkAll 67 re-run and passing on 20 October 2026
- Stack
- Solidity 0.8.26 (via IR), Foundry, Solady, Uniswap v4, TypeScript
- Hook permissions
- 0x28CC
Weight cut
0of 643
Click a node to move it to the other side.
The answer a miner would reveal, 8 bytes, node x in bit x mod 8 of byte x / 8: 0x
keccak256("qubitensor.demo.0"); when this page was built, all 128 edges and 64 scores were checked against the deployed contract. The best of 24 annealing runs found 570 of 643 (88.6%); a greedy pass from a random start reaches about 81.3%.The project
Qubitensor turns Ethereum into a daily race on two hard problems. Each UTC day anyone can open a round, and the contract derives a fresh Max-Cut graph and a fresh quantum magnet from the block’s randomness. Miners seal a hash of their answer, reveal it after 20:00 UTC, and the contract scores it exactly.
The best three on each problem share a slice of the prize pool, which trading fees fill, and newly mined QBT. Holders can stake behind a miner and share its winnings. When answers get too easy, the problems grow.
The problem
Crypto projects that use the word quantum rarely give anyone a way to check the work. Networks such as Bittensor do reward computation, but the scoring is done by validators off chain. The question here was narrower: can a token pay for work that the chain itself generates and verifies, end to end?
And can it say plainly what the chain cannot know? A contract cannot tell a quantum computer from a laptop, and at the sizes Ethereum can check, classical solvers are expected to win today. Qubitensor records each miner’s self-declared solver type, scores everyone the same way, and lets the public record show if that ever changes.
What I built
- A solver lab and an economic model
Random, greedy and annealing solvers run on the real problem shapes set the rules: an 85% bar for Max-Cut (one greedy pass reaches about 81%; the best of four annealing runs cleared 85% on all 112 graphs tested), a 256-node start where independent solvers stop tying, and payouts of 20% of the prize pool per round split 70, 20 and 10.
- Seven contracts
The token, with its own buy and sell; the hook; the Arena, which runs rounds, seals, reveals, ranking, emission, staking and difficulty; two scorers, Cut and Chem; the launch initializer, Ignition; and the VaultKeeper that holds the liquidity.
- A circuit simulator in Solidity
Chem runs an eight-qubit circuit in fixed-point integers and reads its energy with a quotient that cannot be pushed below the ground state by rounding. It costs 466,355 gas at six qubits and 1,721,623 at eight.
- JavaScript twins of both scorers
Step-for-step copies, tested against the contracts, so a miner knows the exact score before sealing. A starter mining script and a browser miner that seals and reveals from the page build on them.
- 67 tests on a mainnet fork
Including the whole launch through the platform’s real deployment factory and the worst-case settlement, measured under the block gas limit.
- The launch package
A public source repository, compiler settings chosen so the platform’s bytecode scanner reads the contracts correctly, and the launch configuration. Approved on the first submission.
Brand and website
Qubitensor looks like a scientific instrument that runs on a clock: near-black, condensed headlines over monospace data, violet for the problems and red start lights at the 20:00 UTC reveal. The mark, the project summary and the website share one system, from the opening field of particles to a mining page that follows the round’s UTC day.
- Palette
- Night
#050507White#F2F2EEViolet#8B7BFFSignal red#FF4D3DCyan#4FE3FFLime#C2FF73 - Type
- Saira Condensed for headlinesSaira for textJetBrains Mono for data
How it works
- 1Draw
Opening a round seeds it from the block’s prevrandao. The Max-Cut graph has n nodes and 2n weighted edges; the magnet has 6 to 8 qubits with random couplings and fields.
- 2Seal
Until 20:00 UTC, miners file only a hash of their answer and a 0.0003 ETH deposit.
- 3Reveal
From 20:00 to midnight, the Arena scores each revealed answer exactly. Max-Cut counts from 85% of the graph’s weight; chemistry only below the best single bit-string.
- 4Rank
Three places per problem. If two miners reveal the same answer, the older seal keeps the place, so nobody gains by racing to reveal.
- 5Pay
Settling a round pays 20% of the prize pool and mints the day’s QBT, half per problem, 70, 20 and 10 to the three places, shared with their backers.
- 6Adapt
A tie between the two best cuts grows the next graph by 25%; three rounds with nothing at 85% shrink it by 20%. Every 30 productive rounds add a qubit.
Open. Anyone opens the day’s round, once, before 20:00 UTC. The seed is keccak(prevrandao, round, Arena); the Max-Cut graph is drawn from keccak(seed, 0) and the magnet from keccak(seed, 1).
Seal. Miners file a hash of their answer with a 0.0003 ETH deposit. Nothing in a seal shows the answer, and seals are filed per miner, so a hash copied from the mempool blocks nobody.
Reveal. The Arena scores each answer exactly and keeps three places per problem. The deposit comes back whatever the score.
Settle. Anyone settles finished rounds, oldest first, up to 12 per call: 20% of the prize pool and the day’s new QBT, half per problem, split 70, 20 and 10.
Fig. 2. One round, one UTC day. Every step can be taken by anyone; the contract enforces the times.
RY turns one qubit by an angle the miner chooses, a 16-bit number per gate: 30 of them for six qubits, 40 for eight.
Joined dots are CZ gates between neighbouring qubits. RY and CZ keep every amplitude real, so the contract can simulate the state exactly in integers.
Read energy is the Rayleigh quotient <a|H|a> / <a|a> of the state as computed, for the round’s magnet H = sum J_ij Z_i Z_j + sum h_i X_i. It can never fall below the true ground energy, so rounding cannot fake a score.
Fig. 3. The circuit Chem.sol simulates: four layers of RY turns and CZ gates, then a final RY layer, drawn for six qubits.
Fig. 4. Where the 2% levy on every trade’s ETH side goes. The pool’s own 1% LP fee goes to the locked position, and 0.30% to the platform.
The contracts, reviewed
Supply and minting
At most one billion QBT can ever exist. Half was created at launch and placed in the pool. The other half does not exist yet: the Arena mints it round by round to the miners who place and to their backers, 250 million in the first year and half as much each year after. Nothing else can mint.
MAX_SUPPLY = 1_000_000_000 ether; POOL_SUPPLY = 500_000_000 ether goes to the initializer. mint accepts only ARENA and never passes MINED_SUPPLY. emissionOf(round) is FIRST_YEAR / 365 per round, halving every 365 rounds.
Burning
Any holder can burn their own QBT. A quarter of the trading levy buys QBT from the pool and burns it.
burn; QubitHook.buyback() can be called by anyone, once per block, and spends at most 1% of the ETH the pool holds at the current price. burned counts both.
Transfers, buy and sell
A standard ERC-20 with no transfer tax and no blacklist. The Uniswap app cannot route this pool, so the token itself can buy from and sell to the pool, refusing any fill below a minimum the trader sets.
Solady ERC20. buy(minOut) spends msg.value and refunds what the pool leaves; sell(amount, minOut) sells from the caller with no approval needed. Both revert below minOut.
Fees
Every trade pays 2% of its ETH side: 1% to the owner, 0.5% to the prize pool and 0.5% to buyback and burn. There is no launch surcharge. The pool’s 1% liquidity fee goes to the locked position, and 0.30% to the launch platform.
FEE = 20_000 pips, cut from the named ETH before the swap or from the ETH out after it. Shares accrue as ERC-6909 claims; sendOwnerFee(), fundPrizes() and buyback() each pay only where their name says.
uint256 ownerPart = fee / 2;
uint256 prizePart = fee / 4;
ownerShare += ownerPart;
prizeShare += prizePart;
burnShare += fee - ownerPart - prizePart;Prizes and staking
Each round pays 20% of the prize pool and the round’s new QBT. Holders can stake behind a miner from the next round; each miner shares 0% to 20% of its winnings with its backers, and stake lifts its weight by up to 20%, never past the place ahead.
PAYOUT_BPS = 2_000; places split 70/20/10. stake, unstake and claimStake; setBackerShare up to 2,000 bps settles earlier rounds first. BOOST_MAX_BPS = 2_000 in full at 10,000,000 QBT. Products run at 512 bits, so even a 1-wei stake cannot overflow anyone else’s totals.
Commit and reveal
Answers are sealed as hashes until 20:00 UTC, so nobody can copy them. A revealed duplicate goes to whoever sealed first, and an answer that is never revealed leaves its deposit to the prize pool.
sealHash = keccak256(abi.encode(round, subnet, solver, keccak256(answer), salt)), filed per solver. firstSeal[round][keccak(subnet, answer)] keeps the lowest seal number. The deposit is refunded on reveal, or held in dueEth if the miner refuses ETH.
Max-Cut scoring
The graph is regenerated from the seed inside the contract, and the answer, one bit per node, is checked against every edge. The score is exact.
Cut.score(seed, n, side) reads four edges per keccak word: two ends mod n and a weight of 1 to 8. Node 0 must sit on side 0, so an answer and its mirror image are the same. About 320 gas an edge: 172,703 at 256 nodes, 2,648,369 at 4,096.
Circuit scoring
The contract simulates the miner’s circuit on the round’s magnet and measures its energy. An answer counts only if it beats every plain, unentangled configuration.
Chem.score(seed, q, angles): amplitudes in units of 2^-62, rounded down; energy as an integer Rayleigh quotient, final division rounded up, in units of 2^-60. The bar is the lowest diagonal entry, the best single bit-string.
Owner and admin powers
There is no administrator, no pause, no upgrade and no adjustable setting. The owner wallet receives its share of the levy and the locked position’s liquidity fees.
QBT.bind and QubitHook.bindArena run once, from the initializer, in the launch transaction. Ignition.ignite runs once, from the deployment factory. Every setting is a constant.
Liquidity
All 500 million pool QBT went in as one position, minted straight to the VaultKeeper, which can only send that position’s fees to the owner. Before that band landed, the hook refused every other deposit and every trade.
beforeAddLiquidity admits, in the opening block only, one band from MIN_TICK to OPEN_TICK carrying at least BAND_LIQUIDITY; after it, deposits are open to everyone. VaultKeeper.collectFees(tokenId) is the keeper’s only function.
Testing and security
A separate adversarial review found one low-severity issue: a reveal refunded the deposit with a direct transfer, so a miner contract that could not receive ETH was locked out. The refund now falls back to a balance the miner withdraws. Its one informational note, that whoever opens a round picks the block whose randomness seeds it, is stated in the contract: every miner gets the same problems for up to twenty hours, so it buys no head start.
| Operation | Gas |
|---|---|
| Buy 0.1 ETH of QBT | 205,042 |
| Sell part of a holding | 218,337 |
| Open a round | 100,530 |
| Seal an answer | 81,795 |
| Reveal Max-Cut, 256 nodes | 344,530 |
| Reveal Max-Cut, 4,096 nodes | 2,888,063 |
| Reveal chemistry, 6 qubits | 612,336 |
| Reveal chemistry, 8 qubits | 1,866,930 |
| Stake behind a miner | 154,455 |
| Launch transaction on mainnet | 12,334,928 |
Limits, stated plainly
- The chain cannot tell a quantum computer from a laptop. The solver type is the miner’s own word, and at the sizes Ethereum can check, classical solvers are expected to win today.
- One person can enter several different answers. They only push others down where they score higher than every one of those others’ own answers.
- Whoever opens a round chooses the block whose randomness seeds it. That gives no head start, because everyone gets the same problems for up to twenty hours.
- The Uniswap app cannot route this pool. The token’s own buy and sell functions, other routers and bots can.
- Rounds settle only when someone calls settle. A call clears at most twelve rounds, so a backlog can always be cleared in bounded gas.
Status on chain
Read from Ethereum mainnet on 20 October 2026, block 26,234,001
- Four rounds had been opened, one a day since 17 October 2026, with 28 answers sealed in all.
- Each of the three settled rounds placed answers on both problems.
- The graph was still 256 nodes and the circuit 6 qubits: difficulty had not moved.
Contracts
| Contract | Address | Verified source |
|---|---|---|
QBTERC-20 token with buy and sell |
0x0E2D39c62dd3A3BDc05D1d151Ff92fC5C9dF90A7 | Etherscan (opens in a new tab) |
QubitHookUniswap v4 hook |
0xf7EAdEbA2Eba60831ccD95E83802c6857EdB28CC | Etherscan (opens in a new tab) |
ArenaRounds, ranking, emission, staking |
0x4F0fEf54dC12b7F0500311736B4F191a3443EC47 | Etherscan (opens in a new tab) |
CutMax-Cut scorer |
0x72B0612Aeb59B72b2BcF83713514445e0c664f0e | Etherscan (opens in a new tab) |
ChemCircuit simulator and scorer |
0x653C9280B72F2816DC1221a2A7A5021A5F7B0955 | Etherscan (opens in a new tab) |
IgnitionLaunch initializer |
0x123dc730bA027F3032ef0D2467dedd3e54963ae3 | Etherscan (opens in a new tab) |
VaultKeeperLiquidity custody |
0x1320445F7151E191b0e45876687F032b1452C0FA | Etherscan (opens in a new tab) |
Fee vaultPlatform fee, Programmable code |
0x8F8EC8343aB6f3a268cF0016019e9d185Fb40962 | Etherscan (opens in a new tab)Programmable’s unmodified EthereumNativeFeeVaultV3, deployed by the hook. Etherscan shows it as a similar match to the platform’s verified original. |
All seven of mine are verified on Etherscan with an exact match. Compiler: solc 0.8.26, via IR, 1,000 optimizer runs, EVM target Cancun.
Source repository: github.com/Qubitensor/qubitensor-contracts (opens in a new tab)