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.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

/**

Website: https://www.philandfriends.xyz/
Telegram: https://t.me/philandfriends
Twitter: https://twitter.com/PhiltheFoxeth

*/

pragma solidity ^0.8.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.8.3/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.8.3/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

contract PHIL is ERC20, Ownable {
    uint256 public immutable initialSupply;
    uint256 public immutable percentageBase;
    uint256 public disabledBlocks;
    uint256 public blockStart;
    uint256 public timeStart;
    address public routerAddress;

    uint256 public maxTax;
    uint256 public buyTax;
    uint256 public sellTax;
    address public taxWallet;

    uint256 public maxWallet;
    uint256 public maxTx;
    uint256 public txCooldown;

    bool public isMaxWalletEnabled;
    bool public isMaxTxEnabled;
    bool public isTxCooldownEnabled;

    uint256 public taxCollected;
    uint256 public taxThreshold;
    uint256 public lastTaxBlock;

    mapping(address => uint256) public lastTxTimestamp;
    mapping(address => bool) public exempt;
    mapping(address => bool) public dex;

    constructor(
        address _router,
        address _taxReceiver,
        address[] memory wallets,
        uint256[] memory tokenAmounts,
        uint256 initialLiquidity
    ) payable ERC20("Phil and Friends", "Phil") Ownable() {
        initialSupply = 100_000_000 ether;
        percentageBase = 100_000;

        disabledBlocks = 4;
        routerAddress = _router;

        maxTax = 10_000; // 10%
        buyTax = 3_000; // 3%
        sellTax = 3_000; // 3%

        taxWallet = _taxReceiver;
        maxWallet = 4_000; // 4%
        maxTx = 1_000; // 1%
        txCooldown = 5 seconds;
        taxThreshold = 5 minutes;

        isMaxWalletEnabled = true;
        isMaxTxEnabled = true;
        isTxCooldownEnabled = true;

        exempt[address(this)] = true;

        require(wallets.length == tokenAmounts.length, "Invalid input.");
        for (uint256 i = 0; i < wallets.length; i++) {
            require(
                tokenAmounts[i] <= (initialSupply * maxWallet) / percentageBase,
                "Invalid token amount."
            );
            _mint(wallets[i], tokenAmounts[i]);
        }

        _mint(address(this), initialLiquidity);
        require(
            totalSupply() == initialSupply,
            "Initial supply does not match."
        );
    }

    function addInitialLiquidity(
    ) external payable onlyOwner {
        require(blockStart == 0, "Liquidity already added.");
        require(timeStart == 0, "Liquidity already added.");
        IUniswapV2Router02 router = IUniswapV2Router02(routerAddress);
        _approve(address(this), routerAddress, ~uint256(0));
        address pair = IUniswapV2Factory(router.factory()).createPair(
            address(this),
            router.WETH()
        );
        dex[pair] = true;
        router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            msg.sender,
            block.timestamp + 15 minutes
        );
        blockStart = block.number;
        timeStart = block.timestamp;
    }

    function setBuyTax(uint256 _tax) external onlyOwner {
        require(_tax <= maxTax, "Tax exceeds maxTax.");
        buyTax = _tax;
    }

    function setSellTax(uint256 _tax) external onlyOwner {
        require(_tax <= maxTax, "Tax exceeds maxTax.");
        sellTax = _tax;
    }

    function setMaxWalletEnabled(bool _enabled) external onlyOwner {
        isMaxWalletEnabled = _enabled;
    }

    function setMaxTxEnabled(bool _enabled) external onlyOwner {
        isMaxTxEnabled = _enabled;
    }

    function setTxCooldownEnabled(bool _enabled) external onlyOwner {
        isTxCooldownEnabled = _enabled;
    }

		function withdraw() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        uint256 transferAmount = amount;
        if (blockStart == 0 || timeStart == 0) {
            require(
                from == address(this) || to == address(this),
                "Liquidity not added."
            );
        }
        bool isBeforeFx = block.number <= blockStart + disabledBlocks;
        if (dex[from] || dex[to]) {
            uint256 taxRate;
            if (exempt[from] || exempt[to]) {
                taxRate = 0;
            } else if (isBeforeFx && dex[from] && !exempt[to]) {
                taxRate = 95_000; // 95%
            } else if (dex[from]) {
                taxRate = buyTax;
            } else if (dex[to]) {
                taxRate = sellTax;
            } else {
                taxRate = 0;
            }
            uint256 taxAmount = (amount * taxRate) / percentageBase;
            transferAmount = amount - taxAmount;
            super._transfer(from, address(this), taxAmount);
            taxCollected += taxAmount;
            if (!isBeforeFx && !exempt[from]) {
                require(
                    !isMaxTxEnabled ||
                        (dex[to] && from == address(this)) ||
                        amount <= (maxTx * initialSupply) / percentageBase,
                    "Transfer amount exceeds maxTx."
                );
                if (dex[from] || dex[to]) {
                    require(
                        !isTxCooldownEnabled ||
                            dex[from] ||
                            (dex[to] && from == address(this)) ||
                            block.timestamp - lastTxTimestamp[from] >=
                            txCooldown,
                        "Transfer cooldown not expired."
                    );
                    lastTxTimestamp[from] = block.timestamp;
                }
            }
        }
        if (!isBeforeFx && !dex[to] && !exempt[to]) {
            require(
                isMaxWalletEnabled ||
                    dex[to] ||
                    to == address(this) ||
                    balanceOf(to) + transferAmount <=
                    (maxWallet * initialSupply) / percentageBase,
                "Recipient wallet balance exceeds maxWallet."
            );
        }
        if (
            !dex[from] &&
            taxCollected > 0 &&
            block.timestamp - lastTaxBlock > taxThreshold
        ) {
            lastTaxBlock = block.timestamp;
            uint256 toSwap = taxCollected;
            taxCollected = 0;
            _swapTokensToEth(toSwap, taxWallet);
        }
        super._transfer(from, to, transferAmount);
    }

    function _swapTokensToEth(uint256 tokenAmount, address recipient) private {
        if (tokenAmount > balanceOf(address(this))) {
            tokenAmount = balanceOf(address(this));
        }
        IUniswapV2Router02 router = IUniswapV2Router02(routerAddress);
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();
        router.swapExactTokensForETH(
            tokenAmount,
            0,
            path,
            recipient,
            block.timestamp + 15 minutes
        );
    }

    receive() external payable {}
}

{
  "compilationTarget": {
    "contracts/Token.sol": "PHIL"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}