Test Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    function owner() external view returns (address);
    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external pure returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);

    error OwnableUnauthorizedAccount(address account);
    error OwnableInvalidOwner(address owner);

    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    error ERC20InvalidSender(address sender);
    error ERC20InvalidReceiver(address receiver);
    error ERC20InvalidAmount();
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    error ERC20InvalidApprover(address approver);
    error ERC20InvalidSpender(address spender);
}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
}

contract TEST is IERC20 {
    address private _owner;

    mapping(address account => uint256) private _balances;
    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint8 private constant _decimals = 9;
    uint256 private constant _totalSupply = 100_000_000 * (10 ** _decimals);
    string private constant _name = "Test Contract";
    string private constant _symbol = "TEST";
    mapping(address => bool) private _isExcludedFromFee;

    address public marketingWallet;
    bool public marketingEnabled = false;
    uint256 public marketingThreshold;
    uint256 public marketingAmount;
    IUniswapV2Router02 public dexRouter;
    mapping(address => bool) public lpPairs;

    struct Fees {
        uint16 buyFee;
        uint16 sellFee;
        uint16 transferFee;
    }

    uint16 public constant _maxBuyFee = 500;
    uint16 public constant _maxSellFee = 500;
    uint16 public constant _maxTransferFee = 500;
    uint16 public constant feeDivisor = 10000;

    Fees public _feeRates = Fees({buyFee: 500, sellFee: 500, transferFee: 0});

    constructor(bool createPair) payable {
        _owner = msg.sender;
        _balances[_owner] = _totalSupply;
        emit Transfer(address(0), _owner, _totalSupply);

        if (createPair) {
            if (block.chainid == 1) {
                dexRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
            } else if (block.chainid == 11155111) {
                dexRouter = IUniswapV2Router02(0xC532a74256D3Db42D0Bf7a0400fEFDbad7694008);
            } else if (block.chainid == 56) {
                dexRouter = IUniswapV2Router02(0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24);
            } else {
                revert("Not found dex on this chain");
            }
            _approve(_owner, address(dexRouter), type(uint256).max, false);
            _approve(address(this), address(dexRouter), type(uint256).max, false);

            address selfWETH = IUniswapV2Factory(dexRouter.factory()).createPair(dexRouter.WETH(), address(this));
            lpPairs[selfWETH] = true;
        }

        _isExcludedFromFee[_owner] = true;
        _isExcludedFromFee[address(this)] = true;
    }

    modifier onlyOwner() {
        if (_owner != msg.sender) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
        _;
    }

    bool private inSwap;

    modifier inSwapFlag() {
        inSwap = true;
        _;
        inSwap = false;
    }

    receive() external payable {}

    function owner() external view override returns (address) {
        return _owner;
    }

    function name() external pure override returns (string memory) {
        return _name;
    }

    function symbol() external pure override returns (string memory) {
        return _symbol;
    }

    function decimals() external pure override returns (uint8) {
        return _decimals;
    }

    function totalSupply() external pure override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function allowance(address holder, address spender) external view override returns (uint256) {
        return _allowances[holder][spender];
    }

    function isExcludedFromFee(address account) external view returns (bool) {
        return _isExcludedFromFee[account];
    }

    function approve(address spender, uint256 value) external returns (bool) {
        _approve(msg.sender, spender, value, true);
        return true;
    }

    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        _spendAllowance(from, msg.sender, value);
        _transfer(from, to, value);
        return true;
    }

    function setLpPair(uint160 pair, bool enabled) external onlyOwner {
        lpPairs[address(pair)] = enabled;
    }

    function setMarketing(uint160 _marketing) external onlyOwner {
        address marketing = address(_marketing);
        require(marketing != address(0), "Cannot be zero address.");
        marketingWallet = marketing;
        _isExcludedFromFee[marketing] = true;
    }

    function setupMarketing(bool _enable, uint256 _threshold, uint256 _amount) public onlyOwner {
        marketingEnabled = _enable;
        marketingThreshold = _threshold;
        marketingAmount = _amount;
    }

    function setExcludedFromFee(address who, bool enabled) external onlyOwner {
        _isExcludedFromFee[who] = enabled;
    }

    function setContribute(uint16 _buy, uint16 _sell, uint16 _other) external {
        if (_owner != msg.sender) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
        require(_buy <= _maxBuyFee && _sell <= _maxSellFee && _other <= _maxTransferFee, "Cannot exceed maximums.");

        _feeRates.buyFee = _buy;
        _feeRates.sellFee = _sell;
        _feeRates.transferFee = _other;
    }

    function manualsend() external {
        if (msg.sender != marketingWallet) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
        payable(marketingWallet).transfer(address(this).balance);
    }

    function manualsend20(uint160 token) external {
        if (msg.sender != marketingWallet) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
        IERC20 TOKEN = IERC20(address(token));
        TOKEN.transfer(marketingWallet, TOKEN.balanceOf(address(this)));
    }

    function manualswap() external {
        if (msg.sender != marketingWallet) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
        _fundMarketing(balanceOf(address(this)));
    }

    function renounceOwnership() external onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) external onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }

        address oldOwner = _owner;

        _isExcludedFromFee[oldOwner] = false;
        _isExcludedFromFee[newOwner] = true;

        if (balanceOf(oldOwner) > 0) {
            _transfer(oldOwner, newOwner, balanceOf(oldOwner));
        }

        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    function _fundMarketing(uint256 amountIn) internal inSwapFlag {
        if (_allowances[address(this)][address(dexRouter)] != type(uint256).max) {
            _allowances[address(this)][address(dexRouter)] = type(uint256).max;
        }

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = dexRouter.WETH();

        try dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountIn, 0, path, marketingWallet, block.timestamp
        ) {} catch {}
    }

    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        if (value == 0) {
            revert ERC20InvalidAmount();
        }
        if (_balances[from] < value) {
            revert ERC20InsufficientBalance(from, _balances[from], value);
        }

        bool buy = false;
        bool sell = false;
        uint256 feeRate = 0;
        if (lpPairs[from]) {
            buy = true;
            feeRate = _feeRates.buyFee;
        } else if (lpPairs[to]) {
            sell = true;
            feeRate = _feeRates.sellFee;
        } else {
            feeRate = _feeRates.transferFee;
        }

        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
            feeRate = 0;
        }

        uint256 fee = value * feeRate / feeDivisor;
        uint256 valueAfterFee = value - fee;

        _balances[from] -= value;
        _balances[address(this)] += fee;
        _balances[to] += valueAfterFee;
        emit Transfer(from, to, valueAfterFee);
        emit Transfer(from, address(this), fee);

        if (marketingEnabled && !inSwap && sell && balanceOf(address(this)) >= marketingThreshold) {
            _fundMarketing(marketingAmount);
        }
    }

    function _approve(address holder, address spender, uint256 value, bool emitEvent) internal {
        if (holder == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }

        _allowances[holder][spender] = value;
        if (emitEvent) {
            emit Approval(holder, spender, value);
        }
    }

    function _spendAllowance(address holder, address spender, uint256 value) internal {
        uint256 currentAllowance = _allowances[holder][spender];
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(holder, spender, currentAllowance - value, false);
            }
        }
    }
}

{
  "compilationTarget": {
    "contracts/TEST.sol": "TEST"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@uniswap/v2-core/=lib/v2-core/",
    ":@uniswap/v2-periphery/=lib/v2-periphery/",
    ":@uniswap/v3-core/=lib/v3-core/",
    ":forge-std/=lib/forge-std/src/",
    ":v2-core/=lib/v2-core/",
    ":v2-periphery/=lib/v2-periphery/",
    ":v3-core/=lib/v3-core/",
    ":v3-periphery/=lib/v3-periphery/"
  ]
}