Front Running Patterns

1. Victim submits swap: buy 100 ETH of TOKEN
2. Attacker front-runs: buys TOKEN, pushing price up
3. Victim's swap executes at worse price
4. Attacker back-runs: sells TOKEN at inflated price

error SlippageExceeded(uint256 amountOut, uint256 minAmountOut);

function swap(
    address tokenIn,
    address tokenOut,
    uint256 amountIn,
    uint256 minAmountOut,   // user sets minimum acceptable output
    uint256 deadline
) external returns (uint256 amountOut) {
    if (block.timestamp > deadline) revert Expired();

    amountOut = _executeSwap(tokenIn, tokenOut, amountIn);

    if (amountOut < minAmountOut) {
        revert SlippageExceeded(amountOut, minAmountOut);
    }

    emit Swapped(msg.sender, tokenIn, tokenOut, amountIn, amountOut);
}

modifier beforeDeadline(uint256 deadline) {
    if (block.timestamp > deadline) revert TransactionExpired(deadline, block.timestamp);
    _;
}

function addLiquidity(
    uint256 amount0,
    uint256 amount1,
    uint256 minLiquidity,
    uint256 deadline
) external beforeDeadline(deadline) returns (uint256 liquidity) {
    // ...
}

uint256 public constant COMMIT_PERIOD = 1 hours;
uint256 public constant REVEAL_PERIOD = 30 minutes;
uint256 public constant MIN_COMMIT_AGE = 2 minutes; // at least 1 block gap

mapping(address => bytes32) public commitments;
mapping(address => uint256) public commitTimestamps;

function commit(bytes32 hash) external {
    commitments[msg.sender] = hash;
    commitTimestamps[msg.sender] = block.timestamp;
    emit Committed(msg.sender);
}

function reveal(uint256 bid, bytes32 salt) external {
    uint256 commitTime = commitTimestamps[msg.sender];
    if (commitTime == 0) revert NoCommitment();
    if (block.timestamp < commitTime + MIN_COMMIT_AGE) revert RevealTooEarly();
    if (block.timestamp > commitTime + COMMIT_PERIOD + REVEAL_PERIOD) revert RevealExpired();

    bytes32 expected = keccak256(abi.encodePacked(msg.sender, bid, salt));
    if (commitments[msg.sender] != expected) revert InvalidReveal();

    commitments[msg.sender] = bytes32(0);
    _processBid(msg.sender, bid);
}

// Frontend integration: submit via Flashbots Protect RPC
const provider = new ethers.JsonRpcProvider("https://rpc.flashbots.net");
const tx = await signer.sendTransaction({
  to: routerAddress,
  data: encodedSwap,
  // Flashbots Protect: not visible in public mempool
});

// VULNERABLE: first caller wins
function claim(uint256 tokenId) external {
    require(!claimed[tokenId], "Already claimed");
    claimed[tokenId] = true;
    _mint(msg.sender, tokenId);
}

// SAFER: randomized or committed selection
// Use commit-reveal or Chainlink VRF for fair selection

// Track when liquidity was added to prevent JIT manipulation
mapping(uint256 => uint256) public positionMintBlock;

function mint(uint256 positionId, ...) external {
    positionMintBlock[positionId] = block.number;
    // ...
}

function collectFees(uint256 positionId) external {
    // Require liquidity existed for at least N blocks before fee collection
    if (block.number - positionMintBlock[positionId] < MIN_LIQUIDITY_BLOCKS) {
        revert LiquidityTooRecent();
    }
    // ...
}

1. Chainlink oracle update TX: ETH price changes from $2000 → $2100
2. Attacker front-runs: opens leveraged long at $2000
3. Oracle updates: price becomes $2100
4. Attacker closes: profit from $100 move with leverage