EIP-8099 MEVless protocol
No call decision · Security & privacy · EIP status Draft · created 2025-09-25
A proposal to eliminate MEV attacks such as sandwich attacks at the source, using a two-stage structure: a sequencing block that orders transactions by hash alone while hiding their content, followed by an execution block that executes them in that order.
Why it is needed
An MEV (Maximal Extractable Value) attack is when the party building a block sees transaction content in advance and manipulates ordering to extract profit. Typical examples are sandwich attacks, which insert a buy and sell around a user's transaction, and frontrunning, which executes a similar transaction ahead of the user's. The source points out that, unlike legitimate arbitrage that supplies liquidity, such attacks are purely exploitative, eroding user trust, raising transaction costs, and causing large monetary losses. Existing alternatives also have limits. Encrypted mempools carry heavy encryption and decryption computation overhead, and private mempools are centralized and require trust. Proposer-builder separation (PBS) still lets builders see transaction content and is becoming increasingly centralized. This proposal takes the approach of eliminating the precondition for the attack itself: seeing transaction content at the ordering stage.
What changes
Today
- Validators and builders see transaction content before determining order within a block
- Because the content is visible, sandwich attacks, frontrunning, and backrunning become possible
- Workarounds such as encrypted mempools, private mempools, and PBS carry computational cost or centralization problems
After EIP-8099
- The network commits to an ordering based solely on transaction hashes, prioritizing those with larger prepayment amounts
- Transaction content is revealed only after ordering is finalized, and execution follows the predetermined order
- Content cannot be seen at the ordering stage, so the precondition for sandwich attacks and frontrunning disappears
Who is affected
- Users: The risk of losses from sandwich attacks and frontrunning in DeFi transactions is reduced.
- DeFi developers: With less need to separately design app-level MEV defenses, developers can, as the source puts it, focus on product and user experience.
- Validators and block producers: They can no longer profit from manipulating ordering using transaction content, and random block production is now a required precondition.
- Client teams: A two-stage block structure split between odd and even block heights, along with two new RPC methods, must be implemented.
In depth
A two-stage block structure
Blocks are split into sequencing blocks and execution blocks. A sequencing block is produced at every odd block height; it receives transaction hashes from users, collects the prepayment (gas fee plus optional tip), sorts the hashes in descending order of prepayment, publishes the sort result as a commitment, and stores the hashes in the block. An execution block is produced at every even block height; it verifies that the transaction contents sent by users match the committed hashes and executes them in the predetermined order. The interval between sequencing blocks can be set shorter than that between execution blocks.
Phase 1: Hash submission and prepayment sorting
The user creates a transaction, computes its hash, and sends only the hash to the network. At this point they pay the Base Gas Fee, the fixed cost of storing the hash and computing the sort, together with an Optional Tip that raises sorting priority. The network checks whether the user's balance is sufficient for the prepayment, sorts the transaction hashes in descending order of total prepayment amount, and deducts the prepayment from the account. The sorted transaction order is published as a commitment, and the hashes are stored in the sequencing block.
Phase 2: Content verification, execution, and the gas tax
The user watches for their transaction hash to be committed, then submits the actual transaction contents along with the remaining gas fee. The network receives the contents in the execution block, verifies that they match the committed hash, and executes them in the predetermined order. During execution it deducts the remaining fee and additionally collects 50% of the actual difference between gasUsed and gasLimit as a tax. The source explains that this mechanism prevents setting gasLimit far above actual usage to monopolize the whole block and chase MEV.
Gas economics
Total prepayment is defined as Total Prepayment = Base Gas Fee + Optional Tip. The base gas fee is the fixed cost of storing the hash and computing the sort, while the tip is a variable amount for sorting priority. Cost calculation is also split by phase: the sequencing phase only performs hash operations, so the gas cost is minimal, while the execution phase follows the same standard gas costs as before.
Why random block production is a prerequisite
If block production order is predictable, a block producer can mount a costless speculative MEV attack: submit a transaction hash first, watch other users' transaction contents, and then decide whether to submit their own contents. This works because the prepayment ultimately returns to the block producer themselves, who can recover the cost through block fees. Conversely, if block production is random, the attacker must pay the prepayment without knowing whether they will produce the next block, which turns that cost into an unrecoverable real cost and makes the attack economically unprofitable. The source explains that as the number of validators grows, the probability of being selected individually falls, so the attack cost grows exponentially.
Two new RPC methods
RPC methods are added to support the two-phase block system. eth_sendTxHash submits a transaction hash instead of the full transaction, and eth_getTxSequence returns the committed transaction sort order.
A Draft-stage proposal
This proposal is in Draft status. The specification's details may still change, and no decision has been made on which network upgrade it would be included in. There is also no record yet of a core developer call deciding on fork inclusion.