MEV Extraction Strategies: Sandwich, Arbitrage, Liquidations

DEX Arbitrage:      45%  ────────────────────────────── $1.125B
Liquidations:       30%  ───────────────────── $750M
Sandwich Attacks:   20%  ────────────── $500M
JIT Liquidity:      3%   ──── $75M
Other (backrunning, 2%  ── $50M
time-bandit, etc.)

Pre-PBS (2022):        Post-PBS (2026):
  Miners: 80%            Block Builders: 45%
  Searchers: 15%        Searchers: 30%
  Users (loss): -5%     Validators: 20%
                         Users (loss): -5%
                          Protocol treasuries: 5% (via MEV burn)

Key change: PBS redistributed MEV from validators to builders.
             Searchers still compete, but builders capture the spread.

Arbitrage opportunity:
  Pool A (Uniswap V3): 1 ETH = 3,200 USDC
  Pool B (Curve):      1 ETH = 3,215 USDC

  Profit: 15 USDC per ETH arbitraged

  Arbitrage bot:
  1. Buy ETH on Pool A for 3,200 USDC
  2. Sell ETH on Pool B for 3,215 USDC
  3. Profit: 15 USDC (minus gas: ~$2-5)

  Net: ~$10-13 per arbitrage

Example: ETH → USDC → DAI → ETH
  Uniswap V3 (ETH/USDC): 1 ETH = 3,200 USDC
  Sushiswap (USDC/DAI):  1 USDC = 0.98 DAI
  Balancer (DAI/ETH):    1 DAI = 0.00031 ETH

  Net: 1 ETH → 3,200 USDC → 3,136 DAI → 0.972 ETH
  Profit: 0.028 ETH (~$90) minus gas (~$30)
  Net profit: ~$60

// On-chain example of an arbitrage transaction
// Tx: 0xabcd... on block 19,500,000

// 1. Flash loan 5,000 ETH from Aave
// 2. Swap on Uniswap V3: 5,000 ETH → 16,000,000 USDC
// 3. Swap on Curve: 16,000,000 USDC → 5,050 ETH
// 4. Repay flash loan: 5,000 ETH + 0.1 ETH fee
// 5. Profit: 49.9 ETH (~$160K)

// Gas used: 350,000
// Gas price: 50 gwei
// Gas cost: 0.0175 ETH ($56)
// Net profit: $159,944

Lending protocol (Aave):

Borrower deposits 100 ETH as collateral ($320K)
Borrows 75 ETH ($240K) → Health factor: 1.33

ETH price drops 25% → Collateral now worth $240K
Loan is $240K → Health factor: 1.0

Anyone can liquidate:
  1. Repay $48K of the loan (20% of debt)
  2. Receive $48K worth of collateral + liquidation bonus
  3. Bonus: 5-10% on Aave = $2,400-$4,800 profit

# Simplified liquidation bot logic
def monitor_positions():
    while True:
        # Scan all lending protocols for positions near liquidation
        for protocol in ["aave", "compound", "morpho", "spark"]:
            positions = protocol.get_risky_positions(health_factor < 1.05)

            for position in positions:
                if position.health_factor < 1.0:
                    # Calculate profitability
                    gas_cost = estimate_gas(protocol)
                    bonus = position.debt * protocol.liquidation_bonus
                    profit = bonus - gas_cost

                    if profit > 0:
                        # Submit liquidation bundle
                        send_bundle_to_builders(
                            txs=[protocol.liquidate(position)],
                            tip=profit * 0.3,  # Bid 30% of profit to builder
                        )

The liquidation market is EXTREMELY competitive:

Ethereum: ~200 professional liquidation bots
  - Top 10 bots capture 70% of all liquidations
  - Average time to liquidate after price change: 3-5 seconds
  - Profit per liquidation: $500-$50,000 (depends on loan size)

Solana: ~50 liquidation bots
  - Faster execution (400ms block time)
  - Higher competition due to no mempool
  - Profit per liquidation: $100-$10,000

Key advantage: Low-latency oracle price feeds
  - Chainlink price updates are the trigger
  - First bot to detect new price and submit wins
  - Latency matters: 100ms = 20% lower win rate

User transaction: Swap 10 ETH for USDC on Uniswap

Sandwich attack:

1. FRONT-RUN: Attacker swaps 5 ETH for USDC
   → Price moves: 1 ETH = 3,200 → 3,180 USDC

2. VICTIM: User's swap executes at worse price
   → User gets 31,800 USDC instead of 32,000
   → User loses: 200 USDC (0.6% slippage)

3. BACK-RUN: Attacker sells USDC back for ETH at better price
   → Price recovers after user's trade
   → Attacker profits: ~180 USDC (minus gas)

Attacker profit: ~$180 on a single sandwich
Gas cost: ~$30 (high priority gas)
Net profit: ~$150

Arguments FOR sandwiches:
  - They're "tax" on uninformed traders
  - They provide profit to searchers who secure blocks
  - Slippage protection is the user's responsibility

Arguments AGAINST sandwiches:
  - They're extractive (not value-creating like arbitrage)
  - They harm retail users
  - They increase gas costs for everyone
  - They're the reason for MEV-Burn proposals

Etherscan transaction analysis:

Original user tx: 0xswap...
  Gas price: 20 gwei
  Slippage: 5%

Front-run tx: 0xsandwich_front...
  From: 0xMEVBot
  Gas price: 30 gwei (higher = priority)
  Same block, same pool, opposite direction

Back-run tx: 0xsandwich_back...
  From: 0xMEVBot (same address)
  Gas price: 25 gwei
  Same block, reverses the front-run

Classic signature: Same address, same block,
opposite trades around user transaction.

1. Searcher detects large pending swap (e.g., 1,000 ETH → USDC)
2. Adds concentrated liquidity at the expected swap price range
3. Large swap executes, paying fees to the liquidity position
4. Searcher removes liquidity immediately

Profit: Fee tier × swap volume
  Fee tier: 0.01%, 0.05%, 0.30%, 1.00%
  Swap volume: 1,000 ETH ($3.2M)
  At 0.05% fee: $1,600 in fees for a single swap

Better than sandwiching:
  - Less harmful to users (no price manipulation)
  - Legitimate value-add (provides liquidity)
  - Lower risk of being front-run

Types of backrunning:
1. Post-arb: Back-run an arbitrageur's trade
   → If arbitrage corrects price, follow with a small trade

2. Oracle update backrun: Trade after oracle price update
   → Chainlink updates price → trade on the new price

3. Transaction backrun: Execute after a known trader
   → Some whales signal trades (large approvals, etc.)
   → Trade in the same direction after they move the market

Pre-PBS:
  Validator:          [Mempool] → Select txs → [Block]

Post-PBS:
                      ┌────────────────────┐
                      │  User / Searcher   │
                      │  Submit bundle     │
                      └─────────┬──────────┘
                                │
                     ┌──────────▼──────────┐
                     │   Block Builder     │
                     │  (Optimized, MEV    │
                     │   extraction engine)│
                     └──────────┬──────────┘
                                │ Block bid
                     ┌──────────▼──────────┐
                     │   Relay (e.g.,     │
                     │  Flashbots, bloxR) │
                     └──────────┬──────────┘
                                │ Best block
                     ┌──────────▼──────────┐
                     │   Validator         │
                     │  (Proposer)         │
                     │  Select best block  │
                     └─────────────────────┘

# Using Flashbots SDK (or mev-geth)
from flashbots import flashbots

# 1. Create your bundle of transactions
bundle = [
    {"to": "0x...", "data": "0x...", "gas": 100000},
    {"to": "0x...", "data": "0x...", "gas": 50000},
]

# 2. Bundle must be valid (simulate first)
sim_result = flashbots.simulate_bundle(bundle, block_number=19500000)

if sim_result.success:
    profit = sim_result.profit

    # 3. Bundle pays builder a tip (bribe)
    tip = int(profit * 0.3)  # 30% of profit to builder
    bundle[0]["maxPriorityFeePerGas"] = tip

    # 4. Submit to builder via relay
    result = flashbots.send_bundle(
        bundle,
        target_block=19500000,
        min_timestamp=current_time,
    )

    # 5. Compete: submit to MULTIPLE builders simultaneously
    for builder in ["flashbots", "beaverbuild", "titan"]:
        flashbots.send_to_builder(builder, bundle, tip)

Solana has no public mempool — validators see transactions immediately.

MEV on Solana:
1. Arbitrage: Same as Ethereum but faster
   - 400ms block time = must react in <100ms
   - Requires colocation with validators

2. Liquidations: Very fast
   - Oracle price changes → immediate liquidation opportunity
   - First to detect wins (no mempool = no gas war)

3. Sandwich: Much harder (no mempool)
   - But: Jito (Solana's MEV platform) enables "mempool-like" features
   - Searchers can pay validators for "priority" access
   - More difficult but still possible

Solana MEV market: Jito Labs handles ~80% of Solana MEV
  - Top searchers: pay validators directly via "tips"
  - Total MEV: ~$800M/year and growing

L2s have centralized sequencers that control transaction ordering:

Arbitrum:
  - Sequencer processes txs in order received
  - MEV possible during "sequencer delay" (10 min)
  - Most MEV is cross-L2 arbitrage (Arbitrum ↔ Ethereum)

Optimism:
  - Similar to Arbitrum
  - MEV primarily from interop between OP Stack chains

Base:
  - Coinbase-operated sequencer
  - Minimal MEV (Coinbase's policy limits it)
  - Most MEV is from bridging/arbing with Ethereum

Total L2 MEV: ~$300M/year (growing as L2 TVL grows)

Flashbots Protect RPC:
  - Sends txs directly to builders (not mempool)
  - 80-90% of sandwiches prevented
  - However: some builders still sandwich
  - Cost: free ($0 for basic protection)

CowSwap:
  - 100% sandwich protection (batch auctions)
  - Best price across all DEXes
  - No gas cost (solver pays)
  - Recommended for all traders >$1K

UniswapX:
  - Dutch auction protects against sandwich
  - Fillers compete = best execution
  - Partial fills possible
  - Built into Uniswap interface

from web3 import Web3
import json

class ArbitrageFinder:
    def __init__(self, w3: Web3):
        self.w3 = w3
        self.pools = self._load_pools()

    def find_arbitrage(self):
        """Scan all tracked pools for arbitrage opportunities."""
        opportunities = []

        for pool_a in self.pools:
            for pool_b in self.pools:
                if pool_a.address == pool_b.address:
                    continue

                price_a = pool_a.get_price()
                price_b = pool_b.get_price()

                if price_a < price_b:
                    profit_pct = (price_b - price_a) / price_a * 100

                    if profit_pct > 0.3:  # Min 0.3% profit
                        opportunities.append({
                            "buy_pool": pool_a,
                            "sell_pool": pool_b,
                            "profit_pct": profit_pct,
                            "estimated_profit": self._estimate_profit(
                                pool_a, pool_b
                            ),
                        })

        return sorted(opportunities, key=lambda x: -x["profit_pct"])

    def build_bundle(self, opportunity, amount):
        """Build a Flashbots bundle for the arbitrage."""
        return [
            # 1. Flash loan from Aave
            self._flash_loan(amount),
            # 2. Swap on buy pool
            opportunity["buy_pool"].build_swap(amount, direction="buy"),
            # 3. Swap on sell pool
            opportunity["sell_pool"].build_swap(
                self._expected_output(opportunity), direction="sell"
            ),
            # 4. Repay flash loan
            self._repay_flash_loan(amount),
        ]