Contract Source Code:

/**
                         nnnnnnn                                                                                                                                                        
                        nnnnnnnnnnnnn                                                                                                                                                   
                       nnnnnnnnnnnnnnnnnn                                                                                                                                               
                      nnnnnn  nnnnnnnnnnnnn           nnnnnnnnnn  nnnnnnnnnnnnnnnnn       nnnnnnnnnnnnnnn  nnnnnnnnnnnnn  nnnnnnnnnn              nnnnnnnnn        nnnnn                
                     nnnnnn        nnnnnnnnnn         nnnnnnnnnn  nnnnnnnnnnnnnnnnn       nnnnnnnnnnnnnnn  nnnnnnnnnnnnnn nnnnnnnnnn              nnnnnnnnnnn      nnnnn                
                     nnnnnn           nnnnnnnn        nnnn                     nnnn       nnnnnnnnn                  nnnnnnnnn        nnnnn       nnnnnnnnnnnn     nnnnn                
                     nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn                     nnnn       nnnnnnnnn                  nnnnnnnnn        nnnnn       nnnnnnnnnnnnnn   nnnnn                
                    nnnnnnnnnnnnnnnnnnnnnnnnnnnn      nnnnnnnnnnnnn    nnnn    nnnn       nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn nnnnnnnnnnnnnnnnn       nnnnnnnnnnnnnnn  nnnnn                
                    nnnnnnnnnnnnnnnnnnnn              nnnnnnnnnnnnn    nnnn               nnnnnnnnnnnnnnnnnnnnnnnnnnnnnn  nnnnnnnnnnnnnnnnn       nnnnnnnnn nnnnnn nnnnn                
                    nnnnnnnnnnnn        nnnnnnn       nnnnnnnnnnnn     nnnn    nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn    nnnnnnnnnnnnnnnnn       nnnnnnnnn  nnnnnnnnnnn                
                     nn                nnnnnnn        nnnn             nnnn    nnnnnnnnnnnnnnnnnnnn        nnnnn  nnnnn   nnnn        nnnnn      nnnnnnnnnn    nnnnnnnnn                
                 nnnnnnnnnn         nnnnnnnn          nnnnnnnnn        nnnn    nnnnnnnnnnnnnnnnnnnnnnnnnn  nnnnn   nnnnn  nnnn         nnnnnnnnnnnnnnn          nnnnnnnn                
                    nnnnnnnn   nnnnnnnnnnnn           nnnnnnnnnn       nnnn    nnnn       nnnnnnnnnnnnnnn  nnnnn    nnnnn nnnn          nnnnnnnnnnnnn            nnnnnnn                
                      nnnnnnnnnnnnnnnnnn              nnnnnnnnnn       nnnn    nnnn       nnnnnnnnnnnnnnn  nnnnn     nnnnnnnnn            nnnnnnnn                nnnnnn                
                       nnnnnnnnnnnnnnn                                                                                                                                                  
                        nnnnnnnnn                                                                                                                                                       
                              
*/

//SPDX-License-Identifier: UNLICENSED

// Etherfun $eFUN - Earn, Create, and Trade- Powered by AI, Fueled by Memes!
// W: https://www.ether-fun.com/
// T: https://t.me/etherfunentry
// X: https://x.com/ether_fun

pragma solidity 0.8.19;

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

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) 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);
}

library Address {
    function sendValue(
        address payable recipient,
        uint256 amount
    ) internal returns (bool) {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

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

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

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

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

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

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

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

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

    function transfer(
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(
        address owner,
        address spender
    ) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        uint256 currentAllowance = _allowances[sender][_msgSender()];
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: transfer amount exceeds allowance"
            );
            unchecked {
                _approve(sender, _msgSender(), currentAllowance - amount);
            }
        }

        _transfer(sender, recipient, amount);

        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender] + addedValue
        );
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        uint256 senderBalance = _balances[sender];
        require(
            senderBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }

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

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

    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 Etherfun is ERC20, Ownable {
    using Address for address payable;

    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;

    mapping(address => bool) private _isExcludedFromFees;

    address public marketingFeeReceiver;
    uint256 public tradingEnabledTime;

    bool private inSwapAndLiquify;
    bool public swapEnabled;
    bool public tradingEnabled;

    uint256 public marketingFee;
    uint256 public maxSwapThreshold;
    uint256 public maxWalletSize;

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SwapAndSendFee(uint256 tokensSwapped, uint256 bnbSend);
    event MarketingFeeReceiverChanged(address marketingFeeReceiver);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 bnbReceived,
        uint256 tokensIntoLiqudity
    );
    event ToggleSwapping(bool swapEnabled);
    event FeesLowered(uint256 _new);
    event MaxWalletSizeRaised(uint256 _new);
    event MaxSwapThresholdUpdated(uint256 _new);

    constructor(address _router, address _feeReceiver, uint256 _initalLiquidity) payable ERC20("Etherfun", "eFUN") { //uniswapv2router address, feereceiving wallet, Tokenname, symbol
        
        marketingFee = 25;

        marketingFeeReceiver = _feeReceiver;
        uniswapV2Router = IUniswapV2Router02(_router);

        //Excluding wallets from fees
        _isExcludedFromFees[owner()] = true;
        _isExcludedFromFees[address(0xdead)] = true;
        _isExcludedFromFees[address(this)] = true;
        _isExcludedFromFees[marketingFeeReceiver] = true;

        uint256 ownerSupply = 1000000000 * 10**decimals() - _initalLiquidity;

        _mint(owner(), ownerSupply);
        _mint(address(this), _initalLiquidity);

        maxWalletSize = 15000000*10**decimals();
        maxSwapThreshold = 15000000*10**decimals();
        
        swapEnabled = false;
        tradingEnabled = false;

    }

    receive() external payable {}

    function claimStuckTokens(address token) external onlyOwner {
        require(
            token != address(this),
            "Owner cannot claim contract's balance of its own tokens"
        );
        if (token == address(0x0)) {
            payable(msg.sender).sendValue(address(this).balance);
            return;
        }

        IERC20(token).transfer(
            msg.sender,
            IERC20(token).balanceOf(address(this))
        );
    }

    function excludeFromFees(
        address account,
        bool excluded
    ) external onlyOwner {
        _isExcludedFromFees[account] = excluded;

        emit ExcludeFromFees(account, excluded);
    }

    function isExcludedFromFees(address account) public view returns (bool) {
        return _isExcludedFromFees[account];
    }

    function changeFeeReceiver(
        address _marketingFeeReceiver
    ) external onlyOwner {
        require(
            _marketingFeeReceiver != address(0) &&
            _marketingFeeReceiver != address(0xdead),
            "Marketing Fee receiver cannot be the zero or dead address"
        );
        marketingFeeReceiver = _marketingFeeReceiver;

        emit MarketingFeeReceiverChanged(marketingFeeReceiver);
    }

    event TradingEnabled(bool tradingEnabled, uint256 tradingEnabledTime);

    function enableTrading() external onlyOwner {
        require(tradingEnabled == false, "O3D: trading already enabled!");
        _approve(address(this), address(uniswapV2Router), type(uint256).max);
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        tradingEnabled = true;
        swapEnabled = true;
        tradingEnabledTime = block.timestamp;
        _isExcludedFromFees[uniswapV2Pair] = true;

        emit TradingEnabled(tradingEnabled, tradingEnabledTime);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "Transfer from the zero address");
        require(to != address(0), "Transfer to the zero address");
        require(tradingEnabled 
                || _isExcludedFromFees[from] 
                || _isExcludedFromFees[to],
            "Trading not yet enabled!"
        );

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

        uint256 contractTokenBalance = balanceOf(address(this));

        uint256 _totalFees;
        if (_isExcludedFromFees[from] && _isExcludedFromFees[to] && inSwapAndLiquify) {
            _totalFees = 0;
        } else if (from == uniswapV2Pair || to == uniswapV2Pair && tradingEnabled) {
            _totalFees = marketingFee;
        } else {
            _totalFees = 0;
        }

        if (_totalFees > 0) {
            uint256 fees = (amount * _totalFees) / 100;
            amount = amount - fees;
            super._transfer(from, address(this), fees);
        }

        if(to == uniswapV2Pair) {
            if (contractTokenBalance > maxSwapThreshold && !inSwapAndLiquify && swapEnabled) {
                inSwapAndLiquify = true;

                _swapAndSendMarketing(maxSwapThreshold);
                
                inSwapAndLiquify = false;
            }
        }

        if(tradingEnabled && !_isExcludedFromFees[to] && !inSwapAndLiquify) {
            uint256 toWalletSize = balanceOf(to);
            require(toWalletSize + amount <= maxWalletSize, "Maximum wallet size exceeded!");
        }

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

    function toggleSwapping(bool _swapEnabled) external onlyOwner {
        require(swapEnabled != _swapEnabled, "Currently at the same stage");
        swapEnabled = _swapEnabled;
        emit ToggleSwapping(swapEnabled);
    }

    function _swapAndSendMarketing(uint256 tokenAmount) private {
        uint256 initialBalance = address(this).balance;

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

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

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

        payable(marketingFeeReceiver).sendValue(newBalance);

        emit SwapAndSendFee(tokenAmount, newBalance);
    }

    function sellFees() public onlyOwner() {
        uint256 contractBalance = balanceOf(address(this));
        _swapAndSendMarketing(contractBalance);
    }

    function lowerFees(uint256 _newFee) public onlyOwner() {
        require(_newFee < marketingFee, "O3D: New fee must be lower than old fee!");

        marketingFee = _newFee;

        emit FeesLowered(_newFee);
    }

    function raiseMaxLimit(uint256 _newLimit) public onlyOwner() {
        require(_newLimit > maxWalletSize, "O3D: New limit must be higher than older!");

        maxWalletSize = _newLimit;

        emit MaxWalletSizeRaised(_newLimit);
    }

    function setSwapThreshold(uint256 _newThreshold) public onlyOwner {
        maxSwapThreshold = _newThreshold;

        emit MaxSwapThresholdUpdated(_newThreshold);
    }
}