[ERC7820] 複数コントラクトの権限を一括管理するACRの仕組みを理解しよう！

pragma solidity 0.8.23;
interface IAccessControlRegistry {
    event ContractRegistered(address indexed _contract, address indexed _admin);
    event ContractUnregistered(address indexed _contract, address indexed _admin);
    event RoleGranted(address indexed targetContract, bytes32 indexed role, address indexed account);
    event RoleRevoked(address indexed targetContract, bytes32 indexed role, address indexed account);

    function registerContract(address _admin) external;
    function unRegisterContract(address _contract) external;

    function grantRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) external;

    function revokeRole(
        address[] memory targetContracts,
        bytes32[] memory roles,
        address[] memory accounts
    ) external;

    function getContractInfo(
        address _contract
    ) external view returns (bool isActive, address admin);

    function getRoleInfo(
        address _contract
    ) external view returns (bool isActive, address admin);
}

event ContractRegistered(address indexed _contract, address indexed _admin);

event ContractUnregistered(address indexed _contract, address indexed _admin);

event RoleGranted(
    address indexed targetContract,
    bytes32 indexed role,
    address indexed account
);

event RoleRevoked(
    address indexed targetContract,
    bytes32 indexed role,
    address indexed account
);

function registerContract(address _admin) external;

function unRegisterContract(address _contract) external;

function grantRole(
    address[] memory targetContracts,
    bytes32[] memory roles,
    address[] memory accounts
) external;

function revokeRole(
    address[] memory targetContracts,
    bytes32[] memory roles,
    address[] memory accounts
) external;

function getContractInfo(
    address _contract
) external view returns (bool isActive, address admin);

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;
    }
}

pragma solidity 0.8.23;

import "./IAccessControlRegistry.sol";

contract AccessControlRegistry is IAccessControlRegistry {
    struct ContractInfo {
        bool isActive;
        address admin;
    }

    mapping(address => ContractInfo) public contracts;
    mapping(address => mapping(address => mapping(bytes32 => bool))) public _contractRoles;

    error ContractAlreadyRegistered();

    modifier onlyAdminOrContract(address _contract) { ... }
    modifier onlyAdmin(address _contract) { ... }
    modifier onlyActiveContract(address _contract) { ... }
    modifier validAddress(address addr) { ... }

    function registerContract(address _admin) external validAddress(_admin) { ... }
    function unRegisterContract(address _contract) public onlyAdmin(_contract) onlyActiveContract(_contract) { ... }

    function grantRole(address[] memory targetContracts, bytes32[] memory roles, address[] memory accounts) public { ... }
    function revokeRole(address[] memory targetContracts, bytes32[] memory roles, address[] memory accounts) public { ... }

    function getContractInfo(address _contract) public view returns (bool isActive, address admin) { ... }
    function getRoleInfo(address targetContract, address account, bytes32 role) public view returns (bool) { ... }

    function _grantRole(address targetContract, bytes32 role, address account) internal onlyAdminOrContract(targetContract) onlyActiveContract(targetContract) validAddress(account) { ... }
    function _revokeRole(address targetContract, bytes32 role, address account) internal onlyAdminOrContract(targetContract) onlyActiveContract(targetContract) validAddress(account) { ... }

    function _isAdmin(address _contract, address _admin) internal view returns (bool) { ... }
}

struct ContractInfo {
    bool isActive;
    address admin;
}

error ContractAlreadyRegistered();

modifier onlyAdminOrContract(address _contract) {
    require(
        _isAdmin(_contract, msg.sender) || 
        (contracts[msg.sender].isActive && msg.sender == _contract),
        "Caller is not admin nor contract"
    );
    _;
}

modifier onlyAdmin(address _contract) {
    require(_isAdmin(_contract, msg.sender), "Caller is not an admin");
    _;
}

modifier onlyActiveContract(address _contract) {
    require(contracts[_contract].isActive, "Contract not registered");
    _;
}

modifier validAddress(address addr) {
    require(addr != address(0), "Invalid address");
    _;
}

function registerContract(address _admin) external validAddress(_admin)

function unRegisterContract(address _contract) 
    public 
    onlyAdmin(_contract) 
    onlyActiveContract(_contract)

function grantRole(
    address[] memory targetContracts,
    bytes32[] memory roles,
    address[] memory accounts
) public

function revokeRole(
    address[] memory targetContracts,
    bytes32[] memory roles,
    address[] memory accounts
) public

function getContractInfo(address _contract)
    public
    view
    returns (bool isActive, address admin)

function getRoleInfo(address targetContract, address account, bytes32 role)
    public
    view
    returns (bool)

function _grantRole(address targetContract, bytes32 role, address account)
    internal
    onlyAdminOrContract(targetContract)
    onlyActiveContract(targetContract)
    validAddress(account)

function _revokeRole(address targetContract, bytes32 role, address account)
    internal
    onlyAdminOrContract(targetContract)
    onlyActiveContract(targetContract)
    validAddress(account)

function _isAdmin(address _contract, address _admin) internal view returns (bool)