// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.4;

interface UniswapV2Factory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface UniswapV2ERC20 {
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);
    function transfer(address to, uint value) external returns (bool);
    function approve(address spender, uint value) external returns (bool);
}

interface UniswapV2Pair {
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function token0() external view returns (address);
}

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

contract DracoExec {
    
    address owner;
    
    mapping (address => bool) whitelist;
    
    modifier onlyOwner {
        require(msg.sender == owner, "Must be Owner");
        _;
    }
    
    modifier onlyWhitelist(address _tocheck) {
        require(whitelist[_tocheck], "Address is not in whitelist");
        _;
    }

    constructor() {
        owner = msg.sender;
        whitelist[msg.sender] = true;
    }
    
    function getOwner() external view onlyOwner returns(address) {
        return owner;
    }
    
    function addWhitelist(address _to_add) external onlyOwner {
        whitelist[_to_add] = true;
    }
    
    function removeWhitelist(address _to_remove) external onlyOwner {
        whitelist[_to_remove] = false;
    }
    
    function getWhitelist(address _to_get) external view onlyOwner returns(bool) {
        return whitelist[_to_get];
    }
    
    function transferToken(address _token, address _to, uint _amount) external onlyOwner {
        UniswapV2ERC20(_token).transfer(_to, _amount);
    }
    
    function changeOwner(address _new_owner) external onlyOwner {
        owner = _new_owner;
    }
    
    function withdrawToken(address _token, uint _amount) external onlyOwner {
        UniswapV2ERC20(_token).transfer(msg.sender, _amount);
    }
    
    function childRefill(address _router, uint _amount, address[] memory _path, address _child, uint _deadline) external onlyOwner {
        UniswapV2Router02(_router).swapExactTokensForETH(_amount, _amount, _path, _child, _deadline);
    }
    
    function dracoTrade(address _factory, address _router, address _weth, uint _reserveA, uint _reserveB, uint _min_front, address[] memory _path, uint _deadline) external onlyWhitelist(msg.sender) {

        uint _amount_in = UniswapV2ERC20(_path[0]).balanceOf(address(this));
        uint _amount_out_min = 0;
        
        if (_amount_in == 0) {
            revert("token balance is zero");
        }
        
        if (_path[0] != _weth) {
            
            if (UniswapV2ERC20(_path[0]).allowance(address(this), _router) < _amount_in) {
                UniswapV2ERC20(_path[0]).approve(_router, _amount_in);
            }
            
        }
        
        else if (_path[0] == _weth) {
            
            if (UniswapV2ERC20(_path[0]).allowance(address(this), _router) < _amount_in) {
                UniswapV2ERC20(_path[0]).approve(_router, 115792089237316195423570985008687907853269984665640564039457584007913129639935);
            }
            
            address pair = UniswapV2Factory(_factory).getPair(_path[0],_path[1]);
            (uint112 reserve0, uint112 reserve1, ) = UniswapV2Pair(pair).getReserves();
            
            if (UniswapV2Pair(pair).token0() != _weth) {
                (reserve0, reserve1) = (reserve1, reserve0);
            }
            
            if (reserve0 * reserve1 < _reserveA * _reserveB) {
                revert("constant data is lower");
            }
            
            if (reserve0 >= _reserveA) {
                revert("reserve is already same or higher");
            }
            
            if (_reserveA - reserve0 < _min_front) {
                revert("Amount is lower than minimum required");
            }
            
            if (_reserveA - reserve0 < _amount_in) {
                _amount_in = _reserveA - reserve0;
            }
              
        }
        
        uint[] memory amount_out_list = UniswapV2Router02(_router).getAmountsOut(_amount_in, _path);
        _amount_out_min = amount_out_list[amount_out_list.length - 1] * 9998 / 10000;
        
        UniswapV2Router02(_router).swapExactTokensForTokensSupportingFeeOnTransferTokens(_amount_in, _amount_out_min, _path, address(this), _deadline);
        
    }
    
    function killMe() external onlyOwner {
        selfdestruct(msg.sender);
    }
    
}

{
  "compilationTarget": {
    "browser/DracoExec2.sol": "DracoExec"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}