Skip to main content

MEV IN SPACE (1)

1. DEX & Trading-Related MEV​

  • Front-Running: Submitting a transaction ahead of a victim’s trade to profit from price changes.
  • Back-Running: Placing transactions after a victim’s trade (e.g., selling after a large buy order).
  • Sandwich Attacks: Combining front- and back-running around a victim’s trade to extract value.
  • Arbitrage: Exploiting price discrepancies between pools, DEXes, or assets (e.g., triangular arbitrage).
  • Limit Order Sniping: Triggering limit orders by manipulating prices to execute favorable trades.
  • Liquidity Pool Manipulation: Adding/removing liquidity to distort prices before trading.
  • JIT (Just-In-Time) Liquidity: Providing liquidity milliseconds before large trades to capture fees, then withdrawing it.
  • Multi-Block MEV: Strategies spanning multiple blocks (e.g., latency-sensitive cross-block arbitrage).

2. Lending & Borrowing Protocols​

  • Liquidation MEV: Racing to liquidate undercollateralized loans for rewards.
  • Collateral Swap Front-Running: Exploiting users adjusting collateral types.
  • Flash Loan MEV: Using flash loans to manipulate markets (e.g., pump-and-dump schemes).
  • Interest Rate Arbitrage: Profiting from delayed updates to borrowing/lending rates.

3. NFT Markets​

  • NFT Sniping: Buying undervalued NFTs listed at incorrect prices.
  • Auction Sniping: Placing last-minute bids in NFT auctions.
  • Rarity Manipulation: Artificially inflating NFT rarity metrics (e.g., trait flipping).

4. Consensus & Block Production​

  • Time-Bandit Attacks: Reorganizing past blocks to retroactively extract MEV.
  • Transaction Reordering: Prioritizing transactions within a block for profit.
  • Censorship: Excluding transactions to suppress competition (e.g., hiding liquidations).
  • Block Stuffing: Including spam transactions to delay others’ trades.

5. Governance & DAOs​

  • Proposal Front-Running: Profiting from governance changes before they’re enacted.
  • Vote Manipulation: Accumulating tokens to swing governance outcomes.
  • Parameter Exploitation: Altering protocol parameters (e.g., fees, rewards) for gain.

6. Cross-Chain & Bridges​

  • Bridge Latency Exploitation: Profiting from delays in cross-chain asset transfers.
  • Cross-Chain Arbitrage: Exploiting price differences between chains (e.g., ETH vs. BNB).

7. Oracles & Price Feeds​

  • Oracle Manipulation: Front-running price feed updates to distort DeFi markets.
  • Data Feed MEV: Exploiting latency in decentralized oracles (e.g., Chainlink).

8. Stablecoins & Pegged Assets​

  • Peg Arbitrage: Capitalizing on deviations from pegs (e.g., DAI, USDC).
  • Mint/Redeem Front-Running: Profiting from stablecoin issuance/redemption mechanisms.

9. Options & Derivatives​

  • Pricing Arbitrage: Exploiting mispriced options or futures.
  • Exercise Front-Running: Manipulating large options exercises.

10. Token Launches & IDOs​

  • Initial Liquidity Sniping: Buying tokens at launch before price surges.
  • Fair Launch Exploits: Bypassing anti-bot mechanisms in token sales.

11. MEV Infrastructure & Tools​

  • Private Mempools: Using Flashbots or private RPCs to hide transactions.
  • Mempool Snooping: Monitoring public mempools for profitable opportunities.
  • RPC Node Exploitation: Extracting transaction data from nodes early.

12. Layer-2 & Rollups​

  • Sequencer MEV: Rollup sequencers reordering transactions for profit.
  • Cross-Layer MEV: Arbitrage between L1 and L2 (e.g., Optimism, Arbitrum).

13. Gas & Fees​

  • Gas Auctions: Bidding higher gas fees to prioritize transactions.
  • Gas Token Arbitrage: Profiting from gas token price fluctuations (e.g., CHI, GST2).

14. Yield Farming & Staking​

  • Reward Sniping: Depositing into farms just before reward distribution.
  • Staking Pool Manipulation: Influencing validator rewards in PoS systems.

15. Privacy & Anonymity​

  • Privacy Pool Exploits: Front-running transactions in mixers (e.g., Tornado Cash).
  • Deanonymization Attacks: Linking addresses to exploit hidden strategies.

16. Insurance Protocols​

  • Payout Triggering: Creating conditions to claim insurance payouts (e.g., Nexus Mutual).

17. Decentralized Storage/Compute​

  • Storage Deal Sniping: Grabbing undervalued storage/compute resources.

18. Gaming & Metaverses​

  • In-Game Asset MEV: Sniping rare items or manipulating virtual economies.

19. Rebasing Tokens​

  • Supply Adjustment Arbitrage: Front-running token rebases (e.g., AMPL).

20. Long-Tail Assets​

  • Low-Liquidity MEV: Exploiting price impact in illiquid markets.

21. Failed Transaction MEV​

  • Failure Exploitation: Profiting from failed transactions (e.g., gas-griefing).

22. Zero-Knowledge Systems​

  • Proof-Time Manipulation: Influencing ZK-proof generation for MEV.

23. Tax & Compliance​

  • Tax Loss Harvesting: Automated tax optimization via MEV (theoretical).

24. Decentralized Identity​

  • Attestation MEV: Front-running credential updates (e.g., ENS domains).

25. Cross-Domain MEV​

  • Multi-Protocol MEV: Combining strategies across DeFi, NFTs, and governance.

DEX Exploits via x*y=k Formula​

  • Protocol: Uniswap, PancakeSwap, SushiSwap

    MEV Type: Sandwich attacks, JIT liquidity

    How It Fails: Bots front-run large swaps by adjusting liquidity or trading ahead, exploiting slippage.

    Example: A user swaps 100 ETH for USDC on Uniswap. A bot detects the tx in the mempool, front-runs it by buying ETH (raising the price), lets the user’s swap execute at a worse rate, then back-runs by selling ETH for profit.

2. Curve Finance Stablecoin Arbitrage​

  • Protocol: Curve (StableSwap invariant)

    MEV Type: Peg arbitrage

    How It Fails: Bots exploit minor stablecoin (e.g., USDC vs. USDT) price deviations across pools.

    Example: If USDC depegs to 0.99onCurve,botsbuyUSDCcheaplyonCurveandsellat0.99onCurve,botsbuyUSDCcheaplyonCurveandsellat1 on Binance or Uniswap.

3. Aave/Compound Liquidations​

  • Protocol: Aave, Compound

    MEV Type: Liquidation racing

    How It Fails: Bots compete to liquidate undercollateralized loans first to claim rewards (e.g., 5% liquidation bonus).

    Example: A $1M ETH position drops below collateral threshold. Bets use flash loans to liquidate it in milliseconds, profiting from the bonus.

4. Flash Loan Oracle Manipulation​

  • Protocol: Mango Markets (Solana), Euler Finance

    MEV Type: Oracle price manipulation

    How It Fails: Attackers borrow large sums via flash loans to artificially inflate/deflate an asset’s price on a DEX, triggering faulty oracle feeds.

    Example: Mango Markets exploit ($116M loss): Attacker pumped MNGO price via flash loans, borrowed against inflated collateral, and drained the protocol.

5. OpenSea NFT Sniping​

  • Protocol: OpenSea, Blur

    MEV Type: NFT sniping

    How It Fails: Bots scan for mispriced NFTs (e.g., rare Bored Ape listed for 1 ETH instead of 100 ETH) and snipe them before humans.

    Example: A user accidentally lists an NFT for 1 ETH due to a typo. Bots detect and instantly buy it, reselling for 100x.

6. Synthetix Futures Front-Running​

  • Protocol: Synthetix (Kwenta)

    MEV Type: Front-running leveraged positions

    How It Fails: Bots detect large futures orders and trade ahead to move prices, causing the user’s position to liquidate.

    Example: A user opens a $10M ETH long. Bots front-run, pump ETH price temporarily, then short to trigger the user’s stop-loss.

7. Balancer Pool Rebalancing​

  • Protocol: Balancer

    MEV Type: Index fund arbitrage

    How It Fails: Bots exploit price discrepancies when Balancer pools auto-rebalance.

    Example: If a Balancer pool holds 50% ETH and 50% BTC, bots front-run rebalancing trades to profit from predictable price impact.

8. THORChain Cross-Chain MEV​

  • Protocol: THORChain

    MEV Type: Cross-chain arbitrage

    How It Fails: Price differences between native ETH (Ethereum) and synthetic ETH (Binance Chain) create arbitrage.

    Example: ETH trades at 1,800onUniswapbut1,800onUniswapbut1,820 on PancakeSwap. Bots swap ETH across chains to pocket the $20 gap.

  • Protocol: Chainlink-reliant protocols (e.g., Venus Protocol)

    MEV Type: Oracle latency exploitation

    How It Fails: Bots exploit delays in Chainlink price updates (e.g., 1-2 minutes) to manipulate markets.

    Example: ETH price crashes on Binance, but Chainlink feed takes 60 seconds to update. Bots liquidate positions on Venus before the oracle reflects the drop.

10. dYdX Stop-Loss Hunting​

  • Protocol: dYdX (Perpetual Swaps)

    MEV Type: Stop-loss hunting

    How It Fails: Bots push prices to trigger cascading liquidations, profiting from short squeezes or long crashes.

    Example: Bots orchestrate a temporary ETH price drop to trigger $50M in long liquidations, then buy ETH cheaply and profit from the rebound.

11. MakerDAO Peg Stability Module (PSM)​

  • Protocol: MakerDAO

    MEV Type: Mint/redeem front-running

    How It Fails: When DAI deviates from 1,botsracetomint/redeemDAIviathePSM.∗∗Example∗∗:DAItradesat1,botsracetomint/redeemDAIviathePSM.∗∗Example∗∗:DAItradesat0.99 on Coinbase. Bots mint DAI for 1viaMakerDAO’sPSMandsellitonCoinbasefor1viaMakerDAO’sPSMandsellitonCoinbasefor0.99, pocketing $0.01 per DAI.

12. Uniswap V3 Limit Order Sniping​

  • Protocol: Uniswap V3 (Concentrated Liquidity)

    MEV Type: Range order sniping

    How It Fails: Bots detect limit orders near current prices and manipulate the price to execute them.

    Example: A user sets a limit order to buy ETH at 1,800.BotstemporarilypushETHto1,800.BotstemporarilypushETHto1,800, trigger the order, then revert the price.

13. SushiSwap Onsen Farms​

  • Protocol: SushiSwap

    MEV Type: Reward sniping

    How It Fails: Bots deposit into liquidity pools seconds before rewards are distributed, then withdraw immediately after.

    Example: A pool offers 10,000 SUSHI rewards daily. Bots add liquidity at 11:59:59 UTC, claim rewards at 00:00:00, and exit by 00:00:05.

14. Blur NFT Bidding​

  • Protocol: Blur

    MEV Type: Bid sniping

    How It Fails: Bots place bids just below the floor price, snipe newly listed NFTs, and relist them higher.

    Example: NFT floor is 1 ETH. Bots auto-bid 0.99 ETH on new listings, buy undervalued NFTs, and resell at 1.05 ETH.

15. GMX Liquidation Cascades​

  • Protocol: GMX

    MEV Type: Liquidation cascades

    How It Fails: Large leveraged positions on GMX are targeted with price manipulation via low-liquidity oracles (e.g., AVAX on Trader Joe).

    Example: A $10M long position on GMX is liquidated after bots dump AVAX on Trader Joe to lower the oracle price.

16. Convex Finance CRV Bribes​

  • Protocol: Convex Finance

    MEV Type: Governance bribes

    How It Fails: Bribers pay CVX holders to vote for pools that maximize their MEV opportunities (e.g., favoring high-fee pools).

    Example: A protocol bribes CVX voters to direct CRV emissions to their pool, enabling front-running on associated DEXes.

17. Tornado Cash Privacy Pool Withdrawals​

  • Protocol: Tornado Cash

    MEV Type: Withdrawal snooping

    How It Fails: Bots monitor Tornado withdrawals and link addresses to front-run subsequent transactions (e.g., NFT mints).

    Example: A user withdraws 100 ETH from Tornado. Bots track their address and front-run their next DEX trade.

18. 1inch Limit Order Griefing​

  • Protocol: 1inch Limit Orders

    MEV Type: Gas griefing

    How It Fails: Bots fill limit orders but set gas prices too low, causing transactions to fail while still profiting.

    Example: A user’s limit order to sell ETH at $2,000 is matched, but the bot’s tx fails due to low gas, leaving the user’s order open for exploitation.

19. Frax Finance AMO (Algorithmic Market Ops)​

  • Protocol: Frax

    MEV Type: Algorithmic mint/redeem arbitrage

    How It Fails: Bots exploit delays in Frax’s AMO rebalancing between FRAX and collateral.

    Example: If FRAX trades below 1,botsbuyFRAX,redeemitfor1,botsbuyFRAX,redeemitfor1 via Frax’s AMO, and profit from the spread.

20. Optimism Bedrock Sequencing​

  • Protocol: Optimism

    MEV Type: Sequencer reordering

    How It Fails: Optimism’s sequencer reorders transactions to extract cross-domain MEV (e.g., DEX trades + bridge actions).

    Example: A user bridges ETH from L1 to Optimism and swaps it. The sequencer front-runs the swap by milliseconds.

Mitigation Strategies for Your Chain​

  1. Encrypted Mempools: Hide transaction intent (e.g., SUAVE, FCFS lanes).
  2. Fair Ordering: Use time-based (e.g., FIFO) or randomness (e.g., RANDAO) for tx ordering.
  3. Oracles with TWAPs: Use time-weighted average prices (e.g., Uniswap V3 TWAPs).
  4. Batch Auctions: Aggregate trades in discrete time intervals (e.g., CowSwap).
  5. Threshold Encryption: Encrypt txs until block inclusion (e.g., Shutter Network).