MEV: Miner Extractable Value in Blockchain

// Simulating a sandwich attack
class SandwichBot {
  constructor() {
    this.flashbotsProvider = null;
  }
  
  async detectSandwich(targetTx) {
    // Parse the pending transaction
    const tx = await this.parseTransaction(targetTx);
    
    // Check if it's a profitable DEX swap
    if (tx.type === "swap" && tx.amount > 5) {
      // Calculate sandwich profit
      const swapImpact = await this.calculatePriceImpact(tx);
      const sandwichProfit = swapImpact * 0.8; // Capture 80% of slippage
      
      if (sandwichProfit > 0.01) { // Min 0.01 ETH profit
        console.log("Sandwich opportunity detected!");
        console.log(`Expected profit: ${sandwichProfit} ETH`);
        
        return {
          shouldExecute: true,
          frontRunAmount: tx.amount * 0.1, // 10% of target's size
          expectedProfit: sandwichProfit,
        };
      }
    }
    
    return { shouldExecute: false };
  }
  
  async executeSandwich(targetTx, frontRunAmount) {
    // Front-run: Buy before victim (drives price up)
    const frontRunTx = await this.createBuyTx(frontRunAmount);
    
    // Victim's transaction (now buys at higher price)
    const victimTx = targetTx;
    
    // Back-run: Sell after victim (at even higher price)
    const backRunTx = await this.createSellTx(frontRunAmount * 1.1);
    
    console.log("Sandwich executed:");
    console.log(`1. Bought at 100 (front-run)`);
    console.log(`2. Victim bought at 102 (slippage)`);
    console.log(`3. Sold at 101 (back-run)`);
    console.log(`Profit: ${(102 - 100) * frontRunAmount - (101 - 102) * 0} ETH`);
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract ArbitrageBot {
    address public uniswapV2;
    address public sushiswap;
    
    function executeArbitrage(uint256 _amount) external {
        // Step 1: Buy on Uniswap (cheaper)
        uint256 bought = swap(uniswapV2, address(WETH), address(USDC), _amount);
        
        // Step 2: Sell on Sushiswap (more expensive)
        uint256 received = swap(sushiswap, address(USDC), address(WETH), bought);
        
        // Profit check
        require(received > _amount, "No profit");
        uint256 profit = received - _amount;
        
        // Transfer profit to caller
        payable(msg.sender).transfer(profit);
    }
    
    function findArbitrage() external view returns (bool hasOpportunity, uint256 profit) {
        uint256 priceUni = getPrice(uniswapV2);
        uint256 priceSushi = getPrice(sushiswap);
        
        if (priceSushi > priceUni) {
            uint256 amountOut = (100 * priceUni) / 1e18;
            uint256 received = (amountOut * 1e18) / priceSushi;
            profit = received - 100;
            hasOpportunity = profit > 105; // 5% min profit after fees
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// Strategy 1: Commit-Reveal (prevents front-running)
contract CommitReveal {
    struct Commit {
        bytes32 hash;
        uint256 block;
        address user;
    }
    
    Commit[] public commits;
    
    function commit(bytes32 _hash) external {
        commits.push(Commit(_hash, block.number, msg.sender));
    }
    
    function reveal(uint256 _index, uint256 _value, bytes32 _secret) external {
        Commit storage c = commits[_index];
        require(msg.sender == c.user, "Not your commit");
        require(keccak256(abi.encodePacked(_value, _secret)) == c.hash, "Invalid reveal");
        require(block.number > c.block, "Too early");
        
        // Process the revealed value
        processValue(_value);
    }
}

// Strategy 2: Slippage Protection
contract SlippageProtected {
    function swap(uint256 _amountIn, uint256 _minAmountOut) external {
        uint256 amountOut = getAmountOut(_amountIn);
        require(amountOut >= _minAmountOut, "Slippage too high");
        // Execute swap
    }
}

// Strategy 3: Private Mempool (Flashbots)
// Users send bundles directly to validators, bypassing the public mempool
contract FlashbotsIntegration {
    // Bundle: [tx1, tx2, tx3] submitted as a unit
    // Either all execute or none execute (atomic)
    // Cannot be front-run because the bundle is private
}

// MEV-Boost flow
class MEVBoost {
  constructor() {
    this.builders = [];
    this.relays = [];
  }
  
  async proposeBlock(validator) {
    // Validator queries relays for the best block
    const bids = await Promise.all(
      this.relays.map(relay => relay.getHeader())
    );
    
    // Select the block with highest MEV payment
    const bestBid = bids.reduce((max, bid) => 
      bid.value > max.value ? bid : max
    );
    
    console.log(`Best block bid: ${bestBid.value} ETH`);
    console.log(`Builder: ${bestBid.builder}`);
    console.log(`Relay: ${bestBid.relay}`);
    
    // Sign the block header (without seeing contents)
    const signature = await validator.sign(bestBid.header);
    
    // Get full block from relay
    const block = await bestBid.relay.getPayload(bestBid.header, signature);
    
    return block;
  }
}

// Expected output:
// Best block bid: 0.15 ETH
// Builder: Flashbots
// Relay: Flashbots Relay