MEV: Maximal Extractable Value and Protection

MEV (Maximal Extractable Value) is profit extracted by reordering, including, or excluding transactions in blocks.

What is MEV?

MEV represents the maximum value that can be extracted from block production by manipulating transaction order.

Sources of MEV

1. Arbitrage: Price differences across DEXs
2. Liquidation: Liquidating undercollateralized positions
3. Front-running: Seeing pending transactions and executing first
4. Sandwich Attacks: Placing orders before and after target transaction
5. Back-running: Following profitable transactions

Types of MEV

1. Arbitrage

RUST
Copy
struct ArbitrageOpportunity {
    dex_a: String,
    dex_b: String,
    token: String,
    price_a: u64,
    price_b: u64,
    profit: u64,
}

struct ArbitrageBot {
    dexes: Vec<String>,
    min_profit: u64,
}

impl ArbitrageBot {
    fn find_opportunity(&self, token: &str) -> Option<ArbitrageOpportunity> {
        // Compare prices across DEXs
        // Find profitable arbitrage
        
        // Example: Buy on DEX A, sell on DEX B
        let price_a = self.get_price("dex_a", token);
        let price_b = self.get_price("dex_b", token);
        
        if price_b > price_a {
            let profit = price_b - price_a - self.calculate_fees(price_a);
            if profit > self.min_profit {
                return Some(ArbitrageOpportunity {
                    dex_a: String::from("dex_a"),
                    dex_b: String::from("dex_b"),
                    token: token.to_string(),
                    price_a,
                    price_b,
                    profit,
                });
            }
        }
        
        None
    }
    
    fn execute_arbitrage(&self, opportunity: &ArbitrageOpportunity) -> Result<u64, String> {
        // Execute buy on DEX A
        // Execute sell on DEX B
        // Return profit
        Ok(opportunity.profit)
    }
}

2. Front-Running

RUST
Copy
// Front-running: See pending transaction, execute similar one first
struct PendingTransaction {
    hash: String,
    from: String,
    to: String,
    data: Vec<u8>,
    gas_price: u64,
}

struct FrontRunner {
    mempool: Vec<PendingTransaction>,
}

impl FrontRunner {
    fn detect_opportunity(&self, tx: &PendingTransaction) -> bool {
        // Detect if transaction is profitable (e.g., large DEX swap)
        // If yes, front-run it with higher gas price
        
        // Check if it's a DEX swap
        if self.is_dex_swap(tx) {
            // Estimate price impact
            let impact = self.estimate_price_impact(tx);
            return impact > self.min_profit_threshold;
        }
        
        false
    }
    
    fn front_run(&self, target_tx: &PendingTransaction) -> PendingTransaction {
        // Create similar transaction with higher gas price
        PendingTransaction {
            hash: String::from("front_run_tx"),
            from: String::from("attacker"),
            to: target_tx.to.clone(),
            data: self.modify_data(&target_tx.data),
            gas_price: target_tx.gas_price + 1, // Higher gas to get included first
        }
    }
}

3. Sandwich Attack

RUST
Copy
struct SandwichAttack {
    front_tx: PendingTransaction,
    target_tx: PendingTransaction,
    back_tx: PendingTransaction,
}

impl SandwichAttack {
    fn create_sandwich(&self, target: &PendingTransaction) -> SandwichAttack {
        // Front-run: Buy before target
        let front_tx = self.create_buy_tx(target);
        
        // Target transaction (victim's swap)
        let target_tx = target.clone();
        
        // Back-run: Sell after target (at better price)
        let back_tx = self.create_sell_tx(target);
        
        SandwichAttack {
            front_tx,
            target_tx,
            back_tx,
        }
    }
    
    fn execute(&self) -> Result<u64, String> {
        // Execute in order: front -> target -> back
        // Profit from price manipulation
        Ok(0)
    }
}

MEV Protection

1. Private Mempools (Flashbots)

Flashbots provides a private mempool to prevent front-running:

RUST
Copy
struct FlashbotsBundle {
    transactions: Vec<PendingTransaction>,
    block_number: u64,
    min_timestamp: Option<u64>,
    max_timestamp: Option<u64>,
}

struct FlashbotsProtection {
    bundles: Vec<FlashbotsBundle>,
}

impl FlashbotsProtection {
    fn create_bundle(&mut self, txs: Vec<PendingTransaction>) -> FlashbotsBundle {
        FlashbotsBundle {
            transactions: txs,
            block_number: 0,
            min_timestamp: None,
            max_timestamp: None,
        }
    }
    
    fn submit_bundle(&self, bundle: &FlashbotsBundle) -> Result<(), String> {
        // Submit to Flashbots relay
        // Transactions are private until included in block
        // Prevents front-running
        Ok(())
    }
}

2. Commit-Reveal Scheme

RUST
Copy
struct CommitReveal {
    commitment: Vec<u8>, // hash(secret + transaction_data)
    reveal_block: u64,
}

impl CommitReveal {
    fn commit(&self, secret: &[u8], tx_data: &[u8]) -> Vec<u8> {
        // Hash secret + transaction data
        // Submit commitment first
        // Reveal later
        vec![]
    }
    
    fn reveal(&self, secret: &[u8], tx_data: &[u8], commitment: &[u8]) -> bool {
        // Verify commitment matches
        // Execute transaction if valid
        true
    }
}

3. Time-Delayed Execution

RUST
Copy
struct TimeDelayedTx {
    transaction: PendingTransaction,
    execute_after: u64, // Block number
}

impl TimeDelayedTx {
    fn create_delayed_tx(tx: PendingTransaction, delay: u64) -> Self {
        TimeDelayedTx {
            transaction: tx,
            execute_after: current_block() + delay,
        }
    }
    
    fn can_execute(&self, current_block: u64) -> bool {
        current_block >= self.execute_after
    }
}

4. Slippage Protection

RUST
Copy
struct SwapWithSlippage {
    amount_in: u64,
    min_amount_out: u64, // Minimum acceptable output
    max_slippage: u8,    // Percentage (e.g., 1 = 1%)
}

impl SwapWithSlippage {
    fn execute_swap(&self, pool: &AMMPool) -> Result<u64, String> {
        let amount_out = pool.calculate_output(self.amount_in);
        
        // Check slippage
        let expected_out = self.amount_in; // Simplified
        let slippage = ((expected_out - amount_out) * 100) / expected_out;
        
        if slippage > self.max_slippage as u64 {
            return Err(String::from("Slippage too high"));
        }
        
        if amount_out < self.min_amount_out {
            return Err(String::from("Output below minimum"));
        }
        
        Ok(amount_out)
    }
}

Real-World Examples

• Flashbots: Private mempool, MEV protection
• CowSwap: Batch auctions, MEV protection
• 1inch: DEX aggregator with MEV protection
• Uniswap V3: Concentrated liquidity, reduced MEV

Best Practices

1. Use Private Mempools: Flashbots for sensitive transactions
2. Set Slippage Limits: Protect against sandwich attacks
3. Batch Transactions: Reduce MEV opportunities
4. Time Delays: Delay execution to prevent front-running
5. Commit-Reveal: Hide transaction details until execution