/*
     Collective DAO is a community-driven platform on the Ethereum Mainnet, 
     focused on launching innovative projects and sharing revenue amongst our members. 
     With our token $CLXV, you'll have the opportunity to participate in governance, 
     access exclusive tools, and benefit from our dual revenue streams.
 ____               ___       ___                       __                                     ____       ______      _____      
/\  _`\            /\_ \     /\_ \                     /\ \__    __                           /\  _`\    /\  _  \    /\  __`\    
\ \ \/\_\    ___   \//\ \    \//\ \       __     ___   \ \ ,_\  /\_\    __  __     __         \ \ \/\ \  \ \ \L\ \   \ \ \/\ \   
 \ \ \/_/_  / __`\   \ \ \     \ \ \    /'__`\  /'___\  \ \ \/  \/\ \  /\ \/\ \  /'__`\        \ \ \ \ \  \ \  __ \   \ \ \ \ \  
  \ \ \L\ \/\ \L\ \   \_\ \_    \_\ \_ /\  __/ /\ \__/   \ \ \_  \ \ \ \ \ \_/ |/\  __/         \ \ \_\ \  \ \ \/\ \   \ \ \_\ \ 
   \ \____/\ \____/   /\____\   /\____\\ \____\\ \____\   \ \__\  \ \_\ \ \___/ \ \____\         \ \____/   \ \_\ \_\   \ \_____\
    \/___/  \/___/    \/____/   \/____/ \/____/ \/____/    \/__/   \/_/  \/__/   \/____/          \/___/     \/_/\/_/    \/_____/
                                                                                                                                      

     Website: https://collectivedao.org
     Telegram: https://t.me/collectivexdao
     Twitter: https://x.com/collectivexdao
     Docs: https://docs.collectivedao.org
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.21;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        _status = _ENTERED;

        _;

        _status = _NOT_ENTERED;
    }
}

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

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 IERC20 {
    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 IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

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

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

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;
    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /// @notice Returns the name of the token
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /// @notice Returns the symbol of the token
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /// @notice Returns the decimals used in the token
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /// @notice Returns the total supply of the token
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /// @notice Returns the balance of a specific account
    /// @param account The address of the account
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /// @notice Transfers tokens to a recipient
    /// @param recipient The address of the recipient
    /// @param amount The amount of tokens to transfer
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /// @notice Returns the allowance for a spender
    /// @param owner The address of the token owner
    /// @param spender The address of the spender
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /// @notice Approves a spender to spend a specified amount of tokens
    /// @param spender The address of the spender
    /// @param amount The amount of tokens to approve
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /// @notice Transfers tokens on behalf of a sender
    /// @param sender The address of the sender
    /// @param recipient The address of the recipient
    /// @param amount The amount of tokens to transfer
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
        return true;
    }

    /// @notice Increases the allowance of a spender
    /// @param spender The address of the spender
    /// @param addedValue The amount to increase the allowance by
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /// @notice Decreases the allowance of a spender
    /// @param spender The address of the spender
    /// @param subtractedValue The amount to decrease the allowance by
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
        return true;
    }

    /// @notice Internal function for transferring tokens
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), 'ERC20: transfer from the zero address');
        require(recipient != address(0), 'ERC20: transfer to the zero address');

        _balances[sender] -= amount;
        _balances[recipient] += amount;
        emit Transfer(sender, recipient, amount);
    }

    /// @notice Internal function for minting new tokens
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), 'ERC20: mint to the zero address');

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    /// @notice Internal function for burning tokens
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), 'ERC20: burn from the zero address');

        _balances[account] -= amount;
        _totalSupply -= amount;
        emit Transfer(account, address(0), amount);
    }

    /// @notice Internal function for approving a spender
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), 'ERC20: approve from the zero address');
        require(spender != address(0), 'ERC20: approve to the zero address');

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
}

contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /// @notice Returns the address of the current owner
    function owner() public view returns (address) {
        return _owner;
    }

    /// @notice Modifier that restricts function access to the owner
    modifier onlyOwner() {
        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
        _;
    }

    /// @notice Renounces ownership of the contract
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /// @notice Transfers ownership to a new owner
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract CollectiveDAO is ERC20, Ownable, ReentrancyGuard {
    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable uniswapV2Pair;
    address public constant deadAddress = address(0xdead);

    bool private swapping;

    address public collectiveDaoWallet;
    address public devWallet;
    address public expenseWallet;

    uint256 public maxTransactionAmount;
    uint256 public maxWallet;
    uint8 private _decimals;

    bool public limitsInEffect = true;
    bool public tradingActive = false;
    bool public swapEnabled = false;
    bool public rescueSwap = false;

    uint256 public tradingActiveBlock;

    uint256 public buyTotalFees;
    uint256 public buyCollectiveDaoFee;
    uint256 public buyLiquidityFee;
    uint256 public buyDevFee;
    uint256 public buyExpenseFee;

    uint256 public sellTotalFees;
    uint256 public sellCollectiveDaoFee;
    uint256 public sellLiquidityFee;
    uint256 public sellDevFee;
    uint256 public sellExpenseFee;

    uint256 public tokensForCollectiveDao;
    uint256 public tokensForLiquidity;
    uint256 public tokensForDev;
    uint256 public tokensForExpense;

    // Exclusions from fees and max transaction amount
    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public _isExcludedMaxTransactionAmount;

    // Store AMM pairs
    mapping(address => bool) public automatedMarketMakerPairs;

    event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    event CollectiveDaoWalletUpdated(address indexed newWallet, address indexed oldWallet);
    event DevWalletUpdated(address indexed newWallet, address indexed oldWallet);
    event ExpenseWalletUpdated(address indexed newWallet, address indexed oldWallet);
    event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
    event ExpenseTriggered(uint256 amount);
    event OwnerForcedSwapBack(uint256 timestamp);

    // Added event declarations for new events
    event TradingEnabled(uint256 blockNumber);
    event LimitsRemoved();
    event MaxTransactionAmountUpdated(uint256 newAmount);
    event MaxWalletUpdated(uint256 newAmount);
    event ExcludedFromMaxTransaction(address account, bool isExcluded);
    event SwapEnabledUpdated(bool enabled);
    event RescueSwapUpdated(bool enabled);
    event BuyFeesUpdated(uint256 collectiveDaoFee, uint256 liquidityFee, uint256 devFee, uint256 expenseFee);
    event SellFeesUpdated(uint256 collectiveDaoFee, uint256 liquidityFee, uint256 devFee, uint256 expenseFee);

    constructor() ERC20('Collective DAO', 'CLXV') {
        address _owner = _msgSender();

        _decimals = 18;

        uint256 totalSupply = 2_500_000_000 * (10 ** _decimals); // 2.5 billion tokens

        maxTransactionAmount = totalSupply * 3 / 100; // 3% max transaction
        maxWallet = totalSupply * 3 / 100; // 3% max wallet

        buyCollectiveDaoFee = 3;
        buyLiquidityFee = 0;
        buyDevFee = 2;
        buyExpenseFee = 0;
        buyTotalFees = buyCollectiveDaoFee + buyLiquidityFee + buyDevFee + buyExpenseFee; // 5% total buy tax

        sellCollectiveDaoFee = 3;
        sellLiquidityFee = 0;
        sellDevFee = 2;
        sellExpenseFee = 0;
        sellTotalFees = sellCollectiveDaoFee + sellLiquidityFee + sellDevFee + sellExpenseFee; // 5% total sell tax

        collectiveDaoWallet = 0xb60D8Db0bCFe97c808544B4B2844856f84c57a86; // DAO Treasury Wallet 
        devWallet = 0x7F7ca22532ddc127e8B5aDb680A5fac8ECB62Ed5; // Development Wallet
        expenseWallet = 0xb60D8Db0bCFe97c808544B4B2844856f84c57a86; 

        address currentRouter;

        if (block.chainid == 1 || block.chainid == 4) {
            currentRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; // Ethereum Mainnet Router
        } else if (block.chainid == 8453) {
            currentRouter = 0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24; // Base Mainnet Router
        } else {
            revert("Unsupported chain");
        }

        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(currentRouter);

        excludeFromMaxTransaction(address(_uniswapV2Router), true);
        uniswapV2Router = _uniswapV2Router;

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        excludeFromMaxTransaction(address(uniswapV2Pair), true);
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);

        // Exclude from fees and max transaction amount
        excludeFromFees(_owner, true);
        excludeFromFees(address(this), true);
        excludeFromFees(deadAddress, true);

        excludeFromMaxTransaction(_owner, true);
        excludeFromMaxTransaction(address(this), true);
        excludeFromMaxTransaction(deadAddress, true);

        _mint(_owner, totalSupply);
        transferOwnership(_owner);
    }

    receive() external payable {}

    /// @notice Enables trading for the token, irreversible action
    function enableTrading() external onlyOwner {
        tradingActive = true;
        swapEnabled = true;
        tradingActiveBlock = block.number;
        emit TradingEnabled(block.number);
    }

    /// @notice Removes all transaction and wallet limits
    function removeLimits() external onlyOwner returns (bool) {
        limitsInEffect = false;
        emit LimitsRemoved();
        return true;
    }

    /// @notice Updates the maximum transaction amount
    /// @param newNum The new max transaction amount
    function updateMaxTransactionAmount(uint256 newNum) external onlyOwner {
        require(newNum >= (totalSupply() * 1 / 100), 'Cannot set maxTransactionAmount lower than 1%');
        maxTransactionAmount = newNum;
        emit MaxTransactionAmountUpdated(newNum);
    }

    /// @notice Updates the maximum wallet amount
    /// @param newNum The new max wallet amount
    function updateMaxWallet(uint256 newNum) external onlyOwner {
        require(newNum >= (totalSupply() * 1 / 100), 'Cannot set maxWallet lower than 1%');
        maxWallet = newNum;
        emit MaxWalletUpdated(newNum);
    }

    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
        _isExcludedMaxTransactionAmount[updAds] = isEx;
        emit ExcludedFromMaxTransaction(updAds, isEx);
    }

    /// @notice Enables or disables swapping of tokens for liquidity or fee distribution
    function updateSwapEnabled(bool enabled) external onlyOwner {
        swapEnabled = enabled;
        emit SwapEnabledUpdated(enabled);
    }

    /// @notice Enables or disables rescue mode to stop swaps
    function updateRescueSwap(bool enabled) external onlyOwner {
        rescueSwap = enabled;
        emit RescueSwapUpdated(enabled);
    }

    /// @notice Excludes an account from fees
    /// @param account The address to exclude from fees
    /// @param excluded Boolean indicating whether to exclude or include the account
    function excludeFromFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
        require(pair != uniswapV2Pair, 'Cannot remove pair');
        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;
        emit SetAutomatedMarketMakerPair(pair, value);
    }

    /// @notice Updates the collectiveDaoWallet address
    /// @param newWallet The new collectiveDao wallet address
    function updateCollectiveDaoWallet(address newWallet) external onlyOwner {
        emit CollectiveDaoWalletUpdated(newWallet, collectiveDaoWallet);
        collectiveDaoWallet = newWallet;
    }

    /// @notice Updates the development wallet address
    /// @param newWallet The new development wallet address
    function updateDevWallet(address newWallet) external onlyOwner {
        emit DevWalletUpdated(newWallet, devWallet);
        devWallet = newWallet;
    }

    /// @notice Updates the expense wallet address
    /// @param newWallet The new expense wallet address
    function updateExpenseWallet(address newWallet) external onlyOwner {
        emit ExpenseWalletUpdated(newWallet, expenseWallet);
        expenseWallet = newWallet;
    }

    /// @notice Returns whether an account is excluded from fees
    function isExcludedFromFees(address account) external view returns (bool) {
        return _isExcludedFromFees[account];
    }

    /// @notice Updates the buy fees for the contract
    function updateBuyFees(uint256 newCollectiveDaoFee, uint256 newLiquidityFee, uint256 newDevFee, uint256 newExpenseFee) external onlyOwner {
        require(newCollectiveDaoFee + newLiquidityFee + newDevFee + newExpenseFee <= 5, "Total buy fees cannot exceed 5%");
        
        buyCollectiveDaoFee = newCollectiveDaoFee;
        buyLiquidityFee = newLiquidityFee;
        buyDevFee = newDevFee;
        buyExpenseFee = newExpenseFee;

        buyTotalFees = buyCollectiveDaoFee + buyLiquidityFee + buyDevFee + buyExpenseFee;
        emit BuyFeesUpdated(buyCollectiveDaoFee, buyLiquidityFee, buyDevFee, buyExpenseFee);
    }

    /// @notice Updates the sell fees for the contract
    function updateSellFees(uint256 newCollectiveDaoFee, uint256 newLiquidityFee, uint256 newDevFee, uint256 newExpenseFee) external onlyOwner {
        require(newCollectiveDaoFee + newLiquidityFee + newDevFee + newExpenseFee <= 5, "Total sell fees cannot exceed 5%");
        
        sellCollectiveDaoFee = newCollectiveDaoFee;
        sellLiquidityFee = newLiquidityFee;
        sellDevFee = newDevFee;
        sellExpenseFee = newExpenseFee;

        sellTotalFees = sellCollectiveDaoFee + sellLiquidityFee + sellDevFee + sellExpenseFee;
        emit SellFeesUpdated(sellCollectiveDaoFee, sellLiquidityFee, sellDevFee, sellExpenseFee);
    }

    function _transfer(address from, address to, uint256 amount) internal override {
        require(from != address(0), 'ERC20: transfer from the zero address');
        require(to != address(0), 'ERC20: transfer to the zero address');

        if (!tradingActive) {
            require(_isExcludedFromFees[from] || _isExcludedFromFees[to], 'Trading is not active.');
        }

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        if (limitsInEffect) {
            if (from != owner() && to != owner() && to != address(0) && to != deadAddress && !(_isExcludedFromFees[from] || _isExcludedFromFees[to]) && !swapping) {
                // On buy
                if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
                    require(amount <= maxTransactionAmount, 'Buy exceeds max transaction amount.');
                    require(amount + balanceOf(to) <= maxWallet, 'Exceeds max wallet.');
                }
                // On sell
                else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
                    require(amount <= maxTransactionAmount, 'Sell exceeds max transaction amount.');
                } else {
                    require(amount + balanceOf(to) <= maxWallet, 'Exceeds max wallet.');
                }
            }
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance > 0;

        if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            swapping = true;
            swapBack();
            swapping = false;
        }

        bool takeFee = !swapping;

        // If any account is excluded from fees, remove fee
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        uint256 fees = 0;
        if (takeFee) {
            if (automatedMarketMakerPairs[to]) {
                if (sellTotalFees > 0) {
                    require(sellTotalFees <= 5, "Sell fees cannot exceed 5%");
                    fees = amount * sellTotalFees / 100;
                    tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
                    tokensForDev += (fees * sellDevFee) / sellTotalFees;
                    tokensForCollectiveDao += (fees * sellCollectiveDaoFee) / sellTotalFees;
                    tokensForExpense += (fees * sellExpenseFee) / sellTotalFees;
                }
            } else if (automatedMarketMakerPairs[from]) {
                if (buyTotalFees > 0) {
                    require(buyTotalFees <= 5, "Buy fees cannot exceed 5%");
                    fees = amount * buyTotalFees / 100;
                    tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
                    tokensForDev += (fees * buyDevFee) / buyTotalFees;
                    tokensForCollectiveDao += (fees * buyCollectiveDaoFee) / buyTotalFees;
                    tokensForExpense += (fees * buyExpenseFee) / buyTotalFees;
                }
            }

            if (fees > 0) {
                super._transfer(from, address(this), fees);
            }

            amount -= fees;
        }

        super._transfer(from, to, amount);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

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

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.addLiquidityETH{ value: ethAmount }(
            address(this),
            tokenAmount,
            0,
            0,
            deadAddress,
            block.timestamp
        );
    }

    function swapBack() private nonReentrant {
        uint256 contractBalance = balanceOf(address(this));
        uint256 totalTokensToSwap = tokensForLiquidity + tokensForCollectiveDao + tokensForDev + tokensForExpense;

        if (contractBalance == 0 || totalTokensToSwap == 0) return;

        // Limit swap to 0.5% of total supply
        if (contractBalance > totalSupply() * 5 / 1000) {
            contractBalance = totalSupply() * 5 / 1000;
        }

        // Halve the amount of liquidity tokens
        uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
        uint256 amountToSwapForETH = contractBalance - liquidityTokens;

        uint256 initialETHBalance = address(this).balance;

        swapTokensForEth(amountToSwapForETH);

        uint256 ethBalance = address(this).balance - initialETHBalance;

        uint256 ethForCollectiveDao = ethBalance * tokensForCollectiveDao / totalTokensToSwap;
        uint256 ethForDev = ethBalance * tokensForDev / totalTokensToSwap;
        uint256 ethForExpense = ethBalance * tokensForExpense / totalTokensToSwap;
        uint256 ethForLiquidity = ethBalance - ethForCollectiveDao - ethForDev - ethForExpense;

        tokensForLiquidity = 0;
        tokensForCollectiveDao = 0;
        tokensForDev = 0;
        tokensForExpense = 0;

        payable(devWallet).transfer(ethForDev);
        payable(expenseWallet).transfer(ethForExpense);

        if (liquidityTokens > 0 && ethForLiquidity > 0) {
            addLiquidity(liquidityTokens, ethForLiquidity);
            emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, liquidityTokens);
        }

        payable(collectiveDaoWallet).transfer(address(this).balance);
    }

    /// @notice Rescue ETH from the contract to the owner's wallet
    function rescueETH() external onlyOwner {
        uint256 contractETHBalance = address(this).balance;
        require(contractETHBalance > 0, "No ETH in contract");
        payable(owner()).transfer(contractETHBalance);
    }

    /// @notice Rescue ERC20 tokens from the contract to the owner's wallet
    function rescueTokens(address tokenAddress) external onlyOwner {
        IERC20 token = IERC20(tokenAddress);
        uint256 contractTokenBalance = token.balanceOf(address(this));
        require(contractTokenBalance > 0, "No tokens in contract");
        token.transfer(owner(), contractTokenBalance);
    }
}

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