《水中刀》与MEV博弈：刀锋作为交易排序的武器

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

contract MEVGame {
    struct Trade {
        address trader;
        uint256 amount;
        uint256 expectedPrice;
        uint256 timestamp;
        uint256 blockNumber;
        uint256 position;
    }

    struct Sandwich {
        address attacker;
        address victim;
        uint256 frontAmount;
        uint256 backAmount;
        uint256 profit;
        uint256 blockNumber;
    }

    mapping(uint256 => Trade[]) public blockTrades;
    mapping(uint256 => Sandwich[]) public sandwiches;
    mapping(address => uint256) public profits;
    mapping(address => uint256) public losses;

    uint256 public constant SLIPPAGE_TOLERANCE = 50; // 0.5%
    uint256 public currentBlock;
    
    event TradeExecuted(address indexed trader, uint256 amount, uint256 price, uint256 position);
    event SandwichDetected(address indexed attacker, address indexed victim, uint256 profit);
    event MEVExtracted(address indexed extractor, uint256 value);

    modifier onlyMiner() {
        require(block.coinbase == msg.sender, "Not miner");
        _;
    }

    function executeTrade(uint256 amount, uint256 expectedPrice) external {
        uint256 blockNumber = block.number;
        uint256 position = blockTrades[blockNumber].length;

        blockTrades[blockNumber].push(Trade({
            trader: msg.sender,
            amount: amount,
            expectedPrice: expectedPrice,
            timestamp: block.timestamp,
            blockNumber: blockNumber,
            position: position
        }));

        // Execute trade with slippage protection
        uint256 executionPrice = _getExecutionPrice(amount, position);
        uint256 slippage = executionPrice > expectedPrice ? 
            ((executionPrice - expectedPrice) * 10000) / expectedPrice :
            ((expectedPrice - executionPrice) * 10000) / expectedPrice;

        if (slippage <= SLIPPAGE_TOLERANCE) {
            _executeSwap(msg.sender, amount, executionPrice);
            emit TradeExecuted(msg.sender, amount, executionPrice, position);
        } else {
            revert("Slippage too high");
        }
    }

    function _getExecutionPrice(uint256 amount, uint256 position) 
        internal view returns (uint256) {
        uint256 blockNumber = block.number;
        Trade[] storage currentTrades = blockTrades[blockNumber];
        
        // Simulate price impact based on position and total volume
        uint256 totalVolume = 0;
        for (uint256 i = 0; i < currentTrades.length; i++) {
            totalVolume += currentTrades[i].amount;
        }

        // Price impact formula: price = basePrice * (1 + impact * position)
        uint256 basePrice = 1000; // 1 ETH = 1000 USDC
        uint256 impact = (totalVolume * 100) / 1e18; // 0.01% per ETH of volume
        uint256 adjustedPrice = basePrice + (basePrice * impact * (position + 1)) / 10000;

        return adjustedPrice;
    }

    function _executeSwap(address trader, uint256 amount, uint256 price) internal {
        // Simulated swap execution
        // In production, this would interact with an AMM
    }

    function detectSandwichAttack(uint256 blockNumber) 
        external view returns (Sandwich[] memory) {
        Trade[] storage trades = blockTrades[blockNumber];
        Sandwich[] memory detected = new Sandwich[](trades.length / 3);
        uint256 count = 0;

        for (uint256 i = 0; i + 2 < trades.length; i += 3) {
            Trade memory front = trades[i];
            Trade memory middle = trades[i + 1];
            Trade memory back = trades[i + 2];

            if (front.trader == back.trader && front.trader != middle.trader) {
                // Potential sandwich attack
                uint256 frontAmount = front.amount;
                uint256 backAmount = back.amount;
                uint256 priceBefore = _getExecutionPrice(frontAmount, i);
                uint256 priceAfter = _getExecutionPrice(backAmount, i + 2);
                uint256 profit = (priceAfter - priceBefore) * middle.amount / 1000;

                detected[count] = Sandwich({
                    attacker: front.trader,
                    victim: middle.trader,
                    frontAmount: frontAmount,
                    backAmount: backAmount,
                    profit: profit,
                    blockNumber: blockNumber
                });
                count++;
            }
        }

        // Resize array
        Sandwich[] memory result = new Sandwich[](count);
        for (uint256 i = 0; i < count; i++) {
            result[i] = detected[i];
        }
        return result;
    }

    function extractMEV(address[] calldata victims) external onlyMiner {
        uint256 totalMEV = 0;
        for (uint256 i = 0; i < victims.length; i++) {
            // Simulate MEV extraction through reordering
            uint256 mev = _calculateMEVFromVictim(victims[i]);
            totalMEV += mev;
            profits[msg.sender] += mev;
            losses[victims[i]] += mev;
        }
        emit MEVExtracted(msg.sender, totalMEV);
    }

    function _calculateMEVFromVictim(address victim) internal view returns (uint256) {
        uint256 blockNumber = block.number;
        Trade[] storage trades = blockTrades[blockNumber];
        uint256 victimMEV = 0;

        for (uint256 i = 0; i < trades.length; i++) {
            if (trades[i].trader == victim) {
                // Calculate potential MEV from this victim's trade
                victimMEV += trades[i].amount * 10 / 10000; // 0.1% of trade value
            }
        }
        return victimMEV;
    }

    function getBlockTrades(uint256 blockNumber) 
        external view returns (Trade[] memory) {
        return blockTrades[blockNumber];
    }
}

import numpy as np
from typing import List, Dict, Tuple
from dataclasses import dataclass
from collections import defaultdict
import json
import random

@dataclass
class Transaction:
    tx_hash: str
    sender: str
    gas_price: int  # in Gwei
    value: int  # ETH
    is_arbitrage: bool
    timestamp: int

@dataclass
class MEVOpportunity:
    victim_tx: Transaction
    frontrun_tx: Transaction
    backrun_tx: Transaction
    profit: float
    strategy: str

class MEVSimulator:
    def __init__(self):
        self.transactions: List[Transaction] = []
        self.opportunities: List[MEVOpportunity] = []
        self.miners: Dict[str, float] = defaultdict(float)
        self.searchers: Dict[str, float] = defaultdict(float)
        self.victims: Dict[str, float] = defaultdict(float)

    def generate_transaction_pool(self, n_txs: int = 100) -> List[Transaction]:
        """Generate a random mempool of transactions"""
        txs = []
        for i in range(n_txs):
            tx = Transaction(
                tx_hash=f"0x{i:064x}",
                sender=f"0x{random.randint(0, 1000):040x}",
                gas_price=random.randint(10, 200),
                value=random.uniform(0.1, 100),
                is_arbitrage=random.random() < 0.1,
                timestamp=i
            )
            txs.append(tx)
        self.transactions = txs
        return txs

    def detect_opportunities(self) -> List[MEVOpportunity]:
        """Detect MEV opportunities in the mempool"""
        opportunities = []

        # Detect arbitrage opportunities
        for i, tx in enumerate(self.transactions):
            if tx.is_arbitrage:
                # Find frontrun opportunity
                for j in range(max(0, i-5), i):
                    if not self.transactions[j].is_arbitrage:
                        frontrun = Transaction(
                            tx_hash=f"0xFRONT_{j:064x}",
                            sender="0xSearcher",
                            gas_price=tx.gas_price + 1,
                            value=tx.value * 0.1,
                            is_arbitrage=True,
                            timestamp=tx.timestamp - 1
                        )
                        opportunities.append(MEVOpportunity(
                            victim_tx=tx,
                            frontrun_tx=frontrun,
                            backrun_tx=None,
                            profit=tx.value * 0.05,
                            strategy="frontrun"
                        ))
                        break

            # Detect sandwich opportunities
            if tx.value > 10:  # Large trade is vulnerable
                # Find frontrun and backrun
                frontrun = Transaction(
                    tx_hash=f"0xSANDWICH_FRONT_{i:064x}",
                    sender="0xSearcher",
                    gas_price=tx.gas_price + 2,
                    value=tx.value * 0.05,
                    is_arbitrage=True,
                    timestamp=tx.timestamp - 1
                )
                backrun = Transaction(
                    tx_hash=f"0xSANDWICH_BACK_{i:064x}",
                    sender="0xSearcher",
                    gas_price=tx.gas_price - 1,
                    value=tx.value * 0.05,
                    is_arbitrage=True,
                    timestamp=tx.timestamp + 1
                )
                opportunities.append(MEVOpportunity(
                    victim_tx=tx,
                    frontrun_tx=frontrun,
                    backrun_tx=backrun,
                    profit=tx.value * 0.02,
                    strategy="sandwich"
                ))

        self.opportunities = opportunities
        return opportunities

    def simulate_block_building(self, block_size: int = 15) -> Dict:
        """Simulate a miner building a block with MEV"""
        # Sort transactions by gas price (miner's preference)
        sorted_txs = sorted(self.transactions, key=lambda t: t.gas_price, reverse=True)
        
        block = []
        total_gas_fees = 0
        total_mev = 0
        
        # Add high-gas transactions first
        for tx in sorted_txs[:block_size]:
            block.append(tx)
            total_gas_fees += tx.gas_price * tx.value / 1000
        
        # Add MEV transactions
        opportunities = self.detect_opportunities()
        for opp in opportunities[:3]:  # Top 3 opportunities
            if len(block) < block_size:
                block.append(opp.frontrun_tx)
                total_mev += opp.profit
                if opp.backrun_tx:
                    if len(block) < block_size:
                        block.append(opp.backrun_tx)
                        total_mev += opp.profit * 0.5

        # Calculate miner revenue
        miner_revenue = total_gas_fees + total_mev
        
        # Track searcher profit
        searcher_profit = total_mev * 0.7  # 70% to searcher, 30% to miner
        
        return {
            'block_size': len(block),
            'gas_fees': total_gas_fees,
            'mev': total_mev,
            'miner_revenue': miner_revenue,
            'searcher_profit': searcher_profit,
            'opportunities_found': len(opportunities),
            'opportunities_executed': min(len(opportunities), 3)
        }

    def simulate_mev_auction(self, n_searchers: int = 10) -> Dict:
        """Simulate a MEV auction where searchers bid for bundle inclusion"""
        opportunities = self.detect_opportunities()
        if not opportunities:
            return {'error': 'No opportunities'}

        # Each searcher bids a portion of their expected profit
        bids = []
        for i in range(n_searchers):
            for opp in opportunities[:3]:
                expected_profit = opp.profit
                bid = expected_profit * random.uniform(0.1, 0.5)
                bids.append({
                    'searcher': f"searcher_{i}",
                    'bid': bid,
                    'strategy': opp.strategy
                })

        # Miner selects highest bids
        sorted_bids = sorted(bids, key=lambda b: b['bid'], reverse=True)
        selected_bids = sorted_bids[:3]
        
        total_miner_mev = sum(b['bid'] for b in selected_bids)
        total_searcher_profit = sum(
            opp.profit * 0.7 for opp in opportunities[:3]
        )

        return {
            'total_bids': len(bids),
            'selected_bids': selected_bids,
            'miner_mev_revenue': total_miner_mev,
            'searcher_total_profit': total_searcher_profit,
            'winner_bid': selected_bids[0]['bid'] if selected_bids else 0
        }

    def analyze_mev_distribution(self, n_blocks: int = 100) -> Dict:
        """Analyze MEV distribution across multiple blocks"""
        total_mev = 0
        total_gas = 0
        block_mevs = []
        
        for _ in range(n_blocks):
            self.generate_transaction_pool(100)
            result = self.simulate_block_building()
            total_mev += result['mev']
            total_gas += result['gas_fees']
            block_mevs.append(result['mev'])

        return {
            'total_blocks': n_blocks,
            'total_mev': total_mev,
            'total_gas_fees': total_gas,
            'mev_to_gas_ratio': total_mev / total_gas if total_gas > 0 else 0,
            'avg_mev_per_block': total_mev / n_blocks,
            'max_mev_block': max(block_mevs),
            'min_mev_block': min(block_mevs),
            'std_mev': np.std(block_mevs)
        }


# Demo
sim = MEVSimulator()
sim.generate_transaction_pool(200)
opportunities = sim.detect_opportunities()
block_result = sim.simulate_block_building()
auction_result = sim.simulate_mev_auction()

print(json.dumps({
    'opportunities': len(opportunities),
    'block': block_result,
    'auction': auction_result
}, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const cors = require('cors');

const app = express();
app.use(cors());
app.use(express.json());

class MEVMonitor {
    constructor(providerUrl) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.mempool = [];
        this.sandwichAlerts = [];
        this.flashbotsRPC = 'https://relay.flashbots.net';
    }

    async monitorMempool() {
        // Subscribe to pending transactions
        this.provider.on('pending', async (txHash) => {
            try {
                const tx = await this.provider.getTransaction(txHash);
                if (tx) {
                    this.mempool.push({
                        hash: txHash,
                        from: tx.from,
                        to: tx.to,
                        value: ethers.utils.formatEther(tx.value),
                        gasPrice: tx.gasPrice?.toString(),
                        timestamp: Date.now()
                    });
                    this.detectSandwich(tx);
                }
            } catch (e) {
                // Ignore errors
            }
        });
    }

    detectSandwich(tx) {
        // Check if this transaction is vulnerable to sandwich attack
        const value = parseFloat(ethers.utils.formatEther(tx.value));
        const gasPrice = parseFloat(ethers.utils.formatEther(tx.gasPrice || 0));
        
        if (value > 10 && gasPrice < 100) {
            // High value, low gas = vulnerable
            this.sandwichAlerts.push({
                txHash: tx.hash,
                type: 'VULNERABLE',
                risk: 'HIGH',
                reason: 'Large transaction with low gas price',
                timestamp: Date.now()
            });
        }
    }

    async simulateMEV(tx) {
        // Simulate potential MEV extraction
        const value = parseFloat(ethers.utils.formatEther(tx.value));
        const potentialProfit = value * 0.02; // 2% sandwich profit
        
        return {
            txHash: tx.hash,
            value,
            potentialMEV: potentialProfit,
            attackTypes: ['sandwich', 'frontrun'],
            recommendedAction: potentialProfit > 0.1 ? 
                'USE_FLASHBOTS' : 'LOW_RISK'
        };
    }

    async submitToFlashbots(privateKey, tx) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const flashbotsProvider = new ethers.providers.JsonRpcProvider(this.flashbotsRPC);
        
        const signedTx = await wallet.signTransaction(tx);
        const bundle = [{ signedTransaction: signedTx }];
        
        const blockNumber = await this.provider.getBlockNumber();
        const targetBlock = blockNumber + 1;
        
        // Submit bundle to Flashbots
        const response = await flashbotsProvider.send('eth_sendBundle', [
            {
                txs: bundle.map(b => b.signedTransaction),
                blockNumber: ethers.utils.hexlify(targetBlock),
                minTimestamp: 0,
                maxTimestamp: Number.MAX_SAFE_INTEGER
            }
        ]);
        
        return response;
    }
}

const monitor = new MEVMonitor(process.env.RPC_URL);

app.get('/api/mev/mempool', (req, res) => {
    res.json({ size: monitor.mempool.length, transactions: monitor.mempool.slice(-20) });
});

app.get('/api/mev/alerts', (req, res) => {
    res.json({ alerts: monitor.sandwichAlerts });
});

app.post('/api/mev/simulate', async (req, res) => {
    const { txHash } = req.body;
    const tx = await monitor.provider.getTransaction(txHash);
    const simulation = await monitor.simulateMEV(tx);
    res.json(simulation);
});

app.post('/api/mev/protect', async (req, res) => {
    const { privateKey, to, value, data } = req.body;
    const wallet = new ethers.Wallet(privateKey, monitor.provider);
    
    const tx = {
        to,
        value: ethers.utils.parseEther(value.toString()),
        data: data || '0x',
        gasLimit: 100000,
        gasPrice: ethers.utils.parseUnits('50', 'gwei')
    };
    
    const result = await monitor.submitToFlashbots(privateKey, tx);
    res.json(result);
});

app.listen(3010, () => {
    console.log('MEV Monitor API running on port 3010');
});