pragma solidity ^0.6.6;

//<SPDX-License-Identifier: MIT

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address src, address dst, uint wad) external returns (bool);
}

interface IFactory {
    function INIT_CODE_PAIR_HASH() external pure returns(bytes32);
}

interface IBEP20 {
    
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}


interface IPair {
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function token0() external pure returns(address);

}

interface IRouter {
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
}

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint z) {require((z = x + y) >= x, 'ds-math-add-overflow');}
    function sub(uint x, uint y) internal pure returns (uint z) {require((z = x - y) <= x, 'ds-math-sub-underflow');}
    function mul(uint x, uint y) internal pure returns (uint z) {require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');}
}

library PairLibrary {
    using SafeMath for uint;
    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
        require(tokenA != tokenB, 'IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'ZERO_ADDRESS');
    }
    
    function pairFor(address factory, bytes32 INIT_CODE_PAIR_HASH, address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(uint(keccak256(abi.encodePacked(hex'ff',factory,keccak256(abi.encodePacked(token0, token1)),INIT_CODE_PAIR_HASH))));
    }
    
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee_num, uint fee_den) internal pure returns (uint amountOut) {
        uint amountInWithFee = amountIn.mul(fee_num);
        uint numerator = amountInWithFee.mul(reserveOut);
        uint denominator = reserveIn.mul(fee_den).add(amountInWithFee);
        amountOut = numerator / denominator;
    }
    
}

contract ContractBot {
    
    using SafeMath for uint;
    
    address owner;
    mapping(address => bool) public allowed;
    
    constructor () public {
        
        owner = msg.sender;
        allowed[owner] = true;
        
    }
    
    modifier OwnerCheck(address _address) {
        require(_address == owner, "Locked!");
        _;
    }
    
    modifier AllowedCheck(address _address) {
        require(allowed[_address] == true, "Not allowed!");
        _;
    }
    
    function changeOwner(address _newOwner) external OwnerCheck(msg.sender) {
        owner = _newOwner;
    }
    
    function getPair(address _factory, bytes32 _INIT_CODE_PAIR_HASH, address _tokenA, address _tokenB) public pure returns (address pairadd) {
        pairadd = PairLibrary.pairFor(_factory, _INIT_CODE_PAIR_HASH, _tokenA, _tokenB);
    }
    
    function isAllowed(address _member) external view returns(bool) {
        return (allowed[_member]);
    }
    
    function approveAddress(address _member) external OwnerCheck(msg.sender) returns (bool) {
        allowed[_member] = true;
        return true;
    }
    
    function bulkApprove(address[] memory _members) external OwnerCheck(msg.sender) returns (bool) {
        for(uint i = 0; i < _members.length; i++) {
            allowed[_members[i]] = true;
        }
        
        return true;
    }
    
    function removeAddress(address _member) external OwnerCheck(msg.sender) returns (bool) {
        allowed[_member] = false;
        return true;
    }
    
    function bulkRemove(address[] memory _members) external OwnerCheck(msg.sender) returns (bool) {
        for(uint i = 0; i < _members.length; i++) {
            allowed[_members[i]] = false;    
        }
        
        return true;
    }
    
    function directSwapBuyOnly(address _router, address _pair, address[] memory _path, uint256 _amountMin, address _to) external payable AllowedCheck(msg.sender) returns(bool success) {
    
        IPair LP = IPair(_pair);
        
        IWETH(_path[0]).deposit{value : msg.value}();
        IWETH(_path[0]).transfer(address(LP), msg.value);
        
        
        uint amountOut;
        (uint reserve0, uint reserve1,) = LP.getReserves();
        address token0 = LP.token0();
        
        (reserve0, reserve1) = _path[0] == token0 ? (reserve0, reserve1) : (reserve1, reserve0);

        amountOut = IRouter(_router).getAmountsOut(msg.value, _path)[1];
        
        if (_amountMin != 0) { require(amountOut >= _amountMin, "ERR : SLIPPAGE"); }

        (uint amount0Out, uint amount1Out) = _path[0] == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        LP.swap(amount0Out, amount1Out, _to, new bytes(0));
        success = true;
    }
    
    function directSwapBuyAndSell(address _router, address _pair, address[] memory _path, uint256 _amount, uint256 _amountMin, address _to) external AllowedCheck(msg.sender) returns(bool success) {
    
        IPair LP = IPair(_pair);
        IWETH(_path[0]).transferFrom(msg.sender, address(LP), _amount);
        
        uint amountOut;
        (uint reserve0, uint reserve1,) = LP.getReserves();
        address token0 = LP.token0();
        
        (reserve0, reserve1) = _path[0] == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
        amountOut = IRouter(_router).getAmountOut(IBEP20(_path[0]).balanceOf(address(LP)).sub(reserve0), reserve0, reserve1);
        
        if (_amountMin != 0) { require(amountOut >= _amountMin, "ERR : SLIPPAGE"); }

        (uint amount0Out, uint amount1Out) = _path[0] == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        LP.swap(amount0Out, amount1Out, _to, new bytes(0));
        success = true;
    }
    
    receive() external payable { }
    
    function withdraw() external OwnerCheck(msg.sender) {
        payable(owner).transfer(address(this).balance);
    }
    
}

{
  "compilationTarget": {
    "contracts/sniper_contract_buy.sol": "ContractBot"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 3999999999
  },
  "remappings": []
}