Token contract code

below is source code off token VBA

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

contract VampireToken is IERC20 {
    string public constant name = "Vampire Auto Bot Token";
    string public constant symbol = "VAB";
    uint8 public constant decimals = 18;
    uint256 public constant totalSupply = 1_000_000_000 * 10**decimals; // 1 billion tokens

    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowances;

    address public owner;

    // Burn mechanism
    uint256 public burnRate = 5; // 0.5% burn rate (scaled by 10)
    uint256 public burnedTokens;

    // Events
    event Burn(address indexed from, uint256 amount);

    constructor() {
        owner = msg.sender;
        balances[owner] = totalSupply; // Assign all tokens to the contract owner
        emit Transfer(address(0), owner, totalSupply);
    }

    // ERC-20 Functions
    function balanceOf(address account) external view override returns (uint256) {
        return balances[account];
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

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

    function approve(address spender, uint256 amount) external override returns (bool) {
        allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        require(allowances[sender][msg.sender] >= amount, "Allowance exceeded");
        allowances[sender][msg.sender] -= amount;
        _transfer(sender, recipient, amount);
        return true;
    }

    // Internal Transfer with Burn Mechanism
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(balances[sender] >= amount, "Insufficient balance");
        require(recipient != address(0), "Invalid recipient address");

        uint256 burnAmount = (amount * burnRate) / 1000; // Calculate 0.5% burn
        uint256 transferAmount = amount - burnAmount;

        balances[sender] -= amount;
        balances[recipient] += transferAmount;

        if (burnAmount > 0) {
            burnedTokens += burnAmount;
            emit Burn(sender, burnAmount);
        }

        emit Transfer(sender, recipient, transferAmount);
    }

    // Burn Function
    function burn(uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance to burn");
        balances[msg.sender] -= amount;
        burnedTokens += amount;
        emit Burn(msg.sender, amount);
    }

    // Total burned tokens
    function totalBurned() external view returns (uint256) {
        return burnedTokens;
    }

    // Only Owner Modifier
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }
}

// Interface for ERC-20
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

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

1. Features of the $VAB Token Contract

1. ERC-20 Standard Compliance

• Implements all basic ERC-20 functions: transfer, approve, transferFrom, and balanceOf.

2. Burn Mechanism

• Automatic Burn: 0.5% of every transaction is burned, reducing the total circulating supply.

• Manual Burn: Token holders can burn their tokens using the burn function.

3. Total Supply

• Fixed total supply of 1 billion $VAB tokens.

4. Ownership

• The contract assigns all initial tokens to the deployer (owner), typically the project’s wallet.