Contract Address Details

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

import "./Access.sol"; // Assuming AuthLib includes all the functionality as discussed

/**
 * @title AccessManager
 * @dev A contract for managing role-based access control. Allows accounts to be granted or revoked roles, and checks for required ranks.
 * This contract uses the AuthLib library for role management.
 */
contract AccessManager {
    using AuthLib for AuthLib.RoleData;

    // State variable for storing role data
    AuthLib.RoleData private roleData;

    // Event declarations for logging changes in role assignments
    event RoleGranted(address indexed account, AuthLib.Rank role);
    event RoleRevoked(address indexed account);
    modifier onlyGladiator() {
        require(checkRole(msg.sender,  AuthLib.Rank.GLADIATOR), "Access Restricted");
        _;
    }

    modifier onlySenator() {
        require(checkRole(msg.sender,  AuthLib.Rank.SENATOR), "Access Restricted");
        _;
    }

    modifier onlyConsul() {
        require(checkRole(msg.sender,  AuthLib.Rank.CONSUL),"Access Restricted");
        _;
    }

    modifier onlyLegatus() {
        require(checkRole(msg.sender,  AuthLib.Rank.LEGATUS),"Access Restricted");
        _;
    }
                    
    modifier onlyPreatormaximus() {
        require(checkRole(msg.sender,  AuthLib.Rank.PREATORMAXIMUS),"Access Restricted");
        _;
    }
       uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
    /**
     * @dev Constructor that grants the contract deployer the highest role (PREATORMAXIMUS).
     */
    constructor() {
        // Grant the deployer the highest role initially
        roleData.grantRole(msg.sender, AuthLib.Rank.PREATORMAXIMUS);
    }

    /**
     * @notice Grants a specific role to an account.
     * @dev Only accounts with the CONSUL or higher role can grant roles.
     * @param account The address of the account to grant the role to.
     * @param rank The rank (role) to assign to the account.
     */
    function grantRole(address account, AuthLib.Rank rank) public {
        // Check if the caller has sufficient privileges (CONSUL or higher)
        require(
            roleData.getHighestRankForAccount(msg.sender) >= AuthLib.Rank.CONSUL,
            "Insufficient privileges to grant roles."
        );
        // Grant the role to the specified account
        roleData.grantRole(account, rank);
        // Emit an event for logging
        emit RoleGranted(account, rank);
    }

    /**
     * @notice Revokes a role from a specific account.
     * @dev Only accounts with the CONSUL or higher role can revoke roles.
     * @param account The address of the account to revoke the role from.
     */
    function revokeRole(address account) public {
        // Check if the caller has sufficient privileges (CONSUL or higher)
        require(
            roleData.getHighestRankForAccount(msg.sender) >= AuthLib.Rank.CONSUL,
            "Insufficient privileges to revoke roles."
        );
        // Revoke the role from the specified account
        roleData.revokeRole(account);
        // Emit an event for logging
        emit RoleRevoked(account);
    }

    /**
     * @notice Checks if an account has a specific role or higher.
     * @param account The address of the account to check.
     * @param rank The required rank to check against.
     * @return True if the account holds the required rank or higher, false otherwise.
     */
    function checkRole(address account, AuthLib.Rank rank) public view returns (bool) {
        // Check if the account has the specified role or higher
        return roleData.getHighestRankForAccount(account) >= rank;
    }

    /**
     * @notice Returns the highest rank (role) assigned to an account.
     * @param account The address of the account to query.
     * @return The rank held by the account.
     */
    function getAccountRank(address account) public view returns (AuthLib.Rank) {
        // Retrieve the highest rank assigned to the account
        return roleData.getHighestRankForAccount(account);
    }
}
        

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

/**
 * @title AuthLib
 * @dev A library for managing role-based access control (RBAC) using ranks. Allows accounts to be granted or revoked roles, and checks for required ranks.
 */
library AuthLib {
    // Custom error for unauthorized account access
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    // Enum representing different ranks in the system
    enum Rank {
        PRINCEPS,
        GLADIATOR,
        LEGATUS,
        SENATOR,
        CONSUL,       
        PREATORMAXIMUS
    }

    // Registry structure to store keys and their corresponding ranks
    struct Registry {
        uint256[] keys;  // Array to hold registered keys
        mapping(uint256 => uint256) indexOf;  // Maps key to its index in the keys array
        mapping(uint256 => bool) inserted;    // Tracks whether a key is inserted
        mapping(uint256 => Rank) keyRoles;    // Maps key to its assigned rank
    }

    // RoleData structure for managing roles of accounts
    struct RoleData {
        Registry registry;                  // Holds the registry for keys and roles
        mapping(address => Rank) ranks;     // Maps accounts to their assigned ranks
    }

    // Events
    event RoleGranted(address indexed account, Rank role);
    event RoleRevoked(address indexed account, Rank role);

    /**
     * @dev Registers a key with a specified rank in the registry.
     * @param _registry The registry where the key will be stored.
     * @param key The key to register (typically the address cast to uint256).
     * @param rank The rank to assign to the key.
     */
    function Register(Registry storage _registry, uint256 key, Rank rank) public {
        if (!_registry.inserted[key]) {
            _registry.inserted[key] = true;
            _registry.indexOf[key] = _registry.keys.length;
            _registry.keys.push(key);
            _registry.keyRoles[key] = rank;  // Store the rank with the key
        } else {
            // Update the rank if already registered
            _registry.keyRoles[key] = rank;
        }
    }

    /**
     * @dev Removes a key from the registry.
     * @param _registry The registry from which the key will be removed.
     * @param key The key to remove.
     */
    function Remove(Registry storage _registry, uint256 key) public {
        if (!_registry.inserted[key]) return;
        delete _registry.inserted[key];
        uint256 index = _registry.indexOf[key];
        uint256 lastKey = _registry.keys[_registry.keys.length - 1];
        _registry.keys[index] = lastKey;
        _registry.indexOf[lastKey] = index;
        delete _registry.indexOf[key];
        _registry.keys.pop();
        delete _registry.keyRoles[key];  // Remove the associated role
    }

    /**
     * @dev Grants a role (rank) to an account. This updates the registry and emits a RoleGranted event.
     * @param roleData The RoleData struct that holds the registry and ranks.
     * @param account The account to grant the role to.
     * @param rank The rank to assign to the account.
     */
    function grantRole(RoleData storage roleData, address account, Rank rank) public {
        uint256 key = uint256(uint160(account)); 
        roleData.ranks[account] = rank;
        Register(roleData.registry, key, rank);
        emit RoleGranted(account, rank);  // Emit event for granting role
    }

    /**
     * @dev Revokes a role (rank) from an account. This updates the registry and emits a RoleRevoked event.
     * @param roleData The RoleData struct that holds the registry and ranks.
     * @param account The account from which the role will be revoked.
     */
    function revokeRole(RoleData storage roleData, address account) public {
        uint256 key = uint256(uint160(account)); 
        Rank role = roleData.ranks[account];  // Capture the role before removal for the event
        delete roleData.ranks[account];
        Remove(roleData.registry, key);
        emit RoleRevoked(account, role);  // Emit event for revoking role
    }

    /**
     * @dev Checks whether an account holds the required role (rank) or higher.
     * @param roleData The RoleData struct that holds the registry and ranks.
     * @param requiredRank The minimum required rank for the account.
     * @param account The account to check for the required rank.
     */
    function checkRole(RoleData storage roleData, Rank requiredRank, address account) public view {
        require(roleData.ranks[account] >= requiredRank, "AccessControlUnauthorizedAccount");
    }

    /**
     * @dev Retrieves the highest rank assigned to an account.
     * @param roleData The RoleData struct that holds the registry and ranks.
     * @param account The account whose rank is being queried.
     * @return The highest rank held by the account.
     */
    function getHighestRankForAccount(RoleData storage roleData, address account) public view returns (Rank) {
        return roleData.ranks[account];
    }
}