Memecoin

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

/// @title Memecoin
/// @notice Bare-bones, immutable ERC20. Full supply is minted to the deployer
///         (your dev wallet) at construction. There is no owner, no mint
///         function, no tax, no blacklist, no pause, and no trading toggle.
///         Nothing can be changed after deploy. Transfers work immediately,
///         so the token becomes tradeable the instant you seed liquidity.
contract Memecoin {
    string public name;
    string public symbol;
    uint8 public constant decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    /// @param _name              token name, e.g. "Based Frog"
    /// @param _symbol            token symbol, e.g. "BFROG"
    /// @param _supplyWholeTokens supply in whole tokens (NOT wei). e.g. 1_000_000_000
    ///                           mints _supplyWholeTokens * 10**18 to msg.sender.
    constructor(
        string memory _name,
        string memory _symbol,
        uint256 _supplyWholeTokens
    ) {
        name = _name;
        symbol = _symbol;

        uint256 supply = _supplyWholeTokens * 10 ** decimals;
        totalSupply = supply;
        balanceOf[msg.sender] = supply;

        emit Transfer(address(0), msg.sender, supply);
    }

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

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) {
            require(allowed >= amount, "insufficient allowance");
            unchecked {
                allowance[from][msg.sender] = allowed - amount;
            }
        }
        _transfer(from, to, amount);
        return true;
    }

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

    /// @notice Optional. Lets a holder destroy their own tokens. Delete if unwanted.
    function burn(uint256 amount) external {
        uint256 bal = balanceOf[msg.sender];
        require(bal >= amount, "insufficient balance");
        unchecked {
            balanceOf[msg.sender] = bal - amount;
            totalSupply -= amount;
        }
        emit Transfer(msg.sender, address(0), amount);
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(to != address(0), "transfer to zero address");
        uint256 bal = balanceOf[from];
        require(bal >= amount, "insufficient balance");
        unchecked {
            balanceOf[from] = bal - amount;
            balanceOf[to] += amount;
        }
        emit Transfer(from, to, amount);
    }
}