ERC20 Basic counters + Mint — Token

Solidity 0.8.20 · MIT · Optimize 200

Important:

This token contract is provided in single-file source form. If explorer verification fails, you can still:

Compile with Solidity 0.8.20
Optimization enabled (200 runs)
License Identifier (MIT License)
single file contract

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

/* ========= Interfaces ========= */
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner );
}

interface IERC20Counters {
    function txInOf(address u)  external view returns (uint256);
    function txOutOf(address u) external view returns (uint256);
    function txAllOf(address u) external view returns (uint256);
    function txCountersOf(address u)
        external
        view
        returns (uint256 inTx, uint256 outTx, uint256 allTx);
}

/* ========= TOKEN ========= */
contract tokenERC20Advanced is IERC20, IERC20Counters {

    /* ========= METADATA ========= */
    string public name;
    string public symbol;
    uint8  public immutable decimals;

    /* ========= OWNERSHIP ========= */
    address public owner;
    address public pendingOwner;

    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_OWNER");
        _;
    }

    /* ========= ERC20 STATE ========= */
    uint256 public override totalSupply;
    uint256 public immutable maxSupply;

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

    /* ========= COUNTERS ========= */
    struct Cnt { uint64 inTx; uint64 outTx; uint64 allTx; }
    mapping(address => Cnt) private _cnt;
    mapping(address => uint64) public lastTxBlock;
    mapping(address => uint64) public lastTxTime;

    /* ========= ERRORS ========= */
    error ERC20InvalidSender(address sender);
    error ERC20InvalidReceiver(address receiver);
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    error ERC20ApproveNonZeroToNonZero(
        address owner,
        address spender,
        uint256 current,
        uint256 newAmount
    );
    error MaxSupplyExceeded(uint256 requested, uint256 maxSupply);

    /* ========= CONSTRUCTOR ========= */
    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint256 initialSupply_,
        uint256 maxSupply_,
        address owner_
    ) {
        require(owner_ != address(0), "ZERO_OWNER");
        require(maxSupply_ >= initialSupply_, "BAD_CAP");

        name = name_;
        symbol = symbol_;
        decimals = decimals_;
        owner = owner_;
        maxSupply = maxSupply_;

        totalSupply = initialSupply_;
        balanceOf[owner_] = initialSupply_;

        emit Transfer(address(0), owner_, initialSupply_);
    }

    /* ========= ERC20 CORE ========= */
    function transfer(address to, uint256 value) external override returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external override returns (bool) {
        uint256 current = allowance[msg.sender][spender];
        if (current != 0 && value != 0) {
            revert ERC20ApproveNonZeroToNonZero(
                msg.sender,
                spender,
                current,
                value
            );
        }
        _approve(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value)
        external
        override
        returns (bool)
    {
        _spendAllowance(from, msg.sender, value);
        _transfer(from, to, value);
        return true;
    }

    /* ========= MINT / BURN ========= */
    function mint(address to, uint256 amount) external onlyOwner {
        if (to == address(0)) revert ERC20InvalidReceiver(address(0));
        if (totalSupply + amount > maxSupply) {
            revert MaxSupplyExceeded(totalSupply + amount, maxSupply);
        }

        totalSupply += amount;
        balanceOf[to] += amount;
        emit Transfer(address(0), to, amount);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    function _burn(address from, uint256 amount) internal {
        uint256 bal = balanceOf[from];
        if (bal < amount) revert ERC20InsufficientBalance(from, bal, amount);

        unchecked {
            balanceOf[from] = bal - amount;
            totalSupply -= amount;
        }

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

    /* ========= COUNTER VIEWS ========= */
    function txInOf(address u) external view override returns (uint256) {
        return _cnt[u].inTx;
    }

    function txOutOf(address u) external view override returns (uint256) {
        return _cnt[u].outTx;
    }

    function txAllOf(address u) external view override returns (uint256) {
        return _cnt[u].allTx;
    }

    function txCountersOf(address u)
        external
        view
        override
        returns (uint256 inTx, uint256 outTx, uint256 allTx)
    {
        Cnt storage c = _cnt[u];
        return (c.inTx, c.outTx, c.allTx);
    }

    /* ========= META / UI VIEWS ========= */
    function getLastBlockOf(address user) external view returns (uint64) {
        return lastTxBlock[user];
    }

    function getLastTimeOf(address user) external view returns (uint64) {
        return lastTxTime[user];
    }

    function getLastBlocks(address[] calldata users)
        external
        view
        returns (uint64[] memory out)
    {
        uint256 n = users.length;
        out = new uint64[](n);
        for (uint256 i; i < n; ++i) {
            out[i] = lastTxBlock[users[i]];
        }
    }

    function getLastTimes(address[] calldata users)
        external
        view
        returns (uint64[] memory out)
    {
        uint256 n = users.length;
        out = new uint64[](n);
        for (uint256 i; i < n; ++i) {
            out[i] = lastTxTime[users[i]];
        }
    }

    function getUserTransaction(address user)
        external
        view
        returns (
            uint64 totalIn,
            uint64 totalOut,
            uint64 totalTx,
            uint64 lastBlock,
            uint64 lastTime
        )
    {
        Cnt storage c = _cnt[user];
        totalIn   = c.inTx;
        totalOut  = c.outTx;
        totalTx   = c.allTx;
        lastBlock = lastTxBlock[user];
        lastTime  = lastTxTime[user];
    }
    
    /* ========= OWNERSHIP TRANSFER ========= */

    /* --- propose new owner --- */
    function transferOwnership(address newOwner) external onlyOwner {
    require(newOwner != address(0), "ZERO_NEW_OWNER");
    pendingOwner = newOwner;
    emit OwnershipTransferStarted(owner, newOwner);
     }

    /* --- accept ownership --- */
    function acceptOwnership() external {
        require(msg.sender == pendingOwner, "NOT_PENDING_OWNER");

       address oldOwner = owner;
       owner = pendingOwner;
       pendingOwner = address(0);

        emit OwnershipTransferred(oldOwner, owner);
    }

     /* --- cancel transfer --- */
     function cancelOwnershipTransfer() external onlyOwner {
         pendingOwner = address(0);
      }

    /* --- Renounce ownership --- */
     function renounceOwnership() external onlyOwner {
          require(pendingOwner == address(0), "PENDING_OWNER_EXISTS");
 
       address oldOwner = owner;
       owner = address(0);

         emit OwnershipTransferred(oldOwner, address(0));
     }
     
     /* --- decrease increase allowance --- */
     function increaseAllowance(address spender, uint256 addedValue)
       external
       returns (bool)
     {
         address owner_ = msg.sender;

         uint256 current = allowance[owner_][spender];
         uint256 updated = current + addedValue; // overflow auto-revert (0.8+)

        _approve(owner_, spender, updated);
         return true;
      }

     function decreaseAllowance(address spender, uint256 subtractedValue)
    external
    returns (bool)
    {
    address owner_ = msg.sender;

    uint256 current = allowance[owner_][spender];
    if (current < subtractedValue) {
        revert ERC20InsufficientAllowance(
            spender,
            current,
            subtractedValue
        );
    }

    unchecked {
        _approve(owner_, spender, current - subtractedValue);
    }
    return true;
    }


    /* ========= INTERNAL ========= */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) revert ERC20InvalidSender(address(0));
        if (to   == address(0)) revert ERC20InvalidReceiver(address(0));

        uint256 fromBal = balanceOf[from];
        if (fromBal < value) {
            revert ERC20InsufficientBalance(from, fromBal, value);
        }

        unchecked {
            balanceOf[from] = fromBal - value;
            balanceOf[to] += value;
        }

        emit Transfer(from, to, value);

        if (value != 0 && from != to) {
            Cnt storage cf = _cnt[from];
            if (cf.outTx < type(uint64).max) cf.outTx++;
            if (cf.allTx < type(uint64).max) cf.allTx++;

            Cnt storage ct = _cnt[to];
            if (ct.inTx < type(uint64).max) ct.inTx++;
            if (ct.allTx < type(uint64).max) ct.allTx++;

            lastTxBlock[from] = uint64(block.number);
            lastTxBlock[to]   = uint64(block.number);
            lastTxTime[from]  = uint64(block.timestamp);
            lastTxTime[to]    = uint64(block.timestamp);
        }
    }

    function _approve(address owner_, address spender, uint256 value) internal {
        if (owner_ == address(0)) revert ERC20InvalidSender(address(0));
        if (spender == address(0)) revert ERC20InvalidReceiver(address(0));

        allowance[owner_][spender] = value;
        emit Approval(owner_, spender, value);
    }

    function _spendAllowance(address owner_, address spender, uint256 value) internal {
        uint256 current = allowance[owner_][spender];
        if (current < value) {
            revert ERC20InsufficientAllowance(spender, current, value);
        }

        if (current != type(uint256).max) {
            unchecked {
                allowance[owner_][spender] = current - value;
            }
        }
    }
}

ERC20 Factory

Solidity 0.8.20 · MIT · Optimize 200




pragma solidity ^0.8.20;

/* ========= FEE ADDRESS INTERFACE ========= */
interface IFeeAddress {
    function creationFee() external view returns (uint256);
}

/* ========= FACTORY ========= */
contract tokenERC20AdvancedFactory {

    /* ========= STATE ========= */
    address public owner;
    address public feeAddress; // address(0) = free

    /* ========= EVENTS ========= */
    event TokenCreated(
        address indexed creator,
        address indexed token,
        string name,
        string symbol,
        uint8 decimals,
        uint256 initialSupply,
        uint256 maxSupply
    );

    event FeeAddressUpdated(
        address indexed oldAddress,
        address indexed newAddress
    );

    /* ========= MODIFIER ========= */
    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_FACTORY_OWNER");
        _;
    }

    /* ========= CONSTRUCTOR ========= */
    constructor(address feeAddress_) {
        owner = msg.sender;
        feeAddress = feeAddress_;
    }

    /* ========= OWNER ========= */
    function setFeeAddress(address newAddress) external onlyOwner {
        address old = feeAddress;
        feeAddress = newAddress;
        emit FeeAddressUpdated(old, newAddress);
    }

    /* ========= FEE VIEW ========= */
    function getCreationFee() external view returns (uint256) {
        if (feeAddress == address(0)) {
            return 0;
        }
        return IFeeAddress(feeAddress).creationFee();
    }

    /* ========= CREATE TOKEN ========= */
    function createToken(
        string calldata name,
        string calldata symbol,
        uint8  decimals,
        uint256 initialSupply,
        uint256 maxSupply
    )
        external
        payable
        returns (address token)
    {
        require(maxSupply >= initialSupply, "BAD_CAP");
        require(decimals <= 18, "DECIMALS_TOO_HIGH");

        /* ===== HANDLE FEE ===== */
        if (feeAddress != address(0)) {
            uint256 fee = IFeeAddress(feeAddress).creationFee();
            require(msg.value == fee, "BAD_FEE");

            (bool ok,) = feeAddress.call{value: msg.value}("");
            require(ok, "FEE_SEND_FAILED");
        } else {
            require(msg.value == 0, "NO_FEE_MODE");
        }

        /* ===== DEPLOY TOKEN ===== */
        token = address(
            new tokenERC20Advanced(
                name,
                symbol,
                decimals,
                initialSupply,
                maxSupply,
                msg.sender
            )
        );

        emit TokenCreated(
            msg.sender,
            token,
            name,
            symbol,
            decimals,
            initialSupply,
            maxSupply
        );
    }
}