Refinery is a quantum-assisted transaction ordering protocol that eliminates MEV, enforces on-chain fairness, and maximizes block execution efficiency β all without trusted sequencers.
Every block on every chain today is ordered using heuristics β greedy, local, adversarial. Refinery replaces that with a formally specified global optimization problem solved by quantum-assisted computation.
Crude oil goes in β messy, unordered, full of impurities. Refined product comes out β pure, optimally processed, maximum value extracted cleanly. Refinery does the same for your mempool. Raw, unordered transactions go in. An optimally sequenced, MEV-free block comes out. The "impurities" β sandwich attacks, front-running, arbitrary reordering β are removed at the protocol level.
Fairness is no longer a social norm enforced by reputation. It's a hard mathematical constraint in the objective function. If an ordering violates it, the optimizer rejects it. No exceptions, no overrides.
The quantum solver searches combinatorial ordering space exponentially faster than classical methods. But the chain never trusts the solver β every output is verified deterministically before inclusion.
Refinery introduces zero new trusted parties. No sequencer, no committee, no oracle. If the quantum solver is offline or wrong, validators fall back to canonical deterministic ordering. Liveness guaranteed.
Refinery is a block production layer upgrade β not a new chain. Existing validators, existing smart contracts, and existing users all benefit without any changes to their current setup.
This is a simulated block of 8 transactions. The left shows what a standard validator would produce. The right shows what Refinery produces. Hit Run to replay.
Refinery separates fairness specification from solution search. The protocol defines the objective β the optimizer finds it.
Validators collect a full mempool batch. Execution dependencies, state reads/writes, and resource usage are encoded into a formal constraint model.
The ordering problem is formulated as QUBO and submitted to a quantum or hybrid quantum-classical optimizer. The solver searches the combinatorial space for a globally optimal sequence.
Every optimizer output is verified deterministically. Validity, constraint satisfaction, and state transition correctness are checked. The chain never trusts β only verifies.
Verified orderings are committed to the block. If verification fails or the solver times out, validators fall back to a canonical deterministic rule. Liveness is always guaranteed.
The optimizer doesn't decide what "optimal" means β the protocol does. Every goal, constraint, and tradeoff is encoded in the objective function before the solver ever runs.
The ordering problem is reduced to QUBO (Quadratic Unconstrained Binary Optimization) β compatible with D-Wave quantum annealers, IBM Quantum gate-based QPUs, IonQ, and QAOA hybrid solvers. Refinery is solver-agnostic.
Consensus never depends on the quantum solver being correct. Every ordering is independently verified by classical validators before inclusion. The quantum layer only provides search efficiency β not authority.
Whether you run quantum hardware or a standard validator, Refinery has an integration path for you.
Run the full Refinery optimization stack with your quantum hardware. Earn additional rewards for producing verifiably optimal block orderings.
No quantum hardware required. Run the Refinery verification layer and earn standard rewards. Your node verifies quantum-submitted orderings from other validators.
Build on top of Refinery's ordering guarantees. Access the fairness proofs, MEV reports, and block metadata via the Refinery RPC extension.
Refinery is an open research proposal. Contribute to the QUBO encoding spec, objective function design, or quantum solver benchmarks.
Refinery ships in four phases β from open spec to mainnet deployment.
We propose a transaction ordering framework in which block construction is formulated as a constrained global optimization problem and solved via quantum-assisted computation. Rather than applying heuristic or first-come-first-served sequencing, validators collect a batch of candidate transactions for each block and encode ordering, execution dependencies, and state transitions into a formal optimization model.
The objective function captures protocol-defined goals such as fairness, maximal execution efficiency, minimal slippage, reduced extractable value (MEV), and adherence to risk and resource constraints. A quantum or hybrid quantum-classical optimizer is then used to compute a candidate ordering and execution plan that maximizes this objective under strict validity constraints.
Current block production is an adversarial, local, heuristic process. Validators and block builders optimize for their own extractable value β not for the protocol's users. This results in billions of dollars of MEV extracted annually, arbitrary fairness violations, and systemic capital inefficiency.
To preserve determinism and consensus safety, all optimization outputs are verified by a classical deterministic validator, ensuring that resulting state transitions are valid, constraints are satisfied, and outcomes are reproducible. The protocol separates fairness specification (encoded in constraints and objective) from solution search (performed by the optimizer), preventing arbitrary or opaque decision-making.
In the event of solver failure or disagreement, validators fall back to a canonical deterministic ordering rule, guaranteeing liveness regardless of quantum hardware availability or solver correctness.
This design transforms block production from a local, adversarial ordering problem into a globally optimized batch execution process. By leveraging quantum-assisted search for combinatorial optimization, the system aims to reduce MEV, improve capital efficiency, and enforce formally defined fairness policies, while maintaining verifiability, consensus compatibility, and robustness under heterogeneous validator capabilities.
Refinery is a block production layer upgrade. Existing smart contracts, wallets, and applications require no changes. Validators that do not run Refinery continue to participate in consensus via the classical fallback path. The upgrade is non-breaking and can be rolled out progressively across the validator set.
Refinery Protocol is entirely funded, governed, and powered by one meme coin β $Refinery. No VCs. No foundation grants. No seed rounds. Just a community that believes the mempool deserves better.
Validators stake $Refinery to participate in the optimization network. The more $Refinery staked, the more optimization power you contribute β and the more rewards you earn from MEV-free blocks.
$Refinery holders vote on the parameters of the fairness constraints β slippage limits, MEV thresholds, fairness floor values. The community decides what "optimal" means. Not a foundation, not VCs.
A portion of every block fee goes into the Refinery treasury, denominated in $Refinery. The community votes on how to deploy it β quantum hardware grants, audits, dev bounties, integrations.
Every time Refinery saves a user from a sandwich attack, a small amount of $Refinery is burned. The more MEV the protocol eliminates, the more the supply shrinks. Usage = burn = value.
No team allocation. No investor unlocks. No vesting cliffs. Just vibes and quantum physics.
Flashbots raised $60M from a16z. Jito raised $10M from Multicoin. Both are still controlled by the people who took that money.
$Refinery raised $0 from nobody. The protocol is open source. The treasury is on-chain. The governance is token-weighted. If Refinery wins, the community wins β not a cap table.
MEV is a multi-billion dollar problem. We're solving it with a meme coin, a quantum computer, and the collective rage of every retail trader who's ever been sandwiched.
That's the Refinery thesis.
Refinery is open research, open source, and powered by one meme coin. Read the spec. Buy the coin. Help build the future of block production.