Stop Front-Running Attacks on Ethereum in 2 Hours

// Personal note: I learned this after losing $800 to a front-running bot
// that detected my large swap in the mempool
pragma solidity ^0.8.20;

contract CommitRevealDEX {
    mapping(address => bytes32) public commits;
    mapping(address => uint256) public commitTimestamps;
    uint256 public constant REVEAL_DELAY = 2; // blocks
    
    // Step 1: User commits to action without revealing details
    function commit(bytes32 _hashedData) external {
        require(commits[msg.sender] == bytes32(0), "Commit exists");
        
        commits[msg.sender] = _hashedData;
        commitTimestamps[msg.sender] = block.number;
        
        emit Committed(msg.sender, _hashedData);
    }
    
    // Step 2: After delay, user reveals and executes
    function revealAndSwap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        bytes32 salt
    ) external {
        // Verify commit exists and delay passed
        require(commits[msg.sender] != bytes32(0), "No commit");
        require(
            block.number >= commitTimestamps[msg.sender] + REVEAL_DELAY,
            "Too early"
        );
        
        // Watch out: Hash parameters exactly as committed
        bytes32 hash = keccak256(abi.encodePacked(
            msg.sender,
            tokenIn,
            tokenOut,
            amountIn,
            minAmountOut,
            salt
        ));
        
        require(hash == commits[msg.sender], "Invalid reveal");
        
        // Clear commit before executing (reentrancy protection)
        delete commits[msg.sender];
        delete commitTimestamps[msg.sender];
        
        // Execute the actual swap
        _executeSwap(tokenIn, tokenOut, amountIn, minAmountOut);
    }
    
    function _executeSwap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut
    ) internal {
        // Your swap logic here
    }
    
    event Committed(address indexed user, bytes32 hashedData);
}

// This line saved me from exposure during the reveal phase
// Flashbots Protect keeps transactions private until mined
const { ethers } = require('ethers');

// Don't skip this validation - learned the hard way
const FLASHBOTS_PROTECT_RPC = 'https://rpc.flashbots.net';

async function submitProtectedTransaction(
    signer,
    contractAddress,
    functionData,
    options = {}
) {
    // Connect to Flashbots Protect RPC
    const flashbotsProvider = new ethers.providers.JsonRpcProvider(
        FLASHBOTS_PROTECT_RPC
    );
    
    // Create transaction
    const tx = {
        to: contractAddress,
        data: functionData,
        gasLimit: options.gasLimit || 300000,
        maxFeePerGas: options.maxFeePerGas || ethers.utils.parseUnits('50', 'gwei'),
        maxPriorityFeePerGas: options.maxPriorityFeePerGas || ethers.utils.parseUnits('2', 'gwei'),
        type: 2, // EIP-1559
        chainId: 1
    };
    
    // Sign transaction
    const signedTx = await signer.signTransaction(tx);
    
    // Submit through Flashbots—invisible to public mempool
    const result = await flashbotsProvider.send('eth_sendRawTransaction', [
        signedTx
    ]);
    
    console.log(`Protected transaction submitted: ${result}`);
    return result;
}

// Example usage for reveal transaction
async function protectedReveal(commitData) {
    const contractInterface = new ethers.utils.Interface([
        "function revealAndSwap(address,address,uint256,uint256,bytes32)"
    ]);
    
    const functionData = contractInterface.encodeFunctionData('revealAndSwap', [
        commitData.tokenIn,
        commitData.tokenOut,
        commitData.amountIn,
        commitData.minAmountOut,
        commitData.salt
    ]);
    
    return await submitProtectedTransaction(
        signer,
        DEX_CONTRACT_ADDRESS,
        functionData,
        {
            gasLimit: 400000,
            maxFeePerGas: ethers.utils.parseUnits('100', 'gwei')
        }
    );
}

pragma solidity ^0.8.20;

contract DynamicSlippageProtection {
    // Store recent price observations
    struct PriceObservation {
        uint256 price;
        uint256 timestamp;
    }
    
    mapping(address => PriceObservation[]) public priceHistory;
    uint256 public constant OBSERVATION_WINDOW = 10; // Keep last 10 prices
    uint256 public constant BASE_SLIPPAGE = 50; // 0.5% base
    
    function calculateDynamicSlippage(
        address tokenPair
    ) public view returns (uint256) {
        PriceObservation[] storage history = priceHistory[tokenPair];
        
        if (history.length < 2) {
            return BASE_SLIPPAGE; // Default for new pairs
        }
        
        // Calculate price volatility over last N observations
        uint256 sumSquaredDiff = 0;
        uint256 avgPrice = 0;
        
        for (uint i = 0; i < history.length; i++) {
            avgPrice += history[i].price;
        }
        avgPrice = avgPrice / history.length;
        
        for (uint i = 0; i < history.length; i++) {
            uint256 diff = history[i].price > avgPrice 
                ? history[i].price - avgPrice 
                : avgPrice - history[i].price;
            sumSquaredDiff += (diff * diff);
        }
        
        // Volatility as percentage of average price
        uint256 volatility = (sqrt(sumSquaredDiff / history.length) * 10000) / avgPrice;
        
        // Slippage = base + (volatility * multiplier)
        // Higher volatility = more slippage tolerance needed
        uint256 dynamicSlippage = BASE_SLIPPAGE + (volatility * 2);
        
        // Cap at 5% maximum
        return dynamicSlippage > 500 ? 500 : dynamicSlippage;
    }
    
    function executeProtectedSwap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external {
        // Get dynamic slippage for this pair
        address pair = getPairAddress(tokenIn, tokenOut);
        uint256 allowedSlippage = calculateDynamicSlippage(pair);
        
        // Calculate minimum output based on dynamic slippage
        uint256 expectedOut = getExpectedOutput(tokenIn, tokenOut, amountIn);
        uint256 minAmountOut = expectedOut - (expectedOut * allowedSlippage / 10000);
        
        // Execute with calculated protection
        _swap(tokenIn, tokenOut, amountIn, minAmountOut);
        
        // Update price history
        updatePriceObservation(pair, expectedOut);
    }
    
    // Babylonian method for square root
    function sqrt(uint256 x) internal pure returns (uint256) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        uint256 y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
        return y;
    }
    
    function updatePriceObservation(address pair, uint256 price) internal {
        PriceObservation[] storage history = priceHistory[pair];
        
        if (history.length >= OBSERVATION_WINDOW) {
            // Remove oldest observation
            for (uint i = 0; i < history.length - 1; i++) {
                history[i] = history[i + 1];
            }
            history.pop();
        }
        
        history.push(PriceObservation({
            price: price,
            timestamp: block.timestamp
        }));
    }
    
    function getPairAddress(address tokenA, address tokenB) internal pure returns (address) {
        // Your pair address logic
        return address(0);
    }
    
    function getExpectedOutput(address tokenIn, address tokenOut, uint256 amountIn) internal view returns (uint256) {
        // Your pricing logic
        return 0;
    }
    
    function _swap(address tokenIn, address tokenOut, uint256 amountIn, uint256 minOut) internal {
        // Your swap logic
    }
}