pragma solidity ^0.8.0;

interface IUniswapV2Router02 {
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

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

contract ZeroXLiquidityMigration {
    address public operator;
    IUniswapV2Router02 public uniswapRouter;
    IERC20 public token;

    event TokensSwapped(uint256 amountIn, uint256 amountOut);
    event EthWithdrawn(uint256 amount);

    constructor(address _operator, address _uniswapRouter, IERC20 _token) {
        operator = _operator;
        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        token = _token;
    }

    modifier onlyOperator() {
        require(msg.sender == operator, "Only operator can call this function");
        _;
    }

    function swapTokensForEth(uint amountIn, uint amountOutMin) external onlyOperator {
        uint256 tokenBalance = token.balanceOf(address(this));
        require(tokenBalance >= amountIn, "Insufficient token balance");
        
        require(token.approve(address(uniswapRouter), amountIn), "Token approve failed");

        address[] memory path = new address[](2);
        path[0] = address(token);
        path[1] = uniswapRouter.WETH();

        uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountIn,
            amountOutMin, 
            path,
            address(this),
            block.timestamp
        );

        emit TokensSwapped(amountIn, address(this).balance);
    }

    function withdrawTokens(uint256 amount) external onlyOperator {
        require(token.transfer(msg.sender, amount), "transfer failed");
    }

    function withdrawEth() external onlyOperator {
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");
        payable(operator).transfer(balance);
        emit EthWithdrawn(balance);
    }

    receive() external payable {}
}

{
  "compilationTarget": {
    "ZeroXLiquidityMigration.sol": "ZeroXLiquidityMigration"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}