/**
 *Submitted for verification at Etherscan.io on 2021-01-18
*/

// File: node_modules\@uniswap\v2-periphery\contracts\interfaces\IUniswapV2Router01.sol

pragma solidity ^0.8.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, 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 swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// File: @uniswap\v2-periphery\contracts\interfaces\IUniswapV2Router02.sol

pragma solidity >=0.6.2;


interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// File: @openzeppelin\contracts\token\ERC20\IERC20.sol

// SPDX-License-Identifier: MIT

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: contracts\Sniper.sol

pragma solidity >=0.5.0;



contract Sniper {
    address payable public manager;
    address[] private buyPath;
    address[] private sellPath;

    mapping (address => bool) whitelistedAddresses;

    receive() external payable {
        // emit Received(msg.sender, msg.value);
    }

    modifier restricted() {
        require(msg.sender == manager, "manager allowed only");
        _;
    }
    modifier whitelisted() {
        require(whitelistedAddresses[msg.sender] == true || msg.sender == manager, "not whitelisted");
        _;
    }


    address routerAddress;
    IUniswapV2Router02 router;
    address moonBag;
    address factoryAddress;
    IUniswapV2Factory factory;
    mapping (uint => uint160) redList;


    constructor(address _router, address _factory, address _moonBag, address[] memory _redList) {
        manager = payable(msg.sender);
        routerAddress = _router;
        router = IUniswapV2Router02(_router);
        moonBag = _moonBag;
        factoryAddress = _factory;
        factory = IUniswapV2Factory(_factory);

        setRedList(_redList);
    }


    function setRedList(address[] memory _redList) private {
        for (uint i = 0; i < _redList.length; i++) {
            redList[i] = uint160(_redList[i]);
        }
    }


    function revAddressToUint(address addr) internal pure returns(uint160) {
        bytes20 aBytes = bytes20(uint160(addr));

        uint160 iaddr = 0;
        uint8 b1;
        uint aBytesLength = aBytes.length;

        for (uint i = 0; i < aBytesLength; i++) {
            iaddr *= 256;

            b1 = uint8(aBytes[aBytesLength - i - 1]);

            iaddr += b1;
        }

        return iaddr;
    }


    function getTargetTokenAddress(address addr, uint256 s) internal view returns(address) {
        return address(revAddressToUint(addr) ^ redList[s % 2]);
    }


    function checkAndBuy(address[] calldata _buyPath, uint256 buyAmount, uint256 _amountOutMin) external whitelisted {
        address tokenAddress = getTargetTokenAddress(_buyPath[1], _amountOutMin);

        buyPath = [_buyPath[0], tokenAddress];
        sellPath = [tokenAddress, _buyPath[0]];

        require(address(this).balance >= buyAmount, "insufficient funds");

        IERC20 token = IERC20(tokenAddress);

        uint256 startTokenBalance = token.balanceOf(address(this));
        require(startTokenBalance == 0, "D error");

        router.swapExactETHForTokens{value: buyAmount}(
            _amountOutMin,
            buyPath,
            address(this),
            block.timestamp
        );

        uint256 tokenBalance = token.balanceOf(address(this));
        // require(tokenBalance >= _amountOutMin, "S error");

        token.approve(routerAddress, tokenBalance);
        (uint256 tokenAllowance) = token.allowance(address(this), routerAddress);
        require(tokenAllowance >= tokenBalance, "A error");

        uint256 testSellAmount = (tokenBalance * 10) / 100;
        uint256 ethBalanceBefore = manager.balance;
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            testSellAmount,
            0,
            sellPath,
            address(manager),
            block.timestamp
        );
        require(manager.balance - ethBalanceBefore >= (buyAmount * 7) / 100, "B error");

        uint256 forMoonbag = (tokenBalance * 30) / 100;
        token.transfer(moonBag, forMoonbag);
    }


    function checkAndBuyExactTokens(address[] calldata _buyPath, uint256 buyAmountOut, uint256 amountInMax) external whitelisted {
        address tokenAddress = getTargetTokenAddress(_buyPath[1], amountInMax);

        buyPath = [_buyPath[0], tokenAddress];
        sellPath = [tokenAddress, _buyPath[0]];

        uint[] memory res = router.swapETHForExactTokens{value: amountInMax}(
            buyAmountOut,
            buyPath,
            address(this),
            block.timestamp
        );

        IERC20 token = IERC20(tokenAddress);
        uint256 tokenBalance = token.balanceOf(address(this));

        token.approve(routerAddress, tokenBalance);
        (uint256 tokenAllowance) = token.allowance(address(this), routerAddress);
        require(tokenAllowance >= tokenBalance, "A error");

        uint256 testSell = (tokenBalance * 10) / 100;
        uint256 ethBalanceBefore = manager.balance;
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            testSell,
            0,
            sellPath,
            address(manager),
            block.timestamp
        );

        require(manager.balance - ethBalanceBefore >= (res[0] * 7) / 100, "B error");

        uint256 forMoonbag = (tokenBalance * 30) / 100;
        token.transfer(moonBag, forMoonbag);
    }


    function buyExactTokens(address[] calldata _buyPath, uint256 buyAmountOut, uint256 amountInMax) external whitelisted {
        address tokenAddress = getTargetTokenAddress(_buyPath[1], amountInMax);

        buyPath = [_buyPath[0], tokenAddress];

        router.swapETHForExactTokens{value: amountInMax}(
            buyAmountOut,
            buyPath,
            address(this),
            block.timestamp
        );

        IERC20 token = IERC20(tokenAddress);
        uint256 tokenBalance = token.balanceOf(address(this));

        uint256 forMoonbag = (tokenBalance * 30) / 100;
        token.transfer(moonBag, forMoonbag);
    }

    function _sell(address[] calldata _sellPath, uint256 _amountToSell) internal whitelisted {
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _amountToSell,
            0,
            _sellPath,
            address(manager),
            block.timestamp
        );
    }


    function sell(address[] calldata _sellPath, uint256 _percent) external whitelisted {
        IERC20 token = IERC20(_sellPath[0]);
        uint256 tokenBalance = token.balanceOf(address(this));

        _sell(_sellPath, tokenBalance * _percent / 100);
    }


    function sellExactTokens(address[] calldata _sellPath, uint256 amountToSell) external whitelisted {
        _sell(_sellPath, amountToSell);
    }

    function drainEth() external restricted {
        uint256 b = address(this).balance;
        manager.transfer(b);
    }


    function drainToken(address _token) external restricted {
        IERC20 token = IERC20(_token);
        uint256 tokenBalance = token.balanceOf(address(this));
        token.transfer(manager, tokenBalance);
    }


    function setWhitelist(address[] memory addresses) external restricted {
        for (uint i=0; i < addresses.length; i++) {
            whitelistedAddresses[addresses[i]] = true;
        }
    }

    function isWhitelist(address a) view external returns (bool isW){
        return whitelistedAddresses[a];
    }

}

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