Alert Source Discuss
⚠️ Draft Standards Track: ERC

ERC-6617: Bit Based Permission

A permission and role system based on bits

Authors Chiro (@chiro-hiro), Victor Dusart (@vdusart)
Created 2023-02-27
Discussion Link


This EIP offers a standard for building a bit-based permission and role system. Each permission is represented by a single bit. By using an uint256, up to $256$ permissions and $2^{256}$ roles can be defined. We are able to specify the importance of each permission based on the order of the bits.


The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “NOT RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119 and RFC 8174.

Note The following specifications use syntax from Solidity 0.8.7 (or above)

  • Permission and role MUST be defined as an uint256
  • Permission MUST be defined as a power of two
  • Permission MUST be unique
  • 0 MUST be used for none permission


Currently permission and access control is performed using a single owner (ERC-173) or with bytes32 roles (ERC-5982). However, using bitwise and bitmask operations allows for greater gas-efficiency and flexibility.

Gas cost efficiency

Bitwise operations are very cheap and fast. For example, doing an AND bitwise operation on a permission bitmask is significantly cheaper than calling any number of LOAD opcodes.


With the 256 bits of the uint256, we can create up to 256 different permissions which leads to $2^{256}$ unique combinations (a.k.a. roles). (A role is a combination of multiple permissions). Not all roles have to be predefined.

Since permissions are defined as unsigned integers, we can use the binary OR operator to create new role based on multiple permissions.

Ordering permissions by importance

We can use the most significant bit to represent the most important permission, the comparison between permissions can then be done easily since they all are uint256s.

Test Cases

pragma solidity ^0.8.7;

import "EIP6617.sol";

contract Test {
    using EIP6617 for uint256;

    uint256 public constant PERMISSION_NONE = 0;
    uint256 public constant PERMISSION_READ = 1;     // 2⁰
    uint256 public constant PERMISSION_WRITE = 2;    // 2¹
    uint256 public constant PERMISSION_EXECUTE = 4;  // 2²

    // Role operator = 1 | 2 = 3

    // Role admin = 1 | 2 | 4 = 7

    function testPermissions() external pure returns (uint256) {
        uint256 userPermission;

        // adding read permission
        userPermission = userPermission.permissionGrant(PERMISSION_READ);
        // adding admin role
        userPermission = userPermission.permissionGrant(ROLE_ADMIN);

        // removing execute permission
    	userPermission = userPermission.permissionRevoke(PERMISSION_EXECUTE);
        // Checking permission
        if (userPermission.permissionCheck(ROLE_ADMIN)) {
            // Only admin can access this part

        return userPermission;

Reference Implementation

pragma solidity ^0.8.7;

    @title EIP-6617 Bit Based Permission
    @dev See
library EIP6617 {
        @notice Check if _permission is a superset of _requiredPermission
        @param _permission          The given permission
        @param _requiredPermission  The required permission
        @return                     True if the _permission is a superset of the _requiredPermission else False
    function permissionCheck(uint256 _permission, uint256 _requiredPermission)
        returns (bool)
        return _permission & _requiredPermission == _requiredPermission;

        @notice Add permission
        @param _permission          The given permission
        @param _permissionToAdd     The permission that will be added
        @return                     The new permission with the _permissionToAdd
    function permissionGrant(uint256 _permission, uint256 _permissionToAdd)
        returns (uint256)
        return _permission | _permissionToAdd;

        @notice Remove permission
        @param _permission          The given permission
        @param _permissionToRemove  The permission that will be removed
        @return                     The new permission without the _permissionToRemove
    function permissionRevoke(uint256 _permission, uint256 _permissionToRemove)
        returns (uint256)
        return (_permission | _permissionToRemove) ^ _permissionToRemove;

Security Considerations

Need more discussion.

Copyright and related rights waived via CC0.


Please cite this document as:

Chiro (@chiro-hiro), Victor Dusart (@vdusart), "ERC-6617: Bit Based Permission [DRAFT]," Ethereum Improvement Proposals, no. 6617, February 2023. [Online serial]. Available: