EthArbitrageMainnet

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

interface IUniswapV2Router {
    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);
}

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract EthArbitrageMainnet {
    address public owner;
    address public immutable usdc;
    IUniswapV2Router public immutable uniswapRouter;

    event SwapSuccess(uint256 ethIn, uint256 usdcOut);
    event SwapFailed(string reason);

    constructor(address _router, address _usdc) {
        owner = msg.sender;
        uniswapRouter = IUniswapV2Router(_router);
        usdc = _usdc;
    }

    function swapEthToUsdcUniswap(uint256 amountOutMin) external payable {
        require(msg.value > 0, "Must send ETH to swap");

        // ✅ Correct checksummed WETH address for Ethereum Mainnet
        address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = usdc;

        try uniswapRouter.swapExactETHForTokens{value: msg.value}(
            amountOutMin,
            path,
            address(this),
            block.timestamp
        ) returns (uint[] memory amounts) {
            emit SwapSuccess(msg.value, amounts[amounts.length - 1]);
        } catch Error(string memory reason) {
            emit SwapFailed(reason);
            revert(reason);
        } catch {
            revert("Uniswap swap failed unexpectedly");
        }
    }

    function withdrawETH() external {
        require(msg.sender == owner, "Not owner");
        payable(owner).transfer(address(this).balance);
    }

    function withdrawToken(address token) external {
        require(msg.sender == owner, "Not owner");
        uint256 balance = IERC20(token).balanceOf(address(this));
        IERC20(token).transfer(owner, balance);
    }
}