Maximal Extractable Value (MEV) on Ethereum, Solana, Bitcoin and Beyond

April 15, 2025•defi

Maximal Extractable Value (MEV) is a term that has grown from an obscure academic concept into a major industry within blockchain. If you've traded on a DEX or used DeFi on Ethereum or other chains, you've likely been touched by MEV (for better or worse). MEV refers to the extra value that block producers (miners, validators, or sequencers) can extract by reordering, inserting, or censoring transactions in a block beyond the standard block rewards and gas fees. In simpler terms, MEV is the profit someone can make by having the power to decide which transactions go into a block and in what order. This post will dive into what MEV is, how it evolved from simple opportunistic trades into a complex ecosystem of "searchers" and protocols, and how it manifests on different chains like Ethereum (and other EVM chains), Solana, and even Bitcoin. We'll also cover how newcomers can start experimenting with MEV, some notorious MEV strategies (sandwich attacks, backrunning, etc.), and the latest research (like Proposer-Builder Separation, SUAVE, order-flow auctions, and more). Throughout, we'll keep it casual but technical enough for a crypto-native reader, with plenty of headings, examples, and even some diagram suggestions to illustrate key points.

What is MEV? A Quick Primer

MEV (Maximal Extractable Value, formerly "Miner Extractable Value") is the extra value a block producer can capture by controlling transaction inclusion and ordering within a block. It's easiest to understand with an example:

Imagine Alice submits a transaction to buy a large amount of a token on a decentralized exchange. This trade will likely move the token's price up. Now Bob, who comes right after, has a transaction to sell that token. If Bob's sell happens after Alice's buy, Bob will get a better price (because Alice's buy pumped the price). A malicious block producer (like a miner or validator) or an external trader could exploit this sequence for profit. For instance, a block producer could see Alice's intent to buy and insert their own transactions around it: they could buy before Alice (frontrunning) and then sell right after Alice but before Bob (backrunning), effectively "sandwiching" Alice's trade and capturing the price difference as profit. Alice ends up paying more, Bob sells for less, and the attacker pockets the difference. This profit from clever reordering is MEV.

Figure: A simplified illustration of a sandwich attack, a form of MEV. The block producer inserts a buy order before Alice's large buy (frontrunning her) and a sell order right after her trade but before Bob's sell (backrunning), effectively capturing a risk-free profit at Alice and Bob's expense.

In general, any opportunity to extract value by controlling transaction order or inclusion is MEV. This can range from arbitrage between DEXs, to liquidating an under-collateralized loan on a lending protocol, to front-running NFT mints, etc. If a block producer (or someone colluding with them) can identify such an opportunity in pending transactions or the current state and capitalize on it by reordering or adding transactions, that's MEV. Originally the term was Miner Extractable Value – coined in the context of Ethereum – since miners in Proof-of-Work could capture these profits. After Ethereum's transition to Proof-of-Stake, it's often called Maximal Extractable Value to include validators and any block producer role on other chains.

MEV can have negative effects on users and the network. Users might receive worse prices on trades (as in a sandwich attack) or see their transactions mysteriously fail or get delayed because a bot beat them to it. From a network perspective, unchecked MEV has led to congestion and high fees in the past (multiple bots fighting to grab the same opportunity) and poses centralization risks – only those with sophisticated infrastructure could capture MEV, which could concentrate power among miners/validators. On the other hand, some MEV can be seen as "strategic arbitrage" that actually helps keep prices in sync across exchanges or ensures loans get liquidated, etc. We'll discuss "toxic" vs "benign" MEV later. First, let's take a tour through the history of MEV and how we got to the current landscape.

From Simple Arbitrage to Searcher Ecosystems: A Brief History of MEV

MEV has been around as long as block production has – the possibility for miners to reorder transactions was always there. But MEV remained a niche concept in the early days of Bitcoin and Ethereum when most transactions were simple. It really caught the community's attention with the explosion of decentralized finance (DeFi) on Ethereum around 2018-2020, which created juicy opportunities (arbitrage, liquidation, etc.) that could be exploited by reordering transactions.

The First Era: Priority Gas Auctions (PGA Wars)

In the early DeFi days on Ethereum, when an arbitrage or profitable trade was up for grabs, independent bots (we call them searchers now) would simply compete in the public mempool by upping the gas price of their transactions to bribe the miner. This was the Priority Gas Auction (PGA) era – effectively a bidding war where bots try to outbid each other's gas fees to get mined first. For example, if there's an arbitrage worth 0.1 ETH, two bots might start spamming ever-higher gas fees (0.05 ETH, 0.07 ETH, 0.09 ETH in fees…) until capturing the arbitrage is no longer profitable. The highest bidder's transaction gets in and makes the profit, while the losing bidders might still get included (wasting gas) or dropped. This was a very inefficient "mechanism" – it drove up gas prices for everyone and even the "winner" often paid most of the profit out as a fee to the miner. The Ethereum network around 2020 saw hundreds of bots clashing in PGA wars, bloating blocks with failed transactions and huge gas premiums.

Figure: The PGA Gas War Era – multiple bots bid up transaction fees to capture a fixed arbitrage (0.1 ETH in this illustration). One bot wins (pays 0.09 ETH fee to capture 0.1 ETH profit, net ~0.01), the others lose and may still pay some fees. These frenetic bidding wars (happening within each 13s block interval) were wasteful and drove network fees higher.

This era highlighted the need for a more efficient and less wasteful approach to MEV. Enter Flashbots.

The Flashbots Era: Private MEV Auctions

In late 2020, a research collective called Flashbots formed to tackle the chaos of PGA wars. The idea was to bring these auctions off-chain into a more controlled environment, reducing the public gas bidding madness. Flashbots introduced a modified Ethereum client called MEV-Geth and a private relay network called the MEV-Relay. With these tools, the game changed:

Searchers could package their transactions into bundles (a set of one or more transactions, often with the searcher's own tx plus the victim or target tx) and submit these bundles directly to miners via a private channel (the relay), instead of the public mempool.
These bundles include a payment (bribe) to the miner – typically by setting a high gas price or direct payment in the bundle – but crucially, only the winning bundle pays the bribe. Competing searchers no longer have to all spend gas on-chain.
Miners running MEV-Geth would receive bundles from the Flashbots relay alongside normal mempool transactions. They could then compare and choose the most profitable combination of transactions (including any MEV bundles) to mine. Essentially, miners got access to an auction of block orderings: searchers bidding via bundles for the right to capture an MEV opportunity.
Because this system was out-of-band, the crazy public bidding wars subsided. By 2021, Flashbots' system was widely adopted – at one point ~90% of Ethereum hashrate was running Flashbots' MEV-Geth, meaning most miners were listening to these bundles.

Flashbots turned a once completely permissionless free-for-all into a somewhat more structured MEV marketplace. It also introduced some transparency: Flashbots started releasing data on MEV and publishing research on its effects. Importantly, this didn't eliminate MEV—bots still battled to win arbitrages—but it made the process more gas-efficient and arguably reduced network congestion. It also formalized roles like searchers (expert bot operators) distinct from miners and normal users.

During this era, other private relay or MEV solutions also popped up. For example, Eden Network launched with its own approach to ordering (they required staking a token to get priority in blocks), and infrastructure providers like bloXroute offered "private transaction" services. But Flashbots remained the dominant player by far, and "Flashbots bundle" became synonymous with MEV extraction on Ethereum.

MEV in a Post-Merge World: Proposer-Builder Separation

Ethereum's Merge in September 2022 (switch to Proof-of-Stake) changed who the block producer is – from miners to validators – but it didn't remove MEV. In fact, MEV became even more central to ETH 2.0 economics, and Flashbots was ready for it.

Under Proof-of-Stake, block production is a bit different. Each slot (block interval) a validator is randomly chosen to propose a block. To continue maximizing MEV, the community introduced MEV-Boost, an off-chain sidecar that implements Proposer-Builder Separation (PBS) for Ethereum. In simple terms, PBS means splitting the role: block builders specialize in constructing the most profitable blocks (ordering transactions, including MEV bundles), and block proposers (the validators) simply pick among these blocks the one with the highest payoff (fee) and propose it to the network. MEV-Boost is the software that connects validators to a network of external builders who compete to provide the best block.

Here's how it works today on Ethereum (and other EVM chains adopting MEV-Boost):

Validators run MEV-Boost and connect to various relays. Relays are like brokers that aggregate blocks from builders. (Flashbots runs a popular relay, and there are others by Blocknative, Eden, etc.)
Searchers still do their thing: find MEV opportunities and submit bundles, now targeting builders (rather than directly validators). In practice, searchers might send bundles to builders via relays or other APIs, depending on the setup.
Builders take transactions from various sources: the public mempool, private orderflow, searcher bundles, etc., and assemble the most profitable block possible. They then send just the block header and payment offer to validators via relays (the block contents are kept confidential initially).
The validator (block proposer) receives potentially multiple block offers each slot and typically chooses the one that pays the most (usually that means the block with the highest MEV captured, since builders share most of that profit with the validator as a bribe). The chosen block gets proposed and added to the chain.

This system has now been widely adopted: over 90% of Ethereum validators today run MEV-Boost, outsourcing their block building to expert builders. It maximizes rewards for validators (great for decentralization, as even a solo staker can earn MEV rewards by outsourcing to builders) but it also introduces new players (builders/relays) and potential centralization at the builder level. We'll revisit that in research topics.

Other chains have analogous evolutions. Many Ethereum Layer-2s (Arbitrum, Optimism, etc.) and EVM sidechains also deal with MEV. For instance, BSC (Binance Smart Chain) saw its own MEV bots and now has private relay initiatives. On Optimism and Arbitrum, today a single sequencer orders transactions, so MEV is internally captured or could be. There's research into decentralizing sequencers and maybe adopting PBS-like designs for rollups in the future, but we'll cover that later.

Meanwhile, outside of Ethereum, Solana was experiencing MEV in its own way, and even Bitcoin had a few MEV-like moments. Let's take a quick look at the major MEV tools and protocols in different ecosystems.

Major MEV Protocols and Tools by Ecosystem

MEV has spawned a whole suite of protocols, services, and tools across different blockchains. Here's a non-exhaustive list of major ones and what they do, organized by ecosystem:

Ethereum & EVM-Based Chains

Flashbots (MEV-Geth / Flashbots Relay / Flashbots Protect) – The OG of MEV. Flashbots is a research org that introduced MEV bundles and a private relay on Ethereum in 2020. MEV-Geth was their miner client modification for Proof-of-Work, and Flashbots Relay is the network that carries bundles from searchers to miners/validators. Flashbots Protect is a user-facing RPC service that sends your transaction to miners/validators privately to avoid being victim to MEV (e.g. avoid getting sandwiched). Flashbots is also behind many new initiatives (MEV-Share, SUAVE – more later). Most MEV activity on Ethereum still involves Flashbots in some way.
MEV-Boost and Relays – This is the post-Merge PBS infrastructure on Ethereum. It's an open-source middleware that validators run. By itself MEV-Boost is just the relay connector; the key parts are the relays and builders. Notable relays: Flashbots Relay, Blocknative Relay, BloXroute, Eden, etc. Notable builders: many are private or run by trading firms (e.g., Builder0x69, rsync, Beaver, etc.), and they compete to produce blocks. MEV-Boost allowed a relatively plug-and-play adoption of PBS – any validator can opt in by running the software, no need to modify the core Ethereum protocol. On Ethereum mainnet, this is now a dominant source of blocks. Other EVM chains like Polygon POS have also integrated MEV-Boost-like systems, and some L2s are considering it as they decentralize their block production.
Eden Network – Eden started in 2021 as an Ethereum block ordering protocol that attempted to create a "fairer" MEV marketplace with its own token. Miners running Eden would give priority to transactions from Eden users (who staked EDEN tokens) and accept bundles via the Eden system. It also introduced concepts like a slot auction (users bidding for the right to be in the next block's "first slot" to avoid being front-run). Eden gained some traction with a few mining pools pre-Merge. Post-Merge, Eden ran an MEV-Boost relay (Eden Relay) for a while, but recently they handed that off and pivoted directions. Eden showed there was interest in alternative MEV relay networks, though it ultimately did not unseat Flashbots.
bloXroute's BDN and "BackRunMe" – bloXroute is a network that provides high-speed blockchain data propagation. They offered a product where users could send transactions through their network (a "Blockchain Distribution Network") to get faster delivery to miners. They also launched a service called BackRunMe which basically let users submit transactions and allow searchers to backrun them, with the searcher paying the user a portion of the profit. This is a form of order flow auction, a concept we'll revisit. It aimed to give users some MEV profit in exchange for allowing their transactions to be non-public until included.
Blocknative – Blocknative is an infrastructure company that runs an Ethereum builder and relay. They provide tools like a real-time mempool API (for seeing pending transactions) and have an MEV bundle API as well. They often publish research and guides (e.g. they wrote a public tutorial on building an arbitrage bot). If you're a searcher, Blocknative's relay is another avenue to get your bundles to validators (competition is good!).
Manifold Finance (OpenMEV) – Manifold started by offering "OpenMEV" on Ethereum and later on Ethereum L2s. They integrated with some DeFi platforms and wallets to capture MEV from users' trades and redistribute it or mitigate its negative effects. For example, they partnered with Cream Finance in 2021 to capture MEV from liquidations and share with the protocol. Manifold also now runs a builder/relay in the PBS system under the name "Ethical MEV" (Gataca) which took over Eden's relay. They've been proponents of MEV being something that can be rebated to users or integrated at the app level.
CoW Protocol (Cowswap) – CoW Protocol is a DEX aggregator that uses a batch auction mechanism. While not an MEV extraction tool, it's a protocol designed to protect users from MEV by matching trades in batch auctions and using "solvers" who compete to fill the batch with optimal order settlements. CoW can also intercept and fill trades internally so they never hit the public mempool, thus avoiding sandwiches. They even launched mev-blocker (in 2023) – a RPC endpoint similar to Flashbots Protect that bundles your tx with a backrun and returns any extracted MEV to you or the miner, preventing outside bots from sandwiching. CoW Protocol and similar order-flow auctions are part of a trend to cut users in on the MEV game rather than leaving them as victims.
Others: There are many other pieces in the MEV landscape. MEV-Explore and MEV-Inspect are tools that analyze blocks to see what MEV was taken. MistX was a DEX that submitted all trades via Flashbots to avoid mempool. Research groups like EigenPhi provide dashboards for arbitrages and sandwiches happening on-chain. In short, a lot of tooling grew around MEV once people realized how much money was on the table (hundreds of millions of dollars).

Solana

Solana is a high-performance L1 with a different architecture, and MEV takes a different shape there:

Jito Labs and Jito-Solana – Jito is essentially the Solana equivalent of Flashbots. It's an out-of-protocol auction for blockspace on Solana, implemented in a modified Solana client that many validators run. Since Solana doesn't have a mempool in the same way as Ethereum, Jito introduced an out-of-band transaction pool and auction. Searchers on Solana can send bundles (like in Ethereum) to Jito validators, with an attached tip. Solana leaders (block producers) running Jito would pause for a very short window (200 milliseconds) to let searchers submit competing bundles that target pending user transactions, and then include the highest-paying bundle. This allowed typical MEV like sandwiching to happen on Solana, even though Solana's normal runtime doesn't expose a public mempool. Jito's bundle system led to significant extra revenue for validators (e.g. one validator received an 890 SOL tip in a single bundle, and in one week Solana validators earned >$7M in tips via Jito). However, the Solana community grew concerned about the toxic MEV (sandwich attacks) this enabled. In March 2024, Jito Labs actually shut down the 200ms "mempool" feature that enabled sandwiching. Validators agreed to forego that short-term MEV income to protect user experience on Solana. Now, Jito still runs but focuses on backruns and arbitrages that don't require seeing transactions mid-flight (searchers can still submit bundles for things like liquidations or arbitrages after seeing a block). The Jito-Solana client and its Block Engine continue to optimize block building and share revenue with validators, just without the most predatory forms of MEV.
Geyser Plugins – Solana's design is very different: it processes transactions in parallel (more on that later) and has continuous block production (a new block every ~400ms, with leaders rotating every few blocks). There isn't a single global mempool; instead, nodes forward transactions to the current and next leaders. For MEV searchers, speed of data is crucial. Geyser is a plugin system in Solana nodes that allows exporting real-time data (accounts, transactions, etc.) via gRPC. Many searchers run their own Solana validator or RPC node with a Geyser plugin (e.g. to get every token swap event as it happens) to find opportunities. Geyser doesn't extract MEV itself, but it's a tool for searchers to get an edge in observing the Solana blockstream.
Other Solana MEV efforts: There have been independent projects and research on Solana MEV. For instance, one team (Chorus One) experimented with a validator that could reorder certain trades inside the Solana runtime for MEV. There's also talk of priority fees and quality-of-service affecting MEV on Solana – e.g. Solana lets you attach an extra fee per compute unit to prioritize your tx execution, which is another lever searchers can use. Overall, Solana's MEV scene has consolidated around Jito's ecosystem for now, and the focus is on extracting "benign" MEV like arbitrage and sharing it with validators, while cutting out harmful user-front-running.
Solana's differences: Not having a public mempool by default means you can't easily see a user's trade before it's executed (searchers have to sniff transactions as they propagate to the leader, often by running a fast node themselves). Also, Solana's parallel execution means if two transactions touch disjoint state (different accounts), they don't really contend with each other and can run simultaneously. This reduces some MEV competition because, for example, two independent arbitrages could be executed in the same block without ordering conflict. But if they do conflict (e.g. both need the same liquidity pool), then only one can get the necessary account lock and the other will be delayed. The complexity of Solana's scheduler (multiple threads processing txs, locking accounts) makes MEV extraction a very technical game. It favors those who run validators co-located with the leaders to get the freshest info and submit transactions with minimal latency. We'll discuss later the challenges this poses for Solana as it scales.

Bitcoin (and other UTXO chains)

Bitcoin doesn't have the rich transaction types that Ethereum or Solana do – you can't do DEX trades or DeFi on Bitcoin L1 (at least not in the same way). So, while the theory of MEV applies to Bitcoin (miners could in principle reorder or front-run transactions), historically there have been few opportunities to do so. Most Bitcoin transactions are simple payments, and miners just order them by highest fee.

That said, Bitcoin is not completely MEV-free:

One classic example of Bitcoin MEV is "fee sniping" or time-bandit attacks: If one block has an unusually high reward (say, someone paid a huge transaction fee or there's some opportunity like a lucrative output), another miner might attempt to re-mine (reorg) that block to steal the reward. Back in 2013, Bitcoin developer Peter Todd even warned about this: if a transaction creates a big payout (like a bounty), miners might try to invalidate that block and grab the bounty themselves. This is analogous to a reorg for MEV on Ethereum – it's just not common on Bitcoin because block rewards dwarf normal fees, and reorgs are risky. But if Bitcoin had some special one-off opportunity, the incentive exists.
Recently, Ordinals (NFT-like content on Bitcoin) and Rune (a proposed token protocol) have introduced more complex transactions and even DEX-like behavior on Bitcoin. With these, one can imagine MEV creeping in – e.g. if an NFT mint on Bitcoin becomes a thing, miners could potentially reorder to get a valuable mint for themselves, or front-run a trade in a Bitcoin-based DEX. These are early and experimental, but the Bitcoin community is aware that as soon as you add complexity, MEV opportunities grow.
Cross-chain arbitrage: Sometimes Bitcoin is part of an arbitrage via pegged or wrapped BTC on Ethereum. A Bitcoin miner can't directly influence Ethereum transactions, of course, but as the ecosystem becomes multi-chain (with Bitcoin sidechains or Layer2s), there might be roles for Bitcoin miners in order-flow auctions or collateral liquidations, etc. Not much of this exists yet.

In summary, Bitcoin's MEV is mostly theoretical and minimal today. There's no Flashbots for Bitcoin (some have jokingly suggested it, but Bitcoin culture is against this kind of complexity on L1). However, things like Drivechains or smart contract layers on Bitcoin could bring familiar MEV problems to the Bitcoin realm in the future.

Those are the major platforms and tools. Now that we have context, you might be wondering: how can an individual developer or enthusiast get involved in MEV? Let's cover that next.

Getting Started with MEV: A Beginner's Guide

MEV can seem like an elite pursuit, but there are ways for newcomers to learn and even try their hand at it. Here are some steps and tips for working with MEV as a beginner:

Set Up a Local Fork or Testnet – Before diving into mainnet action (which is very competitive and can be costly), simulate the environments. You can use frameworks like Hardhat or Foundry (Anvil) to fork Ethereum mainnet state on your machine. This allows you to replay real mempool scenarios in a controlled environment. For example, you can take a historical block where an arbitrage happened, fork from just before it, and write a script to see if your bot could capture it. A local fork is great for testing your arbitrage or liquidation logic without risking real funds.
Use MEV Simulators & Sandboxes – There are tools specifically for simulating MEV strategies. Flashbots has a public bundle simulator where you can test how your bundle would execute and whether it would be profitable (without actually sending it on-chain). Tools like Tenderly or Ethereum testnets (like Goerli or Sepolia) can also be used to simulate transactions and outcomes. Some MEV researchers use custom simulations (even Python notebooks) to model scenarios. Essentially, create a safe playground to refine your idea.
Study Existing MEV Bundles and Transactions – A lot can be learned by analyzing how current MEV bots operate. Flashbots publishes data via the Flashbots Dashboard and there are community sites (like Etherscan's Flashbots label, EigenPhi and MEV-Explore) that show historical MEV transactions. By inspecting these, you can see, for example, how a sandwich bot structures its two transactions around a victim, or how an arbitrage bot cycles funds across Uniswap and SushiSwap. You'll notice patterns: e.g. many use flashloans to not require upfront capital, or how they calculate optimal trade sizes. There are also code repositories and tutorials from the community – e.g. Blocknative's blog post on an arbitrage bot and a number of open-source MEV bots on GitHub. Reading and even forking these can jumpstart your understanding.
Run a Node and Monitor the Mempool – If you want to be a searcher, real-time data is your ammo. Set up your own Ethereum full node (e.g. geth or Nethermind) with txpool enabled, or use a service like Blocknative's mempool API or Alchemy's mempool streams. By monitoring the mempool, you can see transactions the moment they are broadcast, which is crucial. For instance, if you see a transaction that will likely cause a price spike on a DEX, you have a small time window to react (craft a sandwich or arbitrage transaction). Getting proficient with mempool event handling (and doing so at scale, since you might be scanning thousands of txs per second) is a key skill. On Solana, as mentioned, you'd run a validator or RPC with Geyser to get feeds of events. On Ethereum, you might also subscribe to pending transaction flows from multiple sources for redundancy (to avoid missing something).
Start with Basic Arbitrage or Liquidation Bots – A good newbie project is an arbitrage bot between two DEXes. The logic: watch pools for price differences, when a difference exceeds fees, execute a trade buying on one and selling on the other in one combined transaction (so it's atomic). This can be done with a simple smart contract that interfaces with, say, Uniswap and SushiSwap. Many tutorials exist for this classic MEV strategy. Another is a liquidation bot on lending platforms: monitor platforms like Aave or Compound for underwater loans, and call the liquidation function when profitable. These are conceptually simpler types of MEV compared to say, writing a sandwich bot (which has to deal with predicting other traders' slippage tolerance and multi-tx sequences). By building a simple MEV bot, you'll learn how to use Web3 libraries, how to send transactions with custom gas and perhaps private endpoints, and how to handle the rapid decision-making required. Keep in mind, any straightforward arb you code up is likely already heavily competed on mainnet, so treat it as a learning exercise more than a money-maker at first.
Use Flashbots (or similar) to Submit Transactions – When you're ready to test on mainnet, you probably don't want to just fire your transactions into the public mempool – because if it's a juicy opportunity, other bots will see your transaction and maybe copy it (this is called generalized frontrunning: bots scanning the mempool to steal others' pending arbs). Instead, you can use Flashbots to send your transaction as a bundle directly to miners/validators without public exposure. Flashbots has a "Searcher Quick Start" guide and open-source libraries (like ethers-provider-flashbots in JavaScript, or Flashbots SDKs in Python and Rust) to help you send bundles. Blocknative's Auction API is another avenue to privately submit. On Solana, using Jito, you'd submit your bundle via their system. Testing with small amounts is crucial – you might think your bot is ready, but there are many corner cases that only live fire will reveal (e.g. your transaction failing due to a state change you didn't anticipate, or your timing being off).
Observe and Iterate – Run your strategy and see how it performs. You may find that you get outbid often, which means you might need to increase your tip to miners (sacrificing some profit), or you might find the opportunities you target are rare. MEV is like an arms race; if you find a new type of opportunity that others haven't, it might be profitable until others catch on. Conversely, if you're doing the same thing as many others, you need to be faster or smarter. Use analytics – logs from your bot, traces from on-chain – to refine your approach. Maybe you optimize your transaction's gas usage, or you find a way to bundle multiple arbitrages in one transaction (some advanced searchers do multi-arb combos).
Participate in MEV Communities – Join communities like the Flashbots Discord, or forums where MEV researchers hang out. There's a vibrant sharing of knowledge (to some extent – the really profitable stuff might be kept secret!). By staying plugged in, you'll learn about new developments: e.g. new MEV opportunities on the horizon (like maybe MEV on a Layer2 DEX or NFT marketplace arbitrage). There are also periodic competitions and hackathons focusing on MEV – these can be great for learning and showcasing skills without risking money.

Finally, keep security in mind. Running bots that move funds automatically can be risky. Smart contract audits (if you deploy a contract for your bot) and careful key management are a must – you don't want your bot to become the hunted (there have been instances where bots got their vulnerabilities exploited by other bots!).

Advanced MEV Strategies and Concepts

Once you have a handle on the basics, you'll discover a whole universe of advanced MEV tactics. Here we explain a few infamous strategies and concepts that are part of the MEV lexicon:

Frontrunning and Sandwich Attacks

Frontrunning in blockchain typically means seeing someone else's pending transaction and getting your transaction in ahead of it to capitalize on its effect. The classic example is a large DEX trade: if you see a 1000 ETH buy order in the mempool, you might try to buy before it to ride the price up, then sell after. A sandwich attack is essentially a specific pattern of one frontrun and one backrun around a victim transaction. The attacker's goal is to manipulate the price and extract value from the victim's trade. Sandwiches are common on Automated Market Maker (AMM) exchanges: the attacker pushes the price against the victim (making the victim get a worse deal), then reverts the price and profits on the rebound. From the user's perspective, they end up with slippage – receiving less than expected – and the attacker pockets that difference as arbitrage profit.

Sandwich attacks are considered toxic MEV because they directly harm users' trades. On Ethereum, many users learned to hate the feeling of being sandwiched (you can often tell when your Uniswap trade goes through with worse-than-expected output). Technically, implementing a sandwich bot means monitoring mempool for large trades and having the ability to very quickly simulate the effect of that trade on the pool price to know how to set your own buy/sell amounts. It's a latency-sensitive and competitive game. And remember, if you can see a victim's tx, so can others – so sandwich bots also compete with each other!

There are defenses: users can use private mempools (so attackers can't see the trade in advance) or DEXs like CoW that use batch auctions. Nonetheless, sandwiching remains rampant on open mempools.

Backrunning

Backrunning is the less nefarious sibling of frontrunning. It means placing your transaction right after another specific transaction to profit. If frontrunning is cutting in line, backrunning is following close behind someone who's creating an opportunity. An example: suppose someone makes a huge swap on Uniswap that moves price of Token X upward by 20%. Right after that, on SushiSwap there's now a big price difference (Token X is still cheap on Sushi relative to Uniswap's new price). A searcher could backrun the Uniswap trade with an arbitrage that immediately buys on SushiSwap and sells on Uniswap, profiting from price convergence. The key is you want your arbitrage to happen in the same block, right after the big trade. If you wait even one block, someone else will likely do it or prices will arbitrage naturally.

Backrunning often helps efficiency (like arbitrage brings markets to equilibrium, and liquidations restore solvency), so it's often seen as "benign" or "non-toxic" MEV. The traders who were going to arbitrage or liquidate eventually aren't harmed (they just didn't get to do it first), and the protocols/users don't suffer negative effects. In fact, timely backruns like arbitrage make sure no DEX stays mispriced for long, which is good for traders. The only ones who might dislike it are liquidity providers who might have preferred prices stay divergent longer – but generally arbitrage is a healthy mechanism.

As a strategy, many MEV bots focus purely on backruns: monitor for any large transaction (or combination of events) that create an arbitrage opportunity or some profitable action, and then execute it. This is slightly easier than pure mempool sniping because you often only need to react after something is already confirmed to happen (you see the transaction or event that definitely will execute, especially in a bundle system where you know if it's in the block with you). On Solana, after Jito removed the mempool, most MEV is essentially backrunning: searchers see a swap in one block and then arbitrage it in the next block.

Reorgs and Time-Bandit Attacks

Most MEV assumes you're working within the confines of one block. But what if the MEV in a given block is so high that it's worth trying to undo that block and steal it? That's the idea of a time-bandit attack (coined by Flashbots researchers) – a miner/validator reordering entire blocks or even doing a chain reorganization to capture past MEV. This is very theoretical in most healthy networks: reorgs are hard to pull off unless you control a lot of hashpower (in PoW) or stake (in PoS). But it's been discussed, especially for PoW Ethereum and for smaller chains: if one block had, say, a million-dollar MEV opportunity in it that Miner A took, Miner B might attempt to orphan that block and mine an alternative history of blocks where Miner B takes that million-dollar MEV instead. Normally, block rewards act as a kind of fixed incentive that makes deep reorgs unprofitable (you'd be competing against the cumulative difficulty or stake weight). However, MEV can be unbounded in theory, so the economic equilibrium could break if MEV jackpots are high and frequent.

On Ethereum, during DeFi summer, people noticed some blocks had tens of ETH of MEV. Could a mining pool try to re-mine those? It never really happened (publicly at least) because it's risky and miners coordinated to avoid such scenarios. But the concern remains: if MEV extraction gets too large, it might undermine consensus stability (validators may fight over who gets to rewrite history to grab MEV). That's part of why the Ethereum community wants to design protocols to smooth or reduce the worst-case MEV (see PBS and MEV-Burn in the next section).

On Bitcoin, as mentioned, reorg to steal a bounty was pointed out by Peter Todd in 2013. To date, Bitcoin's game-theory and the fact that most transactions have low MEV has kept this at bay.

Cross-Domain and Cross-Chain MEV

We live in a multi-chain world now: Ethereum L1, L2s, sidechains, Cosmos zones, Polkadot parachains, Solana, etc., plus many bridges connecting assets across them. Cross-domain MEV refers to opportunities that exist because of price or state differences across domains. For example:

A token could be overpriced on Uniswap on Ethereum versus Pangolin on Avalanche. A bot could buy on one and sell on the other, but it has to actually move assets across a bridge (which might take time or liquidity).
A user might initiate a large transfer from Ethereum to Solana (via a bridge like Wormhole) and by the time the funds arrive on Solana, the price of the token changed – an arbitrage could be done versus what the user expected.
Someone might do a large trade on Arbitrum (L2) which isn't immediately arbitraged on Arbitrum, but that price difference reflects on Ethereum with a delay due to how Arbitrum posts updates. A searcher could take an Ethereum position knowing what's happening on Arbitrum (kind of like trading on insider info from L2).

Cross-chain MEV is very complex because it often involves timing differences and risk (bridges have latency; you can't atomically arbitrage across separate chains unless there's some synchronized mechanism). However, there are specialized searchers and protocols looking at this. For example, Across and Hop (bridges) have designs where relayers arbitrage the bridge rate vs market price. Some MEV firms run infrastructure on multiple chains to catch arbitrage between DEXs on different chains (essentially doing a rapid sequence of trades and transfers).

One interesting cross-domain MEV type is backrunning user arbitrage: e.g. a user tries to arbitrage between Uniswap (Ethereum) and TraderJoe (Avalanche) by moving funds, but their actions themselves create temporary imbalances that another bot could counter-arbitrage.

As ecosystems grow, cross-chain MEV could become as big as single-chain MEV. It also raises questions: will the entity that builds blocks on Ethereum also one day coordinate across chains to capture MEV globally? Projects like SUAVE (later) imagine a unified MEV auction across many domains.

To wrap up this section: We've covered just a few advanced topics. MEV strategies keep evolving – e.g. NFT MEV (sniping rare NFTs in mint blocks), Oracle manipulation (if you can reorder oracle updates and trades), Backrunning sandwich (no joke, some bots sandwich a sandwich attacker to steal some profit!). It's a cat-and-mouse world; every new DeFi protocol or mechanism introduces potential new MEV angles, and researchers as well as attackers are constantly analyzing them.

The Cutting Edge: MEV Research and Emerging Mitigations

MEV is such a hot topic that entire research streams and even startup companies are dedicated to it. Here we'll explore some of the current and upcoming developments aimed at understanding, mitigating, or harnessing MEV:

Proposer-Builder Separation (PBS) In-Protocol: Today's PBS (via MEV-Boost) is an off-chain solution. Ethereum researchers plan to eventually enshrine PBS into the Ethereum protocol itself. In-protocol PBS would mean the role of builder and proposer are formally separated in the consensus rules. This could remove the need for third-party relays and enforce things like always paying the proposer their cut. It's expected to reduce the trust and centralization issues of the current system (where a few builders dominate, and relays could censor transactions). Enshrined PBS is being discussed alongside Ethereum's roadmap for scaling (Danksharding). Implementing it is non-trivial and might not come until possibly 2025 or later. But it's one of the highest priority Ethereum research areas, because it promises to secure the protocol against MEV centralization long-term.
MEV-Burn: Proposed by Ethereum researcher Justin Drake, MEV-Burn is an idea to redirect some of the MEV profits to benefit the protocol or users, instead of all going to validators or searchers. It's analogous to EIP-1559 where we burn a base fee to make fees work for the common good. One idea is to have a mechanism where some portion of the MEV (like very high tips) get burned or put into a pool that is redistributed, smoothing out rewards. This could reduce the incentive for time-bandit attacks (if spikes are smoothed) and make MEV less of a winner-takes-all. It's still just a research idea with pros and cons being debated.
MEV-Share and Order Flow Auctions: Flashbots isn't just resting on bundles. They introduced MEV-Share, a system where users can send transactions to a protected pool and opt-in to sharing some info with searchers in exchange for getting some MEV kickback. Essentially, it's like saying "I'm doing a trade, I'll let searchers know its rough details so they can backrun it, but they have to share profit with me, and they can't frontrun me." This is implemented by splitting the transaction data: searchers might see the token addresses and amounts but not who the sender is or other critical details, and they can bid to backrun. It's an early attempt at an order flow auction (OFA) – where order flow (user transactions) is sold to the highest bidder under certain rules, similar to how Robinhood sells stock order flow to market makers. The goal is to give users a piece of the MEV pie rather than just being the pie. MEV-Share is currently in testing (Flashbots has a beta).

More broadly, Order Flow Auctions are being explored by others too. For example, some Ethereum wallets might in the future route your transactions to a private auction where builders bid to execute it (ensuring you get the best price and maybe a rebate). This could drastically change the "searcher" dynamic if the user's wallet effectively pre-auctions the MEV, leaving less meat on the bone for block-level searchers. Projects like Rook (KeeperDAO) attempted something like this at the protocol level, and CoW Protocol's design is also a flavor of OFA.
SUAVE (Single Unifying Auction for Value Expression): This is Flashbots' moonshot project. SUAVE aims to be a decentralized, cross-domain MEV platform – effectively a new chain or network that can conduct auctions for transactions from any blockchain. The vision is that SUAVE would receive encrypted transactions from users on various chains, aggregate them, run a massive auction (with privacy so bidders can't see everything), and output optimized block bundles to each connected chain's validators. It's like building a universal MEV market that is trustless and user-aligned. SUAVE is in early development (expected to have some releases in 2024). If it succeeds, it could replace the current patchwork of relays and private pools with one system that connects to Ethereum, Solana, L2s, etc. It's very ambitious, essentially requiring its own blockchain (Flashbots jokes it's building an "MEV-aware blockchain"). Keep an eye on this in the coming years as it could redefine how transactions enter all blockchains.
Censorship Resistance (CR) Tools: One downside of the current MEV infrastructure (relays/builders) is potential censorship. In late 2022, over 50% of Ethereum blocks were being built by MEV-Boost relays that were censoring certain transactions (due to OFAC sanctions, etc.). The community has been working on solutions so that even with PBS, no valid transactions get censored systematically. Some approaches:
- Proposer-side filtering (Inclusion Lists): The Ethereum proposer can supply a list of must-include transactions to the builder. If the builder's block is missing these and there was space, the validator can refuse it or insert them itself. This way, even if builders ignore some tx, the validator ensures they eventually get in.
- Encrypted Mempools: Projects like Shutter and Espresso are working on using cryptography so that when users send transactions, they're encrypted (unreadable to others) until a certain point (like until after a block is built). Ethereum researchers have considered schemes where all transactions are encrypted on entry, and only revealed after ordering is decided. This would prevent censorship because a builder couldn't selectively exclude what it can't see (and also prevent MEV exploits like frontrunning because you can't read the tx content ahead of time). The challenge is combining this with MEV extraction (since builders do need to see the content eventually to extract MEV). Some hybrid approach might allow e.g. seeing some data (like tokens involved) but not addresses.
- Relay diversity / decentralization: simply put, encourage more non-censoring relays and builders. This has already helped; as of 2023, many validators configure multiple relays and at least one will include all transactions, so the censorship rate dropped.
Solana-specific MEV and Scaling: In the Solana community, a hot topic is how to scale throughput while keeping MEV under control. Solana's high TPS means traditional block-by-block auctions might not work the same (you can't run a complicated auction for a block that's 400ms long). Their approach so far was Jito's fast auction, but as noted, they removed the part that hurts users. Now, one of Solana's big scaling initiatives is Fire Dancer, an independent validator client by Jump Crypto. Part of its mandate is maximizing performance; it may also introduce new ways to handle transaction ordering. There's discussion around quality-of-service scheduling – basically, letting users pay for priority (which inherently is an MEV-like auction, but built-in as "priority fees" per compute unit). The Solana folks are trying to strike a balance where searchers can still arbitrage (which keeps markets efficient) but can't extract too much at the expense of users or spam the network to death. The stat that 50% of Solana tx were failing arb spam is both testament to Solana's cheap fees (making spam viable) and a concern (wasteful load). One idea is to increase fees or adjust fee markets to make spam less attractive – essentially implementing an EIP-1559-like fee burn or dynamic fee on Solana to charge more for high-load situations. Another concept is randomized transaction ordering within small time windows to prevent deterministic manipulation (Solana's devs have mentioned things akin to Ethereum's EIP-3074 or other fair ordering ideas, though nothing concrete yet).
MEV on L2s and Other Ecosystems: Research is also happening on MEV in Layer 2 rollups (Optimism introduced a concept called MEVA – MEV auctions – for when they decentralize their sequencer). Arbitrum is exploring a Fair Sequencing Service (FSS) in collaboration with Chainlink, which would use an external protocol to order transactions fairly (possibly via secure hardware or randomness). In Cosmos, some chains like Osmosis have built-in protections (Osmosis had threshold decryption for mempool transactions in development). The general trend is each ecosystem wants to mitigate the negative externalities of MEV without eliminating the positive aspects (like arbitrage).
Formalizing "Toxic" vs "Benign" MEV: There's ongoing study into categorizing MEV. As we touched, toxic MEV (sandwiches, theft) directly harms users, whereas benign MEV (arbitrage, some backruns) arguably doesn't. If a protocol can clamp down on toxic MEV but allow/encourage benign MEV, that's a win-win. One way is at the application level: e.g. a DEX could have guardrails that make sandwiching impossible (like matching trades in batches as CoW does, or using a commit-reveal scheme for orders). Another example: lending protocols could have Dutch auctions for liquidations so it's not first-come-first-serve (thus no gas war). These kinds of design choices in dApps can reduce toxic MEV and are part of what researchers call MEV-aware design. It's a growing field – new DeFi apps nowadays often include a section in their docs "MEV considerations".
MEV and Consensus: A wild area is whether consensus algorithms themselves can be MEV-resistant. For instance, some propose reputation or rotating leaders in a way that it's unpredictable who will produce the next block until the last second, so searchers can't target a specific miner/validator with a deal (or the validator can't pre-plan a reorg). Ideas like VRFs (Verifiable Random Functions) to randomize block leader selection or consensus fragmentation to make it hard to capture all MEV in one place are being tossed around. These are pretty experimental and not near deployment, but it shows how deep MEV has wormed into the thinking: we might even change how blockchains reach agreement just to limit MEV power.

Conclusion

MEV has evolved from miners opportunistically squeezing extra dollars from transactions into a sophisticated, multi-faceted ecosystem of its own. We went from gas wars on Ethereum to a structured supply chain of searchers → builders → relays → validators. MEV is now a consideration in protocol design, not an afterthought. On Ethereum and EVM chains, the Flashbots era and now the PBS era have shown both the benefits (efficiency, higher rewards) and new challenges (centralization, censorship) that come with managing MEV. Solana's approach highlights that different architectures yield different MEV dynamics – yet ultimately any place where transactions are ordered, value is up for grabs. Even Bitcoin, minimalist as it is, isn't completely exempt from MEV pressures, especially as new features emerge.

For users and builders, MEV can be a double-edged sword. It can make markets more efficient and provide yield (e.g., validators earning MEV boosts, or arbitrage making prices fair). But it can also turn the user experience sour when you get front-run or when certain transactions get censored by overzealous block builders. The key is finding a balance – taming MEV such that it doesn't harm decentralization or user fairness, while still allowing the useful aspects to flow.

The research and engineering underway – from enshrined PBS, to MEV-share, SUAVE, encrypted mempools, and beyond – shows an encouraging trend: the community is actively working to civilize the MEV wild west. In the meantime, MEV is here to stay, and understanding it is crucial for anyone involved in crypto at a technical level. Whether you aim to be an MEV searcher, a protocol developer, or just an informed user, knowing how MEV works will help you navigate the crypto markets of today and tomorrow.

On a lighter note, the MEV world moves fast (and not just because bots are racing block times!). A statistic to close with: since the Ethereum Merge, over 320,000 ETH (about $800M as of this writing) worth of MEV has been extracted on Ethereum mainnet alone. That's value which did not exist as "fees" or "block rewards", but was conjured by sheer cleverness (or ruthlessness) in transaction ordering. It's both astonishing and a bit daunting. As we head into the future, the hope is that this value can be redistributed more fairly – perhaps partially burned, perhaps shared with users – rather than simply being a prize for the fastest and most cutthroat.

MEV presents one of the most fascinating intersections of game theory, technology, and economics in blockchain. It started as a dark forest of rogue bots, but it's gradually becoming an open field of study and innovation. If you've made it this far, you should have a solid grasp of MEV's past and present, and a glimpse of its future on Ethereum, Solana, and beyond. Happy hunting (or defending) in the world of MEV – and remember, in this game, knowledge is power!