MEV — short for maximal extractable value, originally "miner extractable value" — is the profit that a transaction-orderer can capture by reordering, inserting, or censoring transactions inside a block. Anyone who decides what goes into a block has the power to do this: in proof-of-work that was the miner, in Ethereum's post-Merge proof-of-stake that is the validator, and in the Ethereum mainnet of 2026 that is largely a chain of specialists called searchers, builders, and validators handing the block off to each other through a system called proposer-builder separation. MEV is what makes that handoff valuable. It is also what produces sandwich attacks against DEX users, frontrun arbitrage on every chain with a public mempool, and the reason intent-based DEXs and private-mempool RPCs exist. This article explains what MEV is, how it gets extracted, who the actors are, what it costs ordinary users, and the leading mitigations — including the chain-abstraction-relevant approach of intent-based settlement that makes much of the front-running surface unreachable to begin with.
​

MEV is the dollar value any actor influencing block ordering can extract by choosing which transactions to include and in what order. The simplest case: a user makes a large DEX buy. A searcher places a buy just before and a sell after, capturing the user's price impact as profit. The user pays more; the extractor pockets the difference.
​

The original term was "miner extractable value," coined in the 2019 paper Flash Boys 2.0 by Phil Daian and co-authors. It described what miners on Ethereum were already doing — and what arbitrage bots in the public mempool were already paying miners to do. As Ethereum moved from proof-of-work to proof-of-stake at The Merge in September 2022, "miner" became "validator," and the broader research community generalized the term to "maximal extractable value" to cover any block-ordering actor on any chain.
​

MEV is not inherently exploitative. Some MEV captures genuine economic activity: arbitrage between DEX prices on the same chain pulls them back into agreement with the wider market, which is a service. Some MEV is overtly extractive: sandwich attacks force users into worse fills, transferring value from a DEX trader to an arbitrageur who added zero economic value beyond fast block-ordering. The line between "useful arbitrage" and "value extraction at the user's expense" is the topic of most MEV research and most mitigation work.
​

The total volume of extracted MEV is substantial. Per the EigenPhi MEV dashboard, sandwich and arbitrage MEV on Ethereum routinely produces eight-figure monthly extraction, with the running total measured in the billions of dollars over the chain's lifetime. Flashbots's MEV-Explore tracks the same metric with a different methodology and reaches comparable conclusions. The exact number depends on what counts as MEV, but the order of magnitude is consistent across sources.
​

One useful framing: MEV is a cost on the chain that lands somewhere. If a sandwich attack extracts $50 from a user's trade, the user paid $50 more for their swap than they would have on a chain or DEX that prevented the attack. If an arbitrage closes a price gap and pays a builder $100 to be included first, that $100 came out of the price discrepancy, which means it came from whoever was on the wrong side of the gap. MEV is rarely a victimless transfer.
​

MEV is extracted through three core patterns: front-running (placing a transaction before a user's pending one), back-running (immediately after), and sandwiching (combining a front-run and back-run around the same victim). All three require visibility into pending transactions, which is why the public mempool is the surface where most MEV is extracted.
​

Front-running is the original pattern. A searcher monitoring the mempool sees a pending transaction that will move a price — say a 100,000 USDC buy on a Uniswap V3 pool. The searcher submits an identical-direction transaction with higher priority fee, lands first, captures the price move, and exits. The user transacts at the worse price. Uniswap V3's design is unchanged by this; the AMM math just delivers whatever price the order book is at after the front-run executes.
​

Back-running is the inverse. After a known transaction creates an imbalance, a searcher takes the other side. The classic case is liquidations on lending protocols: when a position becomes liquidatable, searchers compete to be the next transaction that calls the liquidation function. The first to land collects the bonus. Aave's documentation describes the liquidation reward; in practice, hundreds of bots monitor every Aave position and react in milliseconds when a liquidation becomes profitable.
​

Sandwiching combines the two and is the most user-visible MEV pattern. The searcher front-runs the user's swap, lets the user execute at the now-worse price, and back-runs to close out the position at a profit. Sandwiches are extracted at scale by automated bots running against most large DEX trades. Per EigenPhi's sandwich tracker, this pattern alone extracts hundreds of millions of dollars annually from Ethereum DEX users. The mathematical bounds and economics are described in detail in academic studies of DEX MEV.
​

Less visible patterns matter too. JIT (just-in-time) liquidity provision adds and removes Uniswap V3 liquidity around a single trade, capturing fees that would otherwise go to passive LPs. Time-bandit attacks reorganize past blocks to capture MEV that has already been included; this was a real concern under proof-of-work and is largely defused by Ethereum's post-Merge fork-choice rules but remains theoretically possible. Cross-domain MEV — extraction that spans multiple chains or rollups — is an emerging area without mature defenses.
​

The infrastructure supporting these patterns has matured into specialized markets. Searchers run latency-optimized bots scanning the mempool and submit bundles to builders. Builders aggregate searchers' bundles into proposed blocks. Validators pick the highest-paying block from the builder market. Each layer has its own competitive economics, which is the topic of the next section.
​

Searchers, builders, and validators are the three roles that emerged from proposer-builder separation on Ethereum. Searchers find profitable transaction sequences and submit them as bundles to builders. Builders assemble blocks from many searcher bundles plus regular mempool transactions. Validators pick the highest-bidding block from the builder market and attest to it. This split is now the dominant block-production model.
​

Searchers are the bottom of the funnel. They run bots that monitor the mempool — the public one and several private ones — looking for arbitrage opportunities, sandwich targets, and liquidations. When they find one, they construct a transaction sequence that captures the value and submit it to builders as a bundle, with a bid that goes to the builder if their bundle is included. Flashbots's searcher documentation describes the bundle format and bidding mechanics.
​

Builders sit in the middle. They take bundles from many searchers, add regular mempool transactions, and assemble candidate blocks. The builder's job is to maximize total block value — sum of all included bundle bids plus regular tip revenue. Top builders include Flashbots Builder, Beaverbuild, Titan, Rsync, and a handful of others; per relayscan.io data, a small number of builders consistently produce the majority of Ethereum mainnet blocks, which is one of the centralization concerns flagged in the proposer-builder separation literature.
​

Validators are at the top. Under proposer-builder separation, validators do not assemble blocks themselves; they receive sealed-bid block headers from a relay (which sits between builders and validators), pick the highest bid, and sign the block. This separation means a validator does not need to run sophisticated MEV-extraction infrastructure to capture MEV value — they simply outsource block construction and collect the highest bid. The relay enforces that the validator cannot peek at the block contents before committing to it.
​

The table below maps the three roles along the dimensions developers and researchers track when comparing them.
​

Per DeFiLlama protocol data on April 29, 2026, Lido — Ethereum's largest liquid staking pool — held around $20.9B in TVL, while Aave V3 sat at around $13.7B and Morpho Blue at around $7.0B. Lido is the largest single validator operator on Ethereum, which is one reason validator-level centralization gets flagged separately from builder-level centralization. The two are different problems with different mitigations.
​

Searcher-builder-validator is not the only model. Solana takes a different approach: validators build blocks themselves and there is no formal proposer-builder separation. Cosmos chains use a similar single-actor model. Each design has different MEV implications, but the conceptual three-role split is useful for thinking about where extraction happens regardless of which actor performs it.
​

"MEV is not a bug. It is a feature of any system where transactions are ordered. The right question is who captures it and on what terms." — Phil Daian, "The future of MEV is SUAVE," Flashbots Writings

Ordinary users feel MEV mostly through worse DEX fills and unpredictable transaction inclusion. A swap fills at a slightly worse price because a sandwich bot inserted itself around the trade. A liquidation gets delayed because someone paid for priority. The aggregate effect is a tax on every public-mempool interaction, paid in degraded execution rather than a line item.
​

Sandwich losses are the most concrete user cost. A trader swapping a five-figure USDC position for ETH on a thinly-traded Uniswap V3 pool might pay a fraction of a percent in slippage to the AMM and an additional fraction of a percent to a sandwich bot that ran around the trade. The user sees a worse price than the pool quoted; the difference is the sandwich profit. Aggregating these losses across the user base produces the eight-figure monthly extraction figures that EigenPhi tracks.
​

Failed transactions are another cost. When searchers compete for the same liquidation opportunity or the same arbitrage, only one wins; the others' transactions revert and the users still pay gas. On busy days, a meaningful fraction of mempool transactions revert, and the gas fees go to the validator regardless. Etherscan shows reverted transactions plainly; users who are not searchers occasionally hit them when their RPC submits to a now-stale mempool state.
​

Front-running of ordinary trades is rarer than sandwich attacks because a single front-run without a back-run usually produces a worse outcome for the searcher (the price moves against them on exit). But it does occur on highly directional information — for example, a user's first transaction after airdrop unlock, or a known arbitrage between a DEX and a CEX. Sophisticated traders mitigate this by routing through private mempools, covered in the next section.
​

The cumulative experience for retail users is that public-mempool DEXs feel "expensive in ways I can't see." Charts of expected vs realized fills consistently show realized fills worse, with the gap rising during volatile periods when MEV is most profitable. This is one of the reasons intent-based DEXs and private-mempool RPCs have grown — they reframe the trade so MEV is either captured by the user or made structurally inaccessible to outside extractors.
​

For institutional users the cost is more visible because they monitor execution quality. A trading desk routing eight-figure size through a public-mempool DEX accounts for MEV as part of the trade cost, the same way they account for slippage and fees. The number is large enough that the institutional flow has largely migrated to RFQ systems, intent-based DEXs, or off-chain settlement layers that do not expose orders to a public mempool. Per DeFiLlama data, Uniswap V3 maintains around $1.7B in TVL and Curve DEX around $1.7B as of April 29, 2026; both have public-mempool exposure unless users route through private RPCs.
​

Users can mitigate MEV through three main mechanisms: private RPCs that bypass the public mempool, intent-based DEXs that quote a guaranteed price, and slippage controls that bound the loss when MEV is unavoidable. Each addresses a different layer, and they compose: a user can route through a private RPC, set tight slippage, and use an intent-based DEX simultaneously.
​

Private RPCs send a transaction directly to a builder or to a private mempool that searchers cannot read. Flashbots Protect is the most widely used; Merkle, Blocknative, and others offer comparable services. The user's transaction goes to a builder or relay that excludes external searchers; sandwich bots cannot see the pending transaction, so they cannot front-run it. The downside is reduced inclusion speed and dependence on the private network's operators.
​

Intent-based DEXs flip the order of operations. Instead of submitting a transaction that will execute at whatever price the AMM produces at inclusion time, the user signs an intent ("I want at least 1,000 USDC for this 1 ETH"). Solvers compete off-chain to fulfill the intent, and the user only signs the final on-chain settlement at a quoted price. CoW Swap is the canonical example, with batched auctions that internalize MEV. UniswapX uses a similar model with Dutch auctions for solver competition. Per comparison data on intent-based DEXs, sandwich exposure for intent-routed trades is structurally near-zero because the user never broadcasts a public-mempool order against an AMM.
​

Slippage controls bound the loss when MEV is in the picture but not preventable. A user setting tight slippage on a Uniswap V3 swap caps the worst-case execution below the quote. Sandwich bots that can profitably push the price beyond that threshold will trigger a revert rather than a worse fill. Tight slippage trades transaction success rate for execution quality; loose slippage does the opposite. Practical guidance varies by pool depth, asset volatility, and trade size.
​

Private mempools have their own MEV-related properties. MEV-Share from Flashbots gives users a share of the MEV their transaction generates, by allowing searchers to back-run their transactions in exchange for kickbacks. This is a different shape of mitigation — instead of preventing MEV, it returns a fraction to the user. CoW Protocol's documentation describes batch auction MEV internalization in similar terms.
​

For application developers, the mitigation set is broader. Apps can route trades through intent-based DEXs by default, integrate private RPCs as the standard transaction path, and adopt commit-reveal schemes for sensitive flows. Intent settlement systems like Aori are infrastructure that consumer apps integrate to give their users MEV-protected trading without the user needing to know what MEV is. Intents and solvers covers the broader architecture.
​

Cross-chain MEV is extraction that spans multiple chains, where a transaction on chain A creates a price impact a searcher captures by transacting on chain B. The classic case is arbitrage between a DEX on Optimism and one on Base; the discrepancy goes to whoever moves funds fastest. It depends on bridge speed, finality, and orchestration capacity.
​

The basic pattern: searchers monitor pools across multiple chains and detect price discrepancies. When the gap is large enough to cover bridging costs and inventory risk, the searcher sells the cheap asset on one chain, buys it on another, and bridges to settle. Searchers with persistent inventory on multiple chains can capture these gaps faster than searchers who must move funds; the inventory advantage is the structural feature of the cross-chain MEV market.
​

Bridging speed is the binding constraint. Per the DeFiLlama stablecoin tracker pulled on April 29, 2026, USDC supply is around $77.3B distributed across many chains, and stablecoin price discrepancies between chains are usually small. But during volatile periods or when a chain has a temporary liquidity imbalance, the gaps widen — and the searcher who can rebalance fastest captures them. Fast bridging infrastructure is essentially MEV infrastructure for cross-chain operations.
​

Intent-based cross-chain settlement changes the picture. Instead of a searcher arbitraging a price gap by physically moving funds, a user posts an intent that solvers fulfill from their existing inventory on the destination chain. The solver settles with the user immediately and rebalances later. Cross-chain intent protocols review the landscape; the structural feature is that the user is no longer exposed to bridge latency or to inventory rebalancing risk.
​

For protocols that touch many chains, MEV is a continuous design pressure. Every cross-chain transfer is an opportunity for a searcher to extract value somewhere along the path. Designs that funnel users through intent-based DEXs and intent-based cross-chain transfer protocols structurally remove most of those extraction surfaces, leaving only the solver-internal MEV (which competes at the solver layer rather than at the user's expense).
​

Eco Routes is intent-based: users post intents and solvers compete to fulfill them. The user's order never hits a public mempool, so sandwich and front-run surfaces that exist on AMM-style cross-chain bridges are not present. MEV between solvers exists but is internal to the solver layer. The user gets a quoted outcome, not a slippage-prone fill.
​

This pattern is the cross-chain equivalent of what CoW Swap and UniswapX do for single-chain DEX trades: replace the public-mempool transaction with an intent and a competitive solver auction, and the front-running surface disappears for the user. The user signs a single intent; the solver bears the inventory risk and the rebalancing cost. Intents and solvers is the broader architecture writeup.
​

Eco Routes is live on 15 chains as of March 2026. Hyperlane is the only currently-live partner-rail; CCTP is used as internal transport for USDC settlement. The intent-based design is what allows the user to ignore which transport rail handles a given transfer — the solver picks the route, and the user sees the quoted outcome. From an MEV perspective, this means the user is exposed to whatever MEV the solver internally absorbs, not whatever MEV the public mempool would have extracted. Per the DeFiLlama stablecoin tracker on April 29, 2026, USDT supply was around $189.5B and USDC supply around $77.3B, so a meaningful share of cross-chain stablecoin movement now flows through intent-based settlement that would otherwise have been exposed to mempool MEV.
​

For application teams choosing how to handle stablecoin movement at scale, the relevant question is: are users transacting through a surface that exposes them to public-mempool MEV, or through a surface that routes through an intent-based settlement system? The first imposes a continuous tax on every trade; the second pushes that cost onto solvers who compete to absorb it. The Eco architecture is in the second category by design.
​

Solver competition is what makes the intent model sustainable. With many solvers bidding to fulfill the same intent, the spread between what the user receives and what the solver captures shrinks toward the true clearing price. This is the same competitive dynamic that pushed Ethereum builders into a tight margin business — except the competition runs at the intent layer rather than the mempool layer, and the user is the direct counterparty rather than a passive observer of the auction.
​

The flip side is that intent-based systems concentrate trust in the solver set. A solver who promises a quote and fails to deliver creates a different kind of failure mode than a sandwich attack — the user does not lose value to a hidden MEV extractor, but they do depend on the protocol's solver enforcement and slashing mechanisms. Trustless is the relevant frame: intent-based settlement is not trustless in the same way an AMM is, but it shifts the trust to a different surface that can be more easily monitored and constrained.
​

The MEV literature continues to evolve. Topics under active research include cross-domain MEV minimization, encrypted mempools (where transactions are visible only after inclusion), and threshold decryption schemes that prevent any single party from front-running. Flashbots's writings are one of the more readable entry points into the current research; Shutter Network is one of the encrypted-mempool projects with shipping infrastructure. None of these will eliminate MEV entirely, but they constrain extractive MEV without breaking useful arbitrage.
​

The user-side takeaway is concrete. For DEX trades, route through an intent-based DEX or a private RPC. For cross-chain transfers, prefer intent-based settlement to bridge-and-swap flows. For high-value institutional trades, RFQ systems or off-chain settlement layers remain the most MEV-protected option. Each of these is available today; the question is integration rather than research.
​

One last framing worth carrying away: MEV is not a single phenomenon but a category of value flows that depend on transaction ordering. Some flows are competitive arbitrage that closes pricing gaps and benefits the broader market. Some flows are extractive sandwiches that transfer value from a user to a bot that contributed nothing economic. Mitigations target the second category without breaking the first, which is why "kill MEV" is the wrong frame and "shift who captures it" is the right one. The intent-based model — the user gets a guaranteed quote, the solver competes on execution, the MEV that exists lives at the solver layer — is the most user-aligned way of doing that shift. Flashbots's documentation and CoW Protocol's documentation are the two best ongoing references for the engineering details.
​

No. Some MEV reflects genuine economic activity, like arbitrage that closes price gaps between markets. The patterns that consistently transfer value from users — sandwich attacks, opportunistic front-running of known transactions — are the extractive subset. Mitigations target those without preventing useful arbitrage.
​

Gas fees are the protocol-level payment for transaction execution. MEV is the additional value capturable by ordering transactions in a particular way. A transaction can be cheap in gas but expensive in MEV exposure (a public-mempool DEX trade), or expensive in gas but MEV-free (a private-RPC transaction with a guaranteed price).
​

Probably not. As long as transactions are ordered, someone has the power to choose the order, and that power has value. The realistic goal is to reduce extractive MEV (sandwiches, opportunistic front-running) while leaving useful MEV (arbitrage that closes price gaps) functional, and to redistribute the captured value back to users where possible.
​

Proposer-builder separation splits block production into two roles: builders, who assemble candidate blocks from searcher bundles and mempool transactions; and proposers (validators), who pick the highest-bidding block. The split lets validators capture MEV revenue without running sophisticated MEV extraction infrastructure, and it limits censorship by introducing competing builders.
​

Yes. Solana, Avalanche, Cosmos chains, and every L2 with public transaction ordering have MEV. The amount and shape vary by chain design — Solana's leader-schedule produces different MEV dynamics than Ethereum's slot-based proposer-builder separation. The conceptual core is the same: whoever orders transactions captures the ordering value.
​

For deeper context on related concepts, see Eco's articles on CoW Swap, UniswapX, intents and solvers, Aori intent settlement, intent-based DEX comparison, cross-chain intent protocols, Layer 2 networks, block explorers, trustless systems, and externally owned accounts.
​

Sources and methodology. MEV pattern definitions verified against the Flash Boys 2.0 paper and Flashbots research writings. Extraction figures cross-referenced between EigenPhi and Flashbots MEV-Explore. Stablecoin and protocol TVL data pulled from DeFiLlama on April 29, 2026. Builder market share figures cross-checked against relayscan.io. Figures refresh quarterly.
​