Wolfie

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;



contract ERC20 {

    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;

    string private _symbol;



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

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



    constructor(string memory name_, string memory symbol_) {

        _name = name_;

        _symbol = symbol_;

    }



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

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

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

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

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



    function transfer(address recipient, uint256 amount) public returns (bool) {

        _transfer(msg.sender, recipient, 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 sender, address recipient, uint256 amount) public returns (bool) {

        _transfer(sender, recipient, amount);

        _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);

        return true;

    }



    function _transfer(address sender, address recipient, uint256 amount) internal {

        require(sender != address(0), "ERC20: transfer from zero address");

        require(recipient != address(0), "ERC20: transfer to zero address");

        uint256 senderBalance = _balances[sender];

        require(senderBalance >= amount, "ERC20: transfer exceeds balance");

        unchecked { _balances[sender] = senderBalance - amount; }

        unchecked { _balances[recipient] += amount; }

        emit Transfer(sender, recipient, amount);

    }



    function _mint(address account, uint256 amount) internal {

        require(account != address(0), "ERC20: mint to zero address");

        _totalSupply += amount;

        _balances[account] += amount;

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

    }



    function _approve(address owner_, address spender, uint256 amount) internal {

        _allowances[owner_][spender] = amount;

        emit Approval(owner_, spender, amount);

    }

}



contract Ownable {

    address private _owner;

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



    constructor(address initialOwner) {

        require(initialOwner != address(0), "Ownable: zero address");

        _owner = initialOwner;

        emit OwnershipTransferred(address(0), initialOwner);

    }



    modifier onlyOwner() {

        require(msg.sender == _owner, "Ownable: caller not owner");

        _;

    }



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



    function transferOwnership(address newOwner) public onlyOwner {

        require(newOwner != address(0), "Ownable: zero address");

        require(newOwner != _owner, "Ownable: already owner");

        emit OwnershipTransferred(_owner, newOwner);

        _owner = newOwner;

    }

}



contract Wolfie is ERC20, Ownable {

    constructor(address initialOwner)

        ERC20("Wolfie", "WLF")

        Ownable(initialOwner)

    {

        _mint(initialOwner, 10_000_000_000 * 10**decimals());

    }



    function decimals() public pure override returns (uint8) {

        return 18;

    }

}