AccessControl — система ролей

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

abstract contract SimpleAccessControl {
    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    mapping(bytes32 => mapping(address => bool)) private roles;

    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    error MissingRole(bytes32 role, address account);
    error ZeroAddress();

    modifier onlyRole(bytes32 role) {
        if (!hasRole(role, msg.sender)) {
            revert MissingRole(role, msg.sender);
        }

        _;
    }

    function hasRole(bytes32 role, address account) public view returns (bool) {
        return roles[role][account];
    }

    function grantRole(bytes32 role, address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (account == address(0)) {
            revert ZeroAddress();
        }

        _grantRole(role, account);
    }

    function revokeRole(bytes32 role, address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (roles[role][account]) {
            roles[role][account] = false;

            emit RoleRevoked(role, account, msg.sender);
        }
    }

    function _grantRole(bytes32 role, address account) internal {
        if (!roles[role][account]) {
            roles[role][account] = true;

            emit RoleGranted(role, account, msg.sender);
        }
    }
}

contract RoleToken is SimpleAccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");

    string public constant name = "Role Token";
    string public constant symbol = "ROLE";
    uint8 public constant decimals = 18;

    uint256 public totalSupply;
    bool public paused;

    mapping(address => uint256) public balanceOf;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event PauseUpdated(bool paused);
    event TreasuryWithdrawn(address indexed to, uint256 amount);

    error Paused();
    error ZeroAmount();
    error NotEnoughBalance(uint256 available, uint256 required);
    error EthTransferFailed();

    constructor(address admin) {
        if (admin == address(0)) {
            revert ZeroAddress();
        }

        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(MINTER_ROLE, admin);
        _grantRole(PAUSER_ROLE, admin);
        _grantRole(TREASURER_ROLE, admin);
    }

    receive() external payable {}

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        if (to == address(0)) {
            revert ZeroAddress();
        }

        if (amount == 0) {
            revert ZeroAmount();
        }

        totalSupply += amount;
        balanceOf[to] += amount;

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

    function transfer(address to, uint256 amount) external {
        if (paused) {
            revert Paused();
        }

        if (to == address(0)) {
            revert ZeroAddress();
        }

        if (amount == 0) {
            revert ZeroAmount();
        }

        uint256 balance = balanceOf[msg.sender];

        if (balance < amount) {
            revert NotEnoughBalance(balance, amount);
        }

        balanceOf[msg.sender] = balance - amount;
        balanceOf[to] += amount;

        emit Transfer(msg.sender, to, amount);
    }

    function setPaused(bool newPaused) external onlyRole(PAUSER_ROLE) {
        paused = newPaused;

        emit PauseUpdated(newPaused);
    }

    function withdrawTreasury(address payable to) external onlyRole(TREASURER_ROLE) {
        if (to == address(0)) {
            revert ZeroAddress();
        }

        uint256 amount = address(this).balance;

        if (amount == 0) {
            revert ZeroAmount();
        }

        (bool success, ) = to.call{value: amount}("");

        if (!success) {
            revert EthTransferFailed();
        }

        emit TreasuryWithdrawn(to, amount);
    }
}