HIGH severity: Stops Transactions. The transactions are initially disabled for all users excluding authorized addresses.

Vulnerable code:
//SPDX-License-Identifier: MIT



pragma solidity ^0.8.19;



abstract contract Context {

    function _msgSender() internal view virtual returns (address) {

        return msg.sender;

    }



    function _msgData() internal view virtual returns (bytes calldata) {

        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691

        return msg.data;

    }

}



interface IBEP20 {

    function totalSupply() external view returns (uint256);



    function balanceOf(address account) external view returns (uint256);



    function transfer(address recipient, uint256 amount)

        external

        returns (bool);



    function allowance(address owner, address spender)

        external

        view

        returns (uint256);



    function approve(address spender, uint256 amount) external returns (bool);



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) external returns (bool);



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



    event Approval(

        address indexed owner,

        address indexed spender,

        uint256 value

    );

}



interface IBEP20Metadata is IBEP20 {

    /**

     * @dev Returns the name of the token.

     */

    function name() external view returns (string memory);



    /**

     * @dev Returns the symbol of the token.

     */

    function symbol() external view returns (string memory);



    /**

     * @dev Returns the decimals places of the token.

     */

    function decimals() external view returns (uint8);

}



contract BEP20 is Context, IBEP20, IBEP20Metadata {

    mapping(address => uint256) internal _balances;



    mapping(address => mapping(address => uint256)) internal _allowances;



    uint256 private _totalSupply;



    string private _name;

    string private _symbol;



    /**

     * @dev Sets the values for {name} and {symbol}.

     *

     * The defaut value of {decimals} is 18. To select a different value for

     * {decimals} you should overload it.

     *

     * All two of these values are immutable: they can only be set once during

     * construction.

     */

    constructor(string memory name_, string memory symbol_) {

        _name = name_;

        _symbol = symbol_;

    }



    /**

     * @dev Returns the name of the token.

     */

    function name() public view virtual override returns (string memory) {

        return _name;

    }



    /**

     * @dev Returns the symbol of the token, usually a shorter version of the

     * name.

     */

    function symbol() public view virtual override returns (string memory) {

        return _symbol;

    }



    /**

     * @dev Returns the number of decimals used to get its user representation.

     * For example, if `decimals` equals `2`, a balance of `505` tokens should

     * be displayed to a user as `5,05` (`505 / 10 ** 2`).

     *

     * Tokens usually opt for a value of 18, imitating the relationship between

     * Ether and Wei. This is the value {BEP20} uses, unless this function is

     * overridden;

     *

     * NOTE: This information is only used for _display_ purposes: it in

     * no way affects any of the arithmetic of the contract, including

     * {IBEP20-balanceOf} and {IBEP20-transfer}.

     */

    function decimals() public view virtual override returns (uint8) {

        return 18;

    }



    /**

     * @dev See {IBEP20-totalSupply}.

     */

    function totalSupply() public view virtual override returns (uint256) {

        return _totalSupply;

    }



    /**

     * @dev See {IBEP20-balanceOf}.

     */

    function balanceOf(address account)

        public

        view

        virtual

        override

        returns (uint256)

    {

        return _balances[account];

    }



    /**

     * @dev See {IBEP20-transfer}.

     *

     * Requirements:

     *

     * - `recipient` cannot be the zero address.

     * - the caller must have a balance of at least `amount`.

     */

    function transfer(address recipient, uint256 amount)

        public

        virtual

        override

        returns (bool)

    {

        _transfer(_msgSender(), recipient, amount);

        return true;

    }



    /**

     * @dev See {IBEP20-allowance}.

     */

    function allowance(address owner, address spender)

        public

        view

        virtual

        override

        returns (uint256)

    {

        return _allowances[owner][spender];

    }



    /**

     * @dev See {IBEP20-approve}.

     *

     * Requirements:

     *

     * - `spender` cannot be the zero address.

     */

    function approve(address spender, uint256 amount)

        public

        virtual

        override

        returns (bool)

    {

        _approve(_msgSender(), spender, amount);

        return true;

    }



    /**

     * @dev See {IBEP20-transferFrom}.

     *

     * Emits an {Approval} event indicating the updated allowance. This is not

     * required by the EIP. See the note at the beginning of {BEP20}.

     *

     * Requirements:

     *

     * - `sender` and `recipient` cannot be the zero address.

     * - `sender` must have a balance of at least `amount`.

     * - the caller must have allowance for ``sender``'s tokens of at least

     * `amount`.

     */

    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) public virtual override returns (bool) {

        _transfer(sender, recipient, amount);



        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(

            currentAllowance >= amount,

            "BEP20: transfer amount exceeds allowance"

        );

        _approve(sender, _msgSender(), currentAllowance - amount);



        return true;

    }



    /**

     * @dev Atomically increases the allowance granted to `spender` by the caller.

     *

     * This is an alternative to {approve} that can be used as a mitigation for

     * problems described in {IBEP20-approve}.

     *

     * Emits an {Approval} event indicating the updated allowance.

     *

     * Requirements:

     *

     * - `spender` cannot be the zero address.

     */

    function increaseAllowance(address spender, uint256 addedValue)

        public

        virtual

        returns (bool)

    {

        _approve(

            _msgSender(),

            spender,

            _allowances[_msgSender()][spender] + addedValue

        );

        return true;

    }



    /**

     * @dev Atomically decreases the allowance granted to `spender` by the caller.

     *

     * This is an alternative to {approve} that can be used as a mitigation for

     * problems described in {IBEP20-approve}.

     *

     * Emits an {Approval} event indicating the updated allowance.

     *

     * Requirements:

     *

     * - `spender` cannot be the zero address.

     * - `spender` must have allowance for the caller of at least

     * `subtractedValue`.

     */

    function decreaseAllowance(address spender, uint256 subtractedValue)

        public

        virtual

        returns (bool)

    {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(

            currentAllowance >= subtractedValue,

            "BEP20: decreased allowance below zero"

        );

        _approve(_msgSender(), spender, currentAllowance - subtractedValue);



        return true;

    }



    /**

     * @dev Moves tokens `amount` from `sender` to `recipient`.

     *

     * This is internal function is equivalent to {transfer}, and can be used to

     * e.g. implement automatic token fees, slashing mechanisms, etc.

     *

     * Emits a {Transfer} event.

     *

     * Requirements:

     *

     * - `sender` cannot be the zero address.

     * - `recipient` cannot be the zero address.

     * - `sender` must have a balance of at least `amount`.

     */

    function _transfer(

        address sender,

        address recipient,

        uint256 amount

    ) internal virtual {

        require(sender != address(0), "BEP20: transfer from the zero address");

        require(recipient != address(0), "BEP20: transfer to the zero address");



        uint256 senderBalance = _balances[sender];

        require(

            senderBalance >= amount,

            "BEP20: transfer amount exceeds balance"

        );

        _balances[sender] = senderBalance - amount;

        _balances[recipient] += amount;



        emit Transfer(sender, recipient, amount);

    }



    /** This function will be used to generate the total supply

     * while deploying the contract

     *

     * This function can never be called again after deploying contract

     */

    function _tokengeneration(address account, uint256 amount)

        internal

        virtual

    {

        _totalSupply = amount;

        _balances[account] = amount;

        emit Transfer(address(0), account, amount);

    }



    /**

     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.

     *

     * This internal function is equivalent to `approve`, and can be used to

     * e.g. set automatic allowances for certain subsystems, etc.

     *

     * Emits an {Approval} event.

     *

     * Requirements:

     *

     * - `owner` cannot be the zero address.

     * - `spender` cannot be the zero address.

     */

    function _approve(

        address owner,

        address spender,

        uint256 amount

    ) internal virtual {

        require(owner != address(0), "BEP20: approve from the zero address");

        require(spender != address(0), "BEP20: approve to the zero address");



        _allowances[owner][spender] = amount;

        emit Approval(owner, spender, amount);

    }

}



library Address {

    function sendValue(address payable recipient, uint256 amount) internal {

        require(

            address(this).balance >= amount,

            "Address: insufficient balance"

        );



        (bool success, ) = recipient.call{value: amount}("");

        require(

            success,

            "Address: unable to send value, recipient may have reverted"

        );

    }

}



abstract contract Ownable is Context {

    address private _owner;



    event OwnershipTransferred(

        address indexed previousOwner,

        address indexed newOwner

    );



    constructor() {

        _setOwner(_msgSender());

    }



    function owner() public view virtual returns (address) {

        return _owner;

    }



    modifier onlyOwner() {

        require(owner() == _msgSender(), "Ownable: caller is not the owner");

        _;

    }



    function renounceOwnership() public virtual onlyOwner {

        _setOwner(address(0));

    }



    function transferOwnership(address newOwner) public virtual onlyOwner {

        require(

            newOwner != address(0),

            "Ownable: new owner is the zero address"

        );

        _setOwner(newOwner);

    }



    function _setOwner(address newOwner) private {

        address oldOwner = _owner;

        _owner = newOwner;

        emit OwnershipTransferred(oldOwner, newOwner);

    }

}



interface IFactory {

    function createPair(address tokenA, address tokenB)

        external

        returns (address pair);

}



interface IRouter {

    function factory() external pure returns (address);



    function WETH() external pure returns (address);



    function addLiquidityETH(

        address token,

        uint256 amountTokenDesired,

        uint256 amountTokenMin,

        uint256 amountETHMin,

        address to,

        uint256 deadline

    )

        external

        payable

        returns (

            uint256 amountToken,

            uint256 amountETH,

            uint256 liquidity

        );



    function swapExactTokensForETHSupportingFeeOnTransferTokens(

        uint256 amountIn,

        uint256 amountOutMin,

        address[] calldata path,

        address to,

        uint256 deadline

    ) external;

}



 contract DecentralZone is BEP20, Ownable {

    using Address for address payable;



    IRouter public router;

    address public pair;



    bool private _interlock = false;

    bool private providingLiquidity = true;

    bool public tradingEnabled = false;



    uint256 public tokenLiquidityThreshold = 800000 * 10**18; // 0.1%

    uint256 public MaxTxAmount = 800000000 * 10**18; //no limit

    uint256 public MaxWalletSize = 800000000 * 10**18;  //no limit

    

    address public marketingWallet = 0x679b6165d73Fc19aeC212fC6881B92367634b322;

    address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;



    struct Taxes {

        uint256 marketing;

        uint256 liquidity;

    }



    Taxes private taxes = Taxes(3, 0);

    Taxes private sellTaxes = Taxes(3, 0);



    uint256 public BuyTaxes = taxes.marketing + taxes.liquidity;

    uint256 public SellTaxes = sellTaxes.marketing + sellTaxes.liquidity;



    mapping(address => bool) public exemptFee;



    event MaxTxUpdated(uint256 MaxWalletSize, uint256 MaxTxAmount);

    event BuyTaxesUpdated(uint256 marketing,  uint256 liquidity);

    event SellTaxesUpdated(uint256 marketing, uint256 liquidity);

   

    modifier lockTheSwap() {

        if (!_interlock) {

            _interlock = true;

            _;

            _interlock = false;

        }

    }



    constructor() BEP20("DecentralZone", "DZ") {

        _tokengeneration(msg.sender, 800000000 * 10**decimals());

        IRouter _router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

        address _pair = IFactory(_router.factory()).createPair(address(this),_router.WETH());

        router = _router;

        pair = _pair;

        

        exemptFee[msg.sender] = true;

        exemptFee[address(this)] = true;

        exemptFee[marketingWallet] = true;

        exemptFee[deadWallet] = true;

    }



    function approve(address spender, uint256 amount)

        public

        override

        returns (bool)

    {

        _approve(_msgSender(), spender, amount);

        return true;

    }



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) public override returns (bool) {

        _transfer(sender, recipient, amount);



        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(

            currentAllowance >= amount,

            "BEP20: transfer amount exceeds allowance"

        );

        _approve(sender, _msgSender(), currentAllowance - amount);



        return true;

    }



    function increaseAllowance(address spender, uint256 addedValue)

        public

        override

        returns (bool)

    {

        _approve(

            _msgSender(),

            spender,

            _allowances[_msgSender()][spender] + addedValue

        );

        return true;

    }



    function decreaseAllowance(address spender, uint256 subtractedValue)

        public

        override

        returns (bool)

    {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(currentAllowance >= subtractedValue,"BEP20: decreased allowance below zero");

        _approve(_msgSender(), spender, currentAllowance - subtractedValue);



        return true;

    }



    function transfer(address recipient, uint256 amount)

        public

        override

        returns (bool)

    {

        _transfer(msg.sender, recipient, amount);

        return true;

    }



    function _transfer(address sender, address recipient, uint256 amount) internal override {

        require(amount > 0, "Transfer amount must be greater than zero");

        

       if (!exemptFee[sender] && !exemptFee[recipient]) {

            require(tradingEnabled, "Trading not enabled");

        }

        

        if (sender == pair && recipient != address(router) && !exemptFee[recipient] ) {

                require(amount <= MaxTxAmount, "Exceeds the _maxTxAmount.");

                require(balanceOf(recipient) + amount <= MaxWalletSize, "Exceeds the maxWalletSize.");

                

            }

        uint256 feeswap;

        uint256 feesum;

        uint256 fee;

        Taxes memory currentTaxes;



        //set fee to zero if fees in contract are handled or exempted

        if (_interlock || exemptFee[sender] || exemptFee[recipient])

            fee = 0;



            //calculate fee

        else if (recipient == pair) {

            feeswap = sellTaxes.liquidity + sellTaxes.marketing;

            feesum = feeswap;

            currentTaxes = sellTaxes;

        } else if (recipient != pair) {

            feeswap = taxes.liquidity + taxes.marketing;

            feesum = feeswap;

            currentTaxes = taxes;

        } 



        fee = (amount * feesum) / 100;



        //send fees if threshold has been reached

        //don't do this on buys, breaks swap

        if (providingLiquidity && sender != pair)

            Liquify(feeswap, currentTaxes);



        //rest to recipient

        super._transfer(sender, recipient, amount - fee);

        if (fee > 0) {

            //send the fee to the contract

            if (feeswap > 0) {

                uint256 feeAmount = (amount * feeswap) / 100;

                super._transfer(sender, address(this), feeAmount);

            }

        }

  }



    function Liquify(uint256 feeswap, Taxes memory swapTaxes) private lockTheSwap {

        if (feeswap == 0) {

            return;

        }



        uint256 contractBalance = balanceOf(address(this));

        if (contractBalance >= tokenLiquidityThreshold) {

            if (tokenLiquidityThreshold > 1) {

                contractBalance = tokenLiquidityThreshold;

            }



            // Split the contract balance into halves

            uint256 denominator = feeswap * 2;

            uint256 tokensToAddLiquidityWith = (contractBalance * swapTaxes.liquidity) / denominator;

            uint256 toSwap = contractBalance - tokensToAddLiquidityWith;



            uint256 initialBalance = address(this).balance;



            swapTokensForETH(toSwap);



            uint256 deltaBalance = address(this).balance - initialBalance;

            uint256 unitBalance = deltaBalance / (denominator - swapTaxes.liquidity);

            uint256 ethToAddLiquidityWith = unitBalance * swapTaxes.liquidity;



            if (ethToAddLiquidityWith > 0) {

                // Add liquidity to pancake

                addLiquidity(tokensToAddLiquidityWith, ethToAddLiquidityWith);

            }



            uint256 marketingAmt = unitBalance * 2 * swapTaxes.marketing;

            if (marketingAmt > 0) {

                payable(marketingWallet).sendValue(marketingAmt);

            }

        }

    }



    function swapTokensForETH(uint256 tokenAmount) private {

        address[] memory path = new address[](2);

        path[0] = address(this);

        path[1] = router.WETH();



        _approve(address(this), address(router), tokenAmount);



        router.swapExactTokensForETHSupportingFeeOnTransferTokens(

            tokenAmount,

            0,

            path,

            address(this),

            block.timestamp

        );

    }



    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {

        _approve(address(this), address(router), tokenAmount);



        // add the liquidity

        router.addLiquidityETH{value: ethAmount}(

            address(this),

            tokenAmount,

            0, // slippage is unavoidable

            0, // slippage is unavoidable

            deadWallet,

            block.timestamp

        );

    }



    function updateLiquidityProvide(bool state) external onlyOwner {

        providingLiquidity = state;

    }



    function setLiquidityTreshhold(uint256 new_amount) external onlyOwner {

        require(new_amount <= 8000000,"Swap threshold amount should be lower or equal to 1% of tokens");

        tokenLiquidityThreshold = new_amount * 10**decimals();

    }



    function updateBuyFee( uint256 _marketing, uint256 _liquidity) external onlyOwner {

        taxes.marketing = _marketing;

        taxes.liquidity = _liquidity;

     require((_marketing +  _liquidity ) <= 5, "Must keep fees at 5% or less");

     emit BuyTaxesUpdated(_marketing, _liquidity);

    }



    function updateSellFee( uint256 _marketing, uint256 _liquidity) external onlyOwner {

        sellTaxes.marketing = _marketing;

        sellTaxes.liquidity = _liquidity;

    require((_marketing +  _liquidity ) <= 5, "Must keep fees at 5% or less");

    emit SellTaxesUpdated(_marketing, _liquidity);

    }

   

     function setMaxTxLimit(uint256 _maxWallet, uint256 _maxTx) external onlyOwner {

        MaxWalletSize = _maxWallet * 10**decimals(); 

        MaxTxAmount = _maxTx * 10**decimals();

    require (_maxWallet >= 800000, "Cannot set MaxWallet amount lower then 0.1%");

    require (_maxTx >= 800000, "Cannot set MaxTx amount lower then 0.1%");

    emit MaxTxUpdated(_maxWallet, _maxTx);

    }

    

    function enableTrading() external onlyOwner {

        require(!tradingEnabled, "Cannot re-enable trading");

        tradingEnabled = true;

    }

   

    function setMarketingWallet(address newWallet) external onlyOwner {

        require(newWallet != address(0), "Fee Address cannot be zero address");

        require(newWallet != address(this), "Fee Address cannot be CA");

        exemptFee[newWallet] = true;

        marketingWallet = newWallet;

    }



    function excludeFromFee(address _address) external onlyOwner {

        exemptFee[_address] = true;

    }



    function includeInFee(address _address) external onlyOwner {

        exemptFee[_address] = false;

    }



    function rescueEHT() external onlyOwner {

        uint256 contractETHBalance = address(this).balance;

        payable(owner()).transfer(contractETHBalance);

    }



    function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {

        require(tokenAdd != address(this), "Owner can't claim contract's balance of its own tokens");

        IBEP20(tokenAdd).transfer(owner(), amount);

    }



    // fallbacks

    receive() external payable {}

}

Vulnerability type: CWE-284