New to this series? Feel free to check out our previous articles:

Every year, billions of dollars in MEV (Maximal Extractable Value) are siphoned from blockchain users. Although Ethereum and Solana are architected quite differently, their MEV stories have charted a similar path: early spam and bidding wars, the rise of offchain auctions, and now a push toward protocol‑level safeguards. In this post, we trace that shared arc and show how the economics of block production reveal both the inner workings and the future direction of each chain.

MEV represents value that can be captured from transactions beyond base and priority fees. It arises from externalities triggered by transactions, such as adjustments to AMM pool balances or updates to pricing oracles. Block proposers are uniquely positioned to capture MEV due to their exclusive control over transaction inclusion and ordering.

On Ethereum, validators manage transaction ordering within discrete 12-second slots, whereas Solana validators control several consecutive 400-millisecond slots. Within these brief windows, sophisticated actors aggressively reorder, censor, or insert transactions to capture value that otherwise might flow elsewhere.

It's important to note that MEV capture isn't inherently negative; mechanisms like AMMs rely on arbitrage-driven MEV to maintain fair market prices. Nonetheless, from a broader blockchain perspective, MEV extraction can generate a problematic feedback loop: sophisticated validators accumulate more fees, allowing them to purchase greater stake, leading to increased block production opportunities and thus further MEV capture.

Although not an exhaustive list by any measure, we will walk though some common forms of MEV.

Bots identify price discrepancies between DEX liquidity pools or between DEX and CEX prices. When a large trade shifts the price on one venue, searchers race to execute offsetting trades across markets, capturing the price difference as profit. This activity helps synchronize prices across platforms and contributes to overall market efficiency.

DeFi lending protocols rely on liquidations to remain solvent. When collateral value drops below a threshold—often triggered by an oracle update—searchers compete to liquidate the bad positions, earning a liquidation bonus for the service. The race to liquidate first can be extreme, especially during market volatility.

Arguably the most controversial MEV type, sandwich attacks involve placing transactions before and after a large trade. An attacker first buys the asset being purchased to drive up the price, allows a user's transaction to proceed at the inflated price, then sells into that inflated price. Victims effectively pay an invisible tax to the attacker. Some of the most prolific sandwich bots have adopted monikers, with "Jared from Subway" being one of the most well known.

Another well-known and discussed strategy is JIT. This is where searchers provide liquidity to a pool in a block with a high volume of trades, then remove it immediately after. This allows them to capture the lion's share of trading fees without taking on the long-term inventory risk that normal DEX LPs accept. This strategy results in better price execution for traders but reduces fee earnings for traditional LPs.

This encompasses any strategy where searchers detect profitable transactions from other users in the mempool and race to execute them first. This can include copying any transaction that yields a profit. Here is an excellent article on this practice: Escaping the Dark Forest.

As DeFi surged on Ethereum in 2020, attentive developers began to notice exploitable opportunities. Bots actively monitored the mempool for transactions that created value—such as oracle updates triggering liquidations, large AMM trades causing price deviations, or any profitable state changes.

In a naive system where validators ordered transactions solely by gas price, the primary method to capture MEV was to outbid competitors. This practice led to Progressive Gas Auctions (PGAs)—intense bidding wars in which bots continuously increased their bids or spammed the network to ensure optimal transaction placement.

The consequences were detrimental to network usability. During periods of high volatility, these bidding wars consumed significant block space, driving gas prices sharply upward and severely impacting overall network performance. Additionally, failed transactions still incurred gas fees, resulting in a substantial amount of blockspace wasted on unsuccessful transactions.

Flashbots, an R&D organization founded in 2020, introduced a radical solution: moving these auctions offchain. Instead of engaging in gas wars, searchers submitted "bundles"—atomic groups of transactions executed either entirely or not at all—directly to miners through a private relay.

Flashbots' MEV-Geth client, a modified version of Ethereum's Geth client, enabled miners to process these bundles. Crucially, unsuccessful bids remained offchain, eliminating network spam and preventing failed transaction fees. The highest bid prevailed, miners increased their revenue, and ordinary users benefited from lower gas prices.

Within months, MEV-Geth experienced rapid and widespread adoption. By early 2021, most of Ethereum's hashrate ran on Flashbots' software, effectively ending the PGA wars overnight. However, PGAs still occur for long-tail opportunities where searchers prefer not to share their bundles with builders, fearing their strategies might be discovered.

Flashbots' success introduced a troubling reality: they had become a centralized chokepoint for Ethereum block production. As Ethereum approached the Merge, the anticipated surge in block-producing entities highlighted a critical issue. Previously, Flashbots could rely on integrations with a limited number of mining pools, but solo stakers lacked access to this vital infrastructure. Consequently, the centralization flywheel re-emerged as a significant risk, posing an existential threat to Ethereum's decentralization.

The Merge would shift block production responsibilities from sophisticated mining pools to potentially less-experienced home stakers. Without the ability to access MEV-enhanced rewards, these solo stakers risked earning substantially less than validators equipped with advanced setups, potentially accelerating stake centralization.

Flashbots' solution was MEV-Boost, a sidecar designed to democratize access to MEV revenues. Flashbots identified that capturing MEV was fundamentally tied to a validator's monopoly on transaction ordering and sequencing. Less sophisticated validators, unable to fully exploit their monopoly position, could instead benefit by auctioning off their transaction sequencing rights to the market, thereby accurately pricing the true value of their monopoly even if they couldn't directly capture that value themselves. MEV-Boost facilitated this auction process by introducing specialized roles:

This structure enabled any validator, regardless of sophistication, to access MEV revenues.

Currently, ~92% of Ethereum blocks are built through MEV-Boost. Just a few builders dominate the space. Titan, Beaver Build, and Flashbots' BuilderNet together produce roughly 95% of these MEV-Boost blocks.

Initially, superior builder algorithms for optimizing MEV capture through better searching of the combinatorial block construction space drove builders' competitive success.

However, builders soon recognized that whoever sees a transaction first gains an insurmountable advantage—especially if no one else sees it at all—and that the most profitable MEV opportunities emerged from non-toxic order flow. This information asymmetry led to the creation of a complex and lucrative market for private order flow, wherein transactions bypass public mempools entirely. Builders now actively purchase exclusive access to transaction flows from wallets and applications, with some order flow sources reportedly commanding sums in the nine- or even ten-figure range. This payment-for-order-flow market has become the primary arena for builder competition, closely mirroring traditional finance arrangements, such as Citadel’s purchase of retail order flow from platforms like Robinhood.

These order flow arrangements offer applications new monetization avenues. However, open questions remain regarding the implications for end users and how any potential negative effects might be mitigated.

The market has evolved sophisticated auction mechanisms for order flow:

This dynamic has troubling implications. Success in block building increasingly depends not on technical prowess but on business relationships - introducing rent-seeking intermediaries to the transaction supply chain.

TEEs represent a paradigm shift in block building. These secure enclaves run algorithms that produce cryptographic attestations, proving both code executed and output produced. For MEV, this enables "black box" building - verifiable fairness and preventing extraction of encrypted order flow.

Flashbots pioneered production TEE usage with two systems:

Several other protocol-level changes to address MEV are being discussed by the Ethereum Foundation, including running MEV auctions directly in the protocol. For a comprehensive overview of these major proposed changes, watch Jonah's Devcon presentation.

Last year, there was significant discussion in the MEV community about whether a multi-leader architecture would solve MEV. The insight was that MEV arrises from the proposer’s monopoly on block production, and by removing that monopoly, MEV would disappear. Critics argue this view is too idealistic, pointing out that leaderless systems like Hedera still exhibit MEV, albeit with different dynamics. Without a clear leader, these networks often experience spam as searchers race to land transactions first. While multi-proposer solutions are no longer heavily considered in the Ethereum community, they remain active in Solana's development discussions.

While Solana was architected after Ethereum and differs in performance characteristics and execution model, its MEV journey has mirrored Ethereum’s in notable ways. Both ecosystems experienced early chaos from spam and opportunistic extraction, followed by the rise of third-party infrastructure to bring order to MEV markets. Just as Flashbots emerged on Ethereum to address inefficiencies from gas auctions and enable fairer MEV access, Solana's evolution led to Jito—tailored to the network’s unique constraints but solving a similar core problem: how to tame, distribute, and structure MEV. The parallel development paths reveal how MEV is not just a side effect of Ethereum’s design, but a fundamental dynamic across blockchains.

Before the introduction of Jito, Solana suffered from even worse spam issues than Ethereum—largely due to its extremely low transaction fees. With costs several orders of magnitude cheaper than Ethereum, searchers could afford to flood the network with thousands of transactions just to land a single profitable one.

During periods of high volatility, the network often became nearly unusable. Searchers would bombard validators with duplicate transactions, each carrying slightly different fees, in hopes that one would be accepted. Popular NFT mints and major liquidation events frequently triggered massive waves of failed transactions, severely degrading network performance for all users.

Unlike Ethereum, Solana does not have a public mempool by default. Transactions are routed directly to validators via the Transaction Processing Unit (TPU), which makes frontrunning slightly more difficult (we will talk more about transaction processing in future posts). However, this also forced searchers to operate blindly, unable to see competing transactions. As a result, they spammed the network even more aggressively, worsening congestion.

Jito emerged as Solana’s parallel to Flashbots, but with a crucial architectural difference. Rather than building complete blocks, Jito operates as a transaction streaming service that conducts offchain auctions before forwarding winning bundles to validators.

This streaming model is not incidental—it’s a direct response to how Solana’s networking layer is structured. Unlike Ethereum, where validators broadcast a completed block at the end of their slot, Solana validators stream block data as it’s being built, enabling faster propagation and lower latency. In effect, Solana’s block construction resembles a continuous flow of partial confirmations—somewhat analogous to Ethereum’s preconfirmations. (We will talk more about Ethereum and Solana networking in future posts).

As of January 2025, more than 92% of Solana validators (weighted by stake) run the Jito-Solana client. This modified validator client introduces a sophisticated MEV extraction pipeline operating on a per-transaction basis.

Early on, Jito offered a pseudo mempool service that allowed searchers to observe pending transactions before inclusion—effectively recreating the "dark forest." Although sandwich-like usage was against the Terms of Service, the results were predictable: sandwich attacks exploded in frequency. Realizing this, Jito disabled the functionality in March 2024 and is unlikely to enable it again. Despite Jito’s deprecation, multiple operators have been offered to participate in alternative mempools. According to this excellent Helius report, the majority of Solana’s sandwiching originates from a private mempool operated by a single entity DeezNodes.

When transactions arrive at a Jito validator, they first hit the Jito Relayer—a custom Transaction Processing Unit (TPU) proxy that filters, deduplicates, and verifies transactions. It then holds these transactions for 200 milliseconds. This brief pause serves two purposes:

During this window, searchers submit bundles (at most five transactions) with SOL-denominated tips. With a 10,000 lamport minimum tip and 5% fee on all tips going to Jito, only high-value opportunities justify participation.

The Jito Block Engine runs on a separate validator thread, continuously simulating and prioritizing bundles based on fees. It reserves a portion of each block's 60 million compute units exclusively for these MEV transactions.

This creates a fascinating dynamic: Jito essentially operates as both the builder and auctioneer, but in real-time. Unlike Ethereum where builders submit complete blocks, Jito makes transaction-by-transaction decisions, balancing two objectives:

Solana's account-based architecture enables local fee markets (Learn more about Solana's architecture in our previous post). Transactions touching different state don't compete directly—a DEX trade on Orca doesn't compete with an NFT mint on Magic Eden.

Interestingly, many non-MEV transactions use Jito bundles purely for reliability. Since Jito prioritizes bundles, users can bypass standard networking and guarantee inclusion. Bundles also can't include other bundles, providing inherent MEV protection.

Solana's MEV infrastructure continues evolving rapidly. We believe two developments will reshape the landscape:

Agave (Solana's main client) will soon allow validators to customize block-packing logic without forking the client. Jito could become a thin sidecar rather than a full fork, improving maintainability and adoption.

This is a Solana parallel to Flashblocks’ BuilderNet. BAM introduces TEE-based scheduler nodes that privately order transactions and attach cryptographic attestations validators must honor.

BAM's plugin marketplace lets developers upload custom sequencing logic—cancel-replace flows, JIT oracle updates, or application-specific ordering. By keeping order private until execution, BAM could eliminate spam-based MEV strategies while letting applications capture their own MEV.

While Ethereum’s exploration of multi-leader architectures has largely faded, Solana is actively advancing toward a multi-proposer design. Far from theoretical, this model is now part of Solana’s long-term development roadmap, evolving in parallel with major upgrades like the Alpenglow consensus overhaul (more on this in future sections).

At its core, the multi-proposer model addresses the centralization risks of single-leader blockchains, where one validator controls transaction inclusion and ordering during their slot. This monopoly enables censorship and MEV capture. Multi-proposer designs aim to decentralize that power by allowing multiple validators to contribute transactions during the same slot. If one proposer censors a transaction, another can include it—making exclusion far more difficult and increasing overall system fairness.

One of the key mechanisms in this model is merging multiple leaders’ blocks by sorting transactions by descending priority fees. This preserves determinism while enabling expressive application behavior. Developers can now influence transaction sequencing through fee-based logic, making cancel-prioritization and auction-driven ordering practical at the protocol level. This vision aligns with Solana’s broader commitment to Application Controlled Execution (ACE), where smart contracts can define their own transaction ordering models to suit specific market needs.

Crucially, the multi-proposer model also introduces powerful incentives for geographic decentralization. In a system where multiple leaders ingest and propagate data simultaneously, latency becomes an economic differentiator. Validators with physical proximity to key financial centers—such as New York or Tokyo—gain earlier access to market-relevant information and can capitalize on that informational edge. This naturally encourages validators to distribute themselves across the globe rather than co-locating in a few optimized spots, reinforcing Solana’s decentralization and performance goals. For more on this, see Anza’s roadmap on The Internet Capital Markets Roadmap.

MEV reflects fundamental market dynamics rather than technical failures. As long as information asymmetry, latency differences, and ordered state transitions exist, value can be extracted. We’ve witnessed several MEV eras: from PGAs to single builders, multiple builders, and now TEE-based building. Each solution inevitably spawns new forms of MEV. When one technique is defined, searchers develop more subtle extraction methods.

But while MEV is often framed as a cat-and-mouse game between searchers and protocols, it can also be seen as a lens into blockchain design itself. MEV arises not in spite of a chain’s architecture, but because of it. Every choice — from how proposers are selected, to how transactions are ordered, to how blockspace is sold — creates new opportunities for extraction. Studying MEV is, in effect, studying the mechanics of a blockchain in action.

This makes the parallel evolution of Ethereum and Solana all the more telling. Despite their differences, their MEV arcs have followed remarkably similar paths: early spam and bidding wars, the emergence of third-party infrastructure like Flashbots and Jito, and now the push toward protocol-native solutions. Each step reflects an increasing maturity, not just in MEV handling, but in understanding what it means to build sustainable, performant, and fair blockchains.

We hope you enjoyed this post. If we got anything wrong or missed something important, please let us know. Stay tuned for more posts like this one.

Checkout our previous articles in the series as well:

Thanks to @blockchaincap, @cooper_kunz, @0xpiapark, Ilyas Ridhuan at Aztec, and @niallinio for their valuable feedback.