Access Control Registry

pragma solidity 0.8.23;
interface IAccessControlRegistry {
    // Emitted when a contract is registered.
    // @param _contract The address of the registered contract.
    // @param _admin The address of the admin for the registered contract.
    event ContractRegistered(address indexed _contract, address indexed _admin);
    // Emitted when a contract is unregistered.
    // @param _contract The address of the unregistered contract.
    // @param _admin The address who unregistered the contract
    event ContractUnregistered(address indexed _contract, address indexed _admin);
    // Emitted when a role is granted to an account for a contract.
    // @param targetContract The address of the contract.
    // @param role The role being granted.
    // @param account The address of the account.
    event RoleGranted(
        address indexed targetContract,
        bytes32 indexed role,
        address indexed account
    );
    // Emitted when a role is revoked from an account for a contract.
    // @param targetContract The address of the contract.
    // @param role The role being revoked.
    // @param account The address of the account.
    event RoleRevoked(
        address indexed targetContract,
        bytes32 indexed role,
        address indexed account
    );
    // Registers a contract with the given admin.
    // @param _admin The address of the admin for the registered contract.
    function registerContract(address _admin) external;
    // Unregisters a contract.
    // @param _contract The address of the contract to unregister.
    function unRegisterContract(address _contract) external;
    // Grants roles to multiple accounts for multiple contracts.
    // @param targetContracts An array of contract addresses to which roles will be granted.
    // @param roles An array of roles to be granted.
    // @param accounts An array of accounts to be granted the roles.
    function grantRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) external;
    // Revokes roles from multiple accounts for multiple contracts.
    // @param targetContracts An array of contract addresses from which roles will be revoked.
    // @param roles An array of roles to be revoked.
    // @param accounts An array of accounts from which the roles will be revoked.
    function revokeRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) external;
    
    //Gets the information of a registered contract.
    //@param _contract The address of the contract to get the information.
    //@return isActive Whether the contract is active.
    //@return admin The address of the admin for the contract.
    //MUST revert if the registered contract doesn't exist
    function getContractInfo(
        address _contract
    ) external view returns (bool isActive, address admin);
    // Gets the information of a registered contract.
    // @param _contract The address of the contract to get the information.
    // @return isActive Whether the contract is active.
    // @return admin The address of the admin for the contract.
    // MUST revert if the registered contract doesn't exist`
    function getRoleInfo(
        address _contract
    ) external view returns (bool isActive, address admin);
}

pragma solidity 0.8.23;

import "./IAccessControlRegistry.sol";

contract AccessControlRegistry is IAccessControlRegistry {

    // Contains information about a registered contract.
    // @param isActive Indicates whether the contract is active.
    // @param admin The address of the admin for the registered contract.
    struct ContractInfo {
        bool isActive;
        address admin;
    }

    // Mapping to store information of registered contracts
    mapping(address => ContractInfo) public contracts;

    // Mapping to track roles assigned to accounts for specific contracts
    mapping(address => mapping(address => mapping(bytes32 => bool))) public _contractRoles;

    // Custom error to handle duplicate registration attempts
    error ContractAlreadyRegistered();

    // Modifier to check if the caller is an admin or the contract itself
    modifier onlyAdminOrContract(address _contract) {
        require(
            _isAdmin(_contract, msg.sender) || 
            (contracts[msg.sender].isActive && msg.sender == _contract),
            "Caller is not admin nor contract"
        );
        _;
    }

    // Modifier to check if the caller is an admin of the contract
    modifier onlyAdmin(address _contract) {
        require(
            _isAdmin(_contract, msg.sender),
            "Caller is not an admin"
        );
        _;
    }

    // Modifier to ensure the contract is active
    modifier onlyActiveContract(address _contract) {
        require(contracts[_contract].isActive, "Contract not registered");
        _;
    }

    // Modifier to validate if the provided address is non-zero
    modifier validAddress(address addr) {
        require(addr != address(0), "Invalid address");
        _;
    }

    // Registers a contract with the given admin
    // _admin: Address of the admin to register
    function registerContract(address _admin) external validAddress(_admin) {
        address _contract = msg.sender;

        // Check if the contract is already registered
        ContractInfo storage contractInfo = contracts[_contract];
        if (contractInfo.isActive) {
            revert ContractAlreadyRegistered();
        }

        // Register the contract with the provided admin
        contractInfo.isActive = true;
        contractInfo.admin = _admin;

        emit ContractRegistered(_contract, _admin);
    }

    // Unregisters a contract
    // _contract: Address of the contract to unregister
    function unRegisterContract(address _contract) 
        public 
        onlyAdmin(_contract) 
        onlyActiveContract(_contract) 
    {
        ContractInfo storage contractInfo = contracts[_contract];
        contractInfo.isActive = false;
        contractInfo.admin = address(0);

        emit ContractUnregistered(_contract, msg.sender);
    }

    // Grants roles to multiple accounts for multiple contracts
    // targetContracts: Array of contract addresses
    // roles: Array of roles to grant
    // accounts: Array of accounts to assign the roles
    function grantRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) public {
        require(
            targetContracts.length == roles.length &&
            roles.length == accounts.length,
            "Array lengths do not match"
        );

        uint256 cachedArrayLength = roles.length;

        // Grant roles in a batch
        for (uint256 i; i < cachedArrayLength; ++i) {
            _grantRole(targetContracts[i], roles[i], accounts[i]);
        }
    }

    // Revokes roles from multiple accounts for multiple contracts
    // targetContracts: Array of contract addresses
    // roles: Array of roles to revoke
    // accounts: Array of accounts from which roles are revoked
    function revokeRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) public {
        require(
            targetContracts.length == roles.length &&
            roles.length == accounts.length,
            "Array lengths do not match"
        );

        uint256 cachedArrayLength = roles.length;

        // Revoke roles in a batch
        for (uint256 i; i < cachedArrayLength; ++i) {
            _revokeRole(targetContracts[i], roles[i], accounts[i]);
        }
    }

    // Retrieves information of a registered contract
    // _contract: Address of the contract
    // Returns: isActive status and admin address
    function getContractInfo(address _contract) 
        public 
        view 
        returns (bool isActive, address admin) 
    {
        ContractInfo storage info = contracts[_contract];
        return (info.isActive, info.admin);
    }

    // Gets role information for an account and contract
    // targetContract: Address of the target contract
    // account: Address of the account
    // role: Role identifier
    // Returns: Boolean indicating if the account has the role
    function getRoleInfo(
        address targetContract,
        address account,
        bytes32 role
    ) public view returns (bool) {
        return _contractRoles[targetContract][account][role];
    }

    // Internal function to grant a role to an account for a contract
    function _grantRole(
        address targetContract,
        bytes32 role,
        address account
    )
        internal
        onlyAdminOrContract(targetContract)
        onlyActiveContract(targetContract)
        validAddress(account)
    {
        _contractRoles[targetContract][account][role] = true;
        emit RoleGranted(targetContract, role, account);
    }

    // Internal function to revoke a role from an account for a contract
    function _revokeRole(
        address targetContract,
        bytes32 role,
        address account
    )
        internal
        onlyAdminOrContract(targetContract)
        onlyActiveContract(targetContract)
        validAddress(account)
    {
        require(
            _contractRoles[targetContract][account][role],
            "Role already revoked"
        );
        _contractRoles[targetContract][account][role] = false;
        emit RoleRevoked(targetContract, role, account);
    }

    // Checks if the caller is an admin for the contract
    // _contract: Address of the contract
    // _admin: Address of the admin
    // Returns: Boolean indicating admin status
    function _isAdmin(address _contract, address _admin) internal view returns (bool) {
        return _admin == contracts[_contract].admin;
    }
}