Access control with OpenZeppelin in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this contract call?

Consider the following Solidity contract using OpenZeppelin's AccessControl. What will be the result of calling checkRoleForUser() for address 0x123...?

Blockchain / Solidity

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract RoleTest is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");

    constructor() {
        _setupRole(ADMIN_ROLE, msg.sender);
    }

    function checkRoleForUser(address user) public view returns (bool) {
        return hasRole(ADMIN_ROLE, user);
    }
}

A true if user is deployer, false otherwise

B compilation error due to missing constructor visibility

C false for any address

D true for any address

💡 Hint

Remember who is assigned the ADMIN_ROLE in the constructor.

The constructor assigns ADMIN_ROLE only to the deployer (msg.sender). So only that address has the role. Others return false.

❓ Predict Output

intermediate

What error occurs when calling a restricted function without role?

Given this contract snippet, what error message or behavior occurs when an address without the MINTER_ROLE calls mint()?

Blockchain / Solidity

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract Token is AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) public {
        require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
        // mint logic here
    }
}

A Compilation error due to missing override

B Transaction succeeds but does nothing

C Transaction reverts with "AccessControl: account is missing role"

D Transaction reverts with "Caller is not a minter"

💡 Hint

Look at the require statement inside mint().

The mint() function uses a require to check the MINTER_ROLE and reverts with the custom message "Caller is not a minter" if the caller lacks the role.

🔧 Debug

advanced

Why does this contract fail to grant role?

This contract tries to grant EDITOR_ROLE but fails silently. Identify the bug.

Blockchain / Solidity

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract EditorControl is AccessControl {
    bytes32 public constant EDITOR_ROLE = keccak256("EDITOR_ROLE");

    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function addEditor(address user) public {
        grantRole(EDITOR_ROLE, user);
    }
}

A Caller lacks DEFAULT_ADMIN_ROLE, so grantRole reverts

B Missing override for grantRole function

C EDITOR_ROLE is not initialized properly

D addEditor function should be external, not public

💡 Hint

Who can call grantRole successfully?

Only accounts with the admin role for a role can call grantRole. If the caller does not have DEFAULT_ADMIN_ROLE, the call reverts.

📝 Syntax

advanced

Which option fixes the syntax error in this role assignment?

Fix the syntax error in this role assignment snippet:

_setupRole(EDITOR_ROLE user);

A _setupRole(EDITOR_ROLE: user);

B _setupRole(EDITOR_ROLE, user);

C _setupRole(EDITOR_ROLE => user);

D _setupRole(EDITOR_ROLE user);

💡 Hint

Check the correct syntax for function arguments in Solidity.

Function arguments must be separated by commas. The correct syntax is _setupRole(EDITOR_ROLE, user);

🚀 Application

expert

How many roles does this contract have after deployment?

Analyze this contract and determine how many distinct roles exist after deployment.

Blockchain / Solidity

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract MultiRole is AccessControl {
    bytes32 public constant ROLE_A = keccak256("ROLE_A");
    bytes32 public constant ROLE_B = keccak256("ROLE_B");

    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(ROLE_A, msg.sender);
    }

    function assignRoleB(address user) public {
        grantRole(ROLE_B, user);
    }
}

A 1 role: DEFAULT_ADMIN_ROLE only

B 2 roles: DEFAULT_ADMIN_ROLE, ROLE_A

C 3 roles: DEFAULT_ADMIN_ROLE, ROLE_A, ROLE_B

D 4 roles: DEFAULT_ADMIN_ROLE, ROLE_A, ROLE_B, and a hidden role

💡 Hint

Consider all roles declared and used in the contract.

The contract defines ROLE_A and ROLE_B explicitly and uses DEFAULT_ADMIN_ROLE from AccessControl. So there are three distinct roles.