MEV_God_Mode_Fixed_v2

{{
  "language": "Solidity",
  "sources": {
    "MEV_God_Mode_Fixed_v2.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

// ========== SECURITY ==========
abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

// ========== INTERFACES ==========
interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
}

interface IUniswapV2Router {
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    
    function getAmountsOut(
        uint amountIn, 
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface IFlashLoanSimpleReceiver {
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external returns (bool);
}

interface IPool {
    function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
    ) external;
}

// ========== MAIN CONTRACT ==========
contract MEV_God_Mode_Fixed_v2 is ReentrancyGuard, IFlashLoanSimpleReceiver {
    
    // ========== STATE VARIABLES ==========
    address public immutable owner;
    address public immutable WETH;
    address public immutable flashLoanPool;
    
    uint256 public constant MAX_DEADLINE = 300;
    
    // ========== EVENTS ==========
    event MEVExecuted(address indexed asset, uint256 profit);
    event TokensWithdrawn(address indexed token, uint256 amount);
    
    // ========== CONSTRUCTOR ==========
    constructor(address _weth, address _flashLoanPool) {
        require(_weth != address(0), "Invalid WETH");
        require(_flashLoanPool != address(0), "Invalid pool");
        
        owner = msg.sender;
        WETH = _weth;
        flashLoanPool = _flashLoanPool;
    }
    
    // ========== MODIFIERS ==========
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    
    // ========== MAIN MEV FUNCTION ==========
    function executeMEV(
        address pool,
        address asset,
        uint256 amount,
        address[] calldata routers,
        uint256 minProfit,
        uint16 maxSlippage
    ) external onlyOwner nonReentrant {
        require(pool == flashLoanPool, "Invalid pool");
        require(routers.length == 2, "Need 2 routers");
        require(amount > 0, "Amount = 0");
        require(maxSlippage <= 1000, "Slippage too high");
        
        bytes memory params = abi.encode(routers, minProfit, maxSlippage);
        
        IPool(pool).flashLoanSimple(
            address(this),
            asset,
            amount,
            params,
            0
        );
    }
    
    // ========== FLASH LOAN CALLBACK - ULTRA OPTIMIZED ==========
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == flashLoanPool, "Not pool");
        require(initiator == address(this), "Not self");
        
        (address[] memory routers, uint256 minProfit, uint16 maxSlippage) = 
            abi.decode(params, (address[], uint256, uint16));
        
        // Reuse array
        address[] memory path = new address[](2);
        
        // ===== SWAP 1: asset -> WETH =====
        path[0] = asset;
        path[1] = WETH;
        
        {
            uint256 expectedOut = IUniswapV2Router(routers[0]).getAmountsOut(amount, path)[1];
            IERC20(asset).approve(routers[0], amount);
            IUniswapV2Router(routers[0]).swapExactTokensForTokens(
                amount,
                (expectedOut * (10000 - maxSlippage)) / 10000,
                path,
                address(this),
                block.timestamp + MAX_DEADLINE
            );
        }
        
        // ===== SWAP 2: WETH -> asset =====
        path[0] = WETH;
        path[1] = asset;
        
        {
            uint256 wethBal = IERC20(WETH).balanceOf(address(this));
            uint256 expectedOut = IUniswapV2Router(routers[1]).getAmountsOut(wethBal, path)[1];
            IERC20(WETH).approve(routers[1], wethBal);
            IUniswapV2Router(routers[1]).swapExactTokensForTokens(
                wethBal,
                (expectedOut * (10000 - maxSlippage)) / 10000,
                path,
                address(this),
                block.timestamp + MAX_DEADLINE
            );
        }
        
        // ===== PROFIT CHECK & REPAYMENT =====
        {
            uint256 bal = IERC20(asset).balanceOf(address(this));
            uint256 owed = amount + premium;
            
            require(bal >= owed, "Can't repay");
            require(bal - owed >= minProfit, "Low profit");
            
            IERC20(asset).approve(flashLoanPool, owed);
            
            emit MEVExecuted(asset, bal - owed);
        }
        
        return true;
    }
    
    // ========== EMERGENCY FUNCTIONS ==========
    function withdrawETH() external onlyOwner {
        (bool ok, ) = owner.call{value: address(this).balance}("");
        require(ok, "Transfer failed");
    }
    
    function withdrawStuckTokens(address token) external onlyOwner {
        uint256 bal = IERC20(token).balanceOf(address(this));
        require(bal > 0, "No tokens");
        require(IERC20(token).transfer(owner, bal), "Transfer failed");
        emit TokensWithdrawn(token, bal);
    }
    
    receive() external payable {}
    fallback() external payable {}
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}