Application-Level MEV

The value extraction opportunity is created by the application's own rules and smart contract functions. Common examples include:

• Liquidation auctions in lending protocols (e.g., seizing collateral at a discount).
• Arbitrage between different liquidity pools within the same DEX.
• Frontrunning user orders in an on-chain order book or limit order DEX.
• Optimal fee collection in NFT marketplaces or aggregators.

A key distinction from Protocol-Level MEV is that the extracted value is often captured by or for the benefit of the application and its users. Mechanisms include:

• Backrunning user transactions to capture slippage or fees for the protocol treasury.
• Permissioned searchers who are whitelisted to execute specific functions (like liquidations) and share profits.
• In-protocol auctions (e.g., MEV auctions) where the right to execute a profitable operation is sold, with proceeds going to users or stakers.

Specialized actors, known as searchers, compete to identify and execute profitable A-MEV opportunities. Their strategies involve:

• Monitoring application state (e.g., loan health, pool imbalances).
• Simulating transactions to calculate potential profit.
• Bidding for execution rights via gas auctions or in-protocol mechanisms.
• Using private transaction channels (like Flashbots Protect or Titan) to bundle and submit their transactions.

A-MEV can have direct positive or negative effects on end-users. Applications implement design patterns to manage it:

• Negative Impact: Users may experience frontrunning, worse prices (slippage), or failed transactions.
• Positive Redistribution: Protocols can use MEV recapture to refund users or boost yields.
• Mitigation Tools: Fair sequencing, commit-reveal schemes, and private mempools (e.g., SUAVE) aim to reduce harmful extraction.

Real-world protocols that define and manage A-MEV:

• Compound & Aave: Liquidators compete to repay undercollateralized loans and claim collateral at a bonus.
• CowSwap & 1inch: Use batch auctions and solvers to find the best price, capturing slippage as protocol fees.
• EigenLayer: Proposes MEV-Boost++ where validators can run application-specific solo-validators for A-MEV.
• UniswapX: Uses fillers in a Dutch auction to execute swaps, competing on price.

A-MEV exists alongside and interacts with Protocol-Level MEV (e.g., DEX arbitrage, sandwich attacks). Key differences:

• Scope: A-MEV is app-specific; Protocol MEV is chain-wide (e.g., cross-DEX arb).
• Capture: A-MEV value flow is often internalized by the dApp's economic design.
• Execution: A-MEV transactions are often calldata-intensive (complex logic) versus Protocol MEV's gas-intensive simple swaps.
• Stack: Both types of MEV are ultimately settled and ordered by the block builder layer.

The most common example, where bots monitor protocols like Aave or Compound for undercollateralized loans. Key actions include:

• Monitoring loan-to-value ratios in real-time.
• Executing the liquidation transaction, repaying the user's debt.
• Seizing the collateral at a discount as a reward. This is a critical, permissionless function for maintaining protocol solvency, but bots compete on speed and gas to capture the profit.

Bots monitor NFT listings on marketplaces like Blur or OpenSea for mispriced assets. The process involves:

• Frontrunning a user listing an NFT below its perceived market value.
• Purchasing the asset before other users can.
• Reselling it immediately for a profit. This exploits the latency between a listing becoming visible on a public mempool and a human user being able to act.

Within a single Automated Market Maker (AMM), bots can exploit stale limit orders. When the external market price moves, a limit order to sell at a lower price becomes mispriced. Bots will:

• Purchase the asset via the limit order.
• Sell it instantly on another venue or pool at the higher market price. This extracts value from the order placer, not from the AMM's liquidity pools directly.

Sophisticated actors can exploit the timing of governance proposals in DAOs. Strategies include:

• Borrowing or purchasing governance tokens temporarily to influence a vote.
• Frontrunning proposals that will affect token value.
• Extracting value through the outcome (e.g., a passed proposal that benefits their other positions). This turns governance rights into a financialized asset for MEV extraction.

Proactive dApp design can mitigate negative externalities. Examples include:

• Private Transaction Pools (e.g., Flashbots Protect): Submitting user transactions privately to avoid frontrunning.
• Commit-Reveal Schemes: Hiding transaction intent until it's too late to frontrun.
• Fair Ordering: Protocol-level solutions that batch and order transactions to reduce adversarial advantages. These designs shift MEV from a predatory to a more predictable or redistributive force.

In protocols like Yearn Finance, strategies automatically move funds between vaults to optimize yield. MEV arises from:

• Information Asymmetry: Bots detect the rebalancing transaction in the mempool.
• Frontrunning: They execute the same move (e.g., a large swap) first, moving the price.
• Profit Capture: The bot profits from the price impact, while the aggregator's transaction gets a worse rate. This is a cost borne by the vault's depositors.

Regular participants whose transactions are the substrate for extraction. They are often the counterparties in MEV strategies and bear the cost through worse execution (slippage, failed transactions).

• Unprotected Users: Submit public mempool transactions vulnerable to front-running and sandwich attacks.
• Protected Users: Use MEV-aware wallets or protocols that route transactions through private channels (e.g., Flashbots RPC) to avoid predation.

Entities that sit between searchers and the chain, specializing in the extraction and sometimes redistribution of value. They provide infrastructure and liquidity for Application-Level MEV.

• Extractors: Services like Keeper networks that automatically execute specific logic (e.g., liquidations) for a fee.
• Aggregators: Platforms that match searchers' order flow with builder capacity and may offer MEV sharing or rebates back to the application or its users.

A cryptographic technique that separates transaction submission into two phases to hide intent. Users first submit a commitment (a hash of their transaction details) and later reveal the full transaction. This prevents frontrunners from seeing and copying profitable trades until it's too late to act. Used in early decentralized exchanges like 0x and in some NFT minting mechanisms.

Encrypts transaction content on-chain until a future block, using a decentralized network of validators or sequencers to decrypt it collectively. This prevents searchers from viewing pending transactions in the mempool. Protocols like Shutter Network implement this, allowing for fair ordering by making transaction content opaque until it is included in a block.

Directs user transactions through private channels instead of the public mempool. Services like Flashbots Protect RPC or BloXroute's Private Transactions send orders directly to block builders, bypassing public visibility. This shields users from sandwich attacks and reduces the success rate of generalized frontrunning bots.

Protocol-level rules that define a canonical order for transactions to prevent manipulation. This can be achieved through:

• First-Come, First-Served (FCFS): Ordering based on time of receipt by a trusted sequencer.
• Pessimistic Ordering: Assuming all transactions conflict and ordering them randomly or by fee.
• Leaderless Sequencing: Used in protocols like The Graph's L2, where nodes agree on order without a single leader.

Aggregates multiple orders and executes them simultaneously at a single, uniform clearing price. This eliminates the price-time priority of traditional continuous markets, making sandwich attacks impossible within the batch. Key examples include CowSwap (which uses batch auctions for settlement) and Vitalik Buterin's proposed designs for decentralized exchanges.

Architecting systems from the ground up to internalize and redistribute MEV. Strategies include:

• Proposer-Builder Separation (PBS): Separates block building from proposing, creating a competitive market for block space.
• MEV Redistribution: Using CFMMs (Constant Function Market Makers) with virtual balances or TWAMMs (Time-Weighted Average Market Makers) to smooth out large trades and reduce arbitrage profits.
• Schelling Point Coordination: Designing mechanisms where rational actors are incentivized to follow a protocol's fair rules.