@lazy-sol/access-control 1.0.5 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +38 -0
- package/README.md +77 -0
- package/Role-based Access Control (RBAC) Lifecycle.png +0 -0
- package/artifacts/contracts/OwnableToAccessControlAdapter.sol/OwnableToAccessControlAdapter.json +7 -64
- package/contracts/AccessControl.sol +15 -219
- package/contracts/AccessControlCore.sol +353 -0
- package/contracts/AdapterFactory.sol +1 -1
- package/contracts/OwnableToAccessControlAdapter.sol +7 -5
- package/contracts/mocks/AccessControlMock.sol +7 -1
- package/hardhat.config.js +38 -9
- package/index.js +4 -0
- package/package.json +10 -6
- package/test/include/rbac.behaviour.js +22 -7
- package/test/ownable_to_rbac_adapter.js +1 -1
- package/test/ownable_to_rbac_adapter_rbac.js +3 -3
- package/test/rbac_modifier.js +1 -1
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
v1.1.0: Contact Size Optimizations
|
|
2
|
+
|
|
3
|
+
- __Breaking Change:__ Solidity 0.8.4 is now required to compile the contracts
|
|
4
|
+
(previously was 0.4.22 for the core contract and 0.6.2 for periphery contracts).
|
|
5
|
+
- Replaced "access denied" error with string literal (0.4.22) with the custom error AccessDenied() (0.8.4)
|
|
6
|
+
- Introduced lighter modification of the "AccessControl" RBAC contract – "AccessControlCore" (RBAC-C).
|
|
7
|
+
The 'core' version of the RBAC contract hides three rarely used external functions from the public ABI,
|
|
8
|
+
making them internal and thus reducing the overall compiled implementation size.
|
|
9
|
+
|
|
10
|
+
| old name | old modifier | new name | new modifier |
|
|
11
|
+
|----------------------|--------------|-----------------------|--------------|
|
|
12
|
+
| `isFeatureEnabled()` | `public` | `isFeatureEnabled()` | `internal` |
|
|
13
|
+
| `isSenderInRole()` | `public` | `_isSenderInRole()` | `internal` |
|
|
14
|
+
| `isOperatorInRole()` | `public` | `_isOperatorInRole()` | `internal` |
|
|
15
|
+
|
|
16
|
+
- Added `_requireSenderInRole()` and `_requireAccessCondition()` internal functions for a convenient and gas-efficient
|
|
17
|
+
way of checking the access permissions and throwing the AccessDenied() error.
|
|
18
|
+
- Added the CHANGELOG (this file)
|
|
19
|
+
|
|
20
|
+
v1.0.7:
|
|
21
|
+
- Exported the RBAC behavior
|
|
22
|
+
|
|
23
|
+
v1.0.6:
|
|
24
|
+
- Updated the documentation
|
|
25
|
+
|
|
26
|
+
v1.0.5:
|
|
27
|
+
- Exported RBAC JavaScript constants and functions
|
|
28
|
+
|
|
29
|
+
v1.0.4:
|
|
30
|
+
- Fixed broken dependencies
|
|
31
|
+
- Upgraded npm libraries
|
|
32
|
+
- Added Sepolia network support
|
|
33
|
+
|
|
34
|
+
v1.0.3:
|
|
35
|
+
- Allowed lower versions of Hardhat to be used
|
|
36
|
+
|
|
37
|
+
v1.0.2:
|
|
38
|
+
- Optimized npm dependencies
|
package/README.md
CHANGED
|
@@ -4,6 +4,83 @@ A shortcut to a modular and easily pluggable dapp architecture.
|
|
|
4
4
|
Enable the modular plug and play (PnP) architecture for your dapp by incorporating the role-based access control (RBAC)
|
|
5
5
|
into the smart contracts.
|
|
6
6
|
|
|
7
|
+
## Technical Overview
|
|
8
|
+
|
|
9
|
+
Role-based Access Control (RBAC), or simply Access Control, is the base parent contract to be inherited by other smart
|
|
10
|
+
contracts wishing to enable the RBAC feature. It provides an API to check if a specific operation is permitted globally
|
|
11
|
+
and/or if a particular user has a permission to execute it.
|
|
12
|
+
|
|
13
|
+
It deals with two main entities: features and roles. Features are designed to be used to enable/disable public functions
|
|
14
|
+
of the smart contract (used by a wide audience). User roles are designed to control the access to restricted functions
|
|
15
|
+
of the smart contract (used by a limited set of maintainers).
|
|
16
|
+
|
|
17
|
+
When designing the RBAC-enabled contract, the best practice is to make all public mutative functions controlled with
|
|
18
|
+
their corresponding feature flags, which can be enabled/disabled during smart contact deployment, setup process, and,
|
|
19
|
+
optionally, during contract operation.
|
|
20
|
+
|
|
21
|
+
Restricted access functions must be controlled by their corresponding user roles/permissions and usually can be executed
|
|
22
|
+
by the deployer during smart contract deployment and setup process.
|
|
23
|
+
|
|
24
|
+
After deployment is complete and smart contract setup is verified the deployer should enable the feature flags and
|
|
25
|
+
revoke own permissions to control these flags, as well as permissions to execute restricted access functions.
|
|
26
|
+
|
|
27
|
+
It is possible that smart contract functionalities are enabled in phases, but the intention is that eventually it is
|
|
28
|
+
also possible to set the smart contract to be uncontrolled by anyone and be fully decentralized.
|
|
29
|
+
|
|
30
|
+
It is also possible that the deployer shares its admin permissions with other addresses during the deployment and setup
|
|
31
|
+
process, but eventually all these permissions can be revoked from all the addresses involved.
|
|
32
|
+
|
|
33
|
+
Following diagram summarizes stated below:
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
Diagram 1. RBAC-enabled smart contract deployment and setup phases. Contract evolves from the fully controlled in the
|
|
37
|
+
initial phases of the setup process to the fully decentralized and uncontrolled in the end.
|
|
38
|
+
|
|
39
|
+
It is important to note that it is not necessary, and not recommended to wait until the last “Setup Complete” phase is
|
|
40
|
+
executed to consider the protocol fully operational in the mainnet. In fact, the best practice is to do the launch after
|
|
41
|
+
the deployer permissions are revoked, but there are admin multisig accounts with the full permissions to control the
|
|
42
|
+
protocol. This kind of approach allows reacting to the security issues, which are more likely to happen in the beginning
|
|
43
|
+
of the protocol operation.
|
|
44
|
+
|
|
45
|
+
## Special Permissions Mapping
|
|
46
|
+
|
|
47
|
+
Special permissions mapping, `userRoles`, stores special permissions of the smart contract administrators and helpers.
|
|
48
|
+
The mapping is a part of AccessControl and is inherited by the smart contracts using it.
|
|
49
|
+
|
|
50
|
+
The value stored in the mapping is a 256 bits unsigned integer, each bit of that integer represents a particular
|
|
51
|
+
permission. We call a set of permissions a role. Usually, roles are defined as 32 bits unsigned integer constants, but
|
|
52
|
+
extension to 255 bits is possible.
|
|
53
|
+
|
|
54
|
+
Permission with the bit 255 set is a special one. It corresponds to the access manager role `ROLE_ACCESS_MANAGER`
|
|
55
|
+
defined on the Access Control smart contract and allows accounts having that bit set to grant/revoke their permissions
|
|
56
|
+
to other addresses and to enable/disable corresponding features of the smart contract (to update self address “this”
|
|
57
|
+
role – see below).
|
|
58
|
+
|
|
59
|
+
Self address “this” mapping is a special one. It represents the deployed smart contract itself and defines features
|
|
60
|
+
enabled on it. Features control what public functions are enabled and how they behave. Usually, features are defined as
|
|
61
|
+
32 bits unsigned integer constants, but extension to 255 bits is possible.
|
|
62
|
+
|
|
63
|
+
Access Control is a shared parent for other smart contracts which are free to use any strategy to introduce their
|
|
64
|
+
features and roles. Usually, smart contracts use different values for all the features and roles (see the table in the
|
|
65
|
+
next section).
|
|
66
|
+
|
|
67
|
+
Access manager may revoke its own permissions, including the bit 255. Eventually that allows an access manager to let
|
|
68
|
+
the smart contract “float freely” and be controlled only by the community (via DAO) or by no one at all.
|
|
69
|
+
|
|
70
|
+
## Comparing with OpenZeppelin
|
|
71
|
+
|
|
72
|
+
Both our and OpenZeppelin Access Control implementations feature a similar API to check/know "who is allowed to do this
|
|
73
|
+
thing".
|
|
74
|
+
|
|
75
|
+
Zeppelin implementation is more flexible:
|
|
76
|
+
* it allows setting unlimited number of roles, while current is limited to 256 different roles
|
|
77
|
+
* it allows setting an admin for each role, while current allows having only one global admin
|
|
78
|
+
|
|
79
|
+
Our implementation is more lightweight:
|
|
80
|
+
* it uses only 1 bit per role, while Zeppelin uses 256 bits
|
|
81
|
+
* it allows setting up to 256 roles at once, in a single transaction, while Zeppelin allows setting only one role in a
|
|
82
|
+
single transaction
|
|
83
|
+
|
|
7
84
|
## Installation
|
|
8
85
|
```
|
|
9
86
|
npm i -D @lazy-sol/access-control
|
|
Binary file
|
package/artifacts/contracts/OwnableToAccessControlAdapter.sol/OwnableToAccessControlAdapter.json
CHANGED
|
@@ -19,6 +19,11 @@
|
|
|
19
19
|
"stateMutability": "nonpayable",
|
|
20
20
|
"type": "constructor"
|
|
21
21
|
},
|
|
22
|
+
{
|
|
23
|
+
"inputs": [],
|
|
24
|
+
"name": "AccessDenied",
|
|
25
|
+
"type": "error"
|
|
26
|
+
},
|
|
22
27
|
{
|
|
23
28
|
"anonymous": false,
|
|
24
29
|
"inputs": [
|
|
@@ -188,68 +193,6 @@
|
|
|
188
193
|
"stateMutability": "view",
|
|
189
194
|
"type": "function"
|
|
190
195
|
},
|
|
191
|
-
{
|
|
192
|
-
"inputs": [
|
|
193
|
-
{
|
|
194
|
-
"internalType": "uint256",
|
|
195
|
-
"name": "required",
|
|
196
|
-
"type": "uint256"
|
|
197
|
-
}
|
|
198
|
-
],
|
|
199
|
-
"name": "isFeatureEnabled",
|
|
200
|
-
"outputs": [
|
|
201
|
-
{
|
|
202
|
-
"internalType": "bool",
|
|
203
|
-
"name": "",
|
|
204
|
-
"type": "bool"
|
|
205
|
-
}
|
|
206
|
-
],
|
|
207
|
-
"stateMutability": "view",
|
|
208
|
-
"type": "function"
|
|
209
|
-
},
|
|
210
|
-
{
|
|
211
|
-
"inputs": [
|
|
212
|
-
{
|
|
213
|
-
"internalType": "address",
|
|
214
|
-
"name": "operator",
|
|
215
|
-
"type": "address"
|
|
216
|
-
},
|
|
217
|
-
{
|
|
218
|
-
"internalType": "uint256",
|
|
219
|
-
"name": "required",
|
|
220
|
-
"type": "uint256"
|
|
221
|
-
}
|
|
222
|
-
],
|
|
223
|
-
"name": "isOperatorInRole",
|
|
224
|
-
"outputs": [
|
|
225
|
-
{
|
|
226
|
-
"internalType": "bool",
|
|
227
|
-
"name": "",
|
|
228
|
-
"type": "bool"
|
|
229
|
-
}
|
|
230
|
-
],
|
|
231
|
-
"stateMutability": "view",
|
|
232
|
-
"type": "function"
|
|
233
|
-
},
|
|
234
|
-
{
|
|
235
|
-
"inputs": [
|
|
236
|
-
{
|
|
237
|
-
"internalType": "uint256",
|
|
238
|
-
"name": "required",
|
|
239
|
-
"type": "uint256"
|
|
240
|
-
}
|
|
241
|
-
],
|
|
242
|
-
"name": "isSenderInRole",
|
|
243
|
-
"outputs": [
|
|
244
|
-
{
|
|
245
|
-
"internalType": "bool",
|
|
246
|
-
"name": "",
|
|
247
|
-
"type": "bool"
|
|
248
|
-
}
|
|
249
|
-
],
|
|
250
|
-
"stateMutability": "view",
|
|
251
|
-
"type": "function"
|
|
252
|
-
},
|
|
253
196
|
{
|
|
254
197
|
"inputs": [],
|
|
255
198
|
"name": "target",
|
|
@@ -335,8 +278,8 @@
|
|
|
335
278
|
"type": "receive"
|
|
336
279
|
}
|
|
337
280
|
],
|
|
338
|
-
"bytecode": "
|
|
339
|
-
"deployedBytecode": "
|
|
281
|
+
"bytecode": "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",
|
|
282
|
+
"deployedBytecode": "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",
|
|
340
283
|
"linkReferences": {},
|
|
341
284
|
"deployedLinkReferences": {}
|
|
342
285
|
}
|
|
@@ -1,5 +1,11 @@
|
|
|
1
1
|
// SPDX-License-Identifier: MIT
|
|
2
|
-
|
|
2
|
+
// custom errors (0.8.4)
|
|
3
|
+
// require with message (0.4.22)
|
|
4
|
+
// pure/view modifiers (0.4.16)
|
|
5
|
+
// hardhat (0.4.11)
|
|
6
|
+
pragma solidity >=0.8.4;
|
|
7
|
+
|
|
8
|
+
import {AccessControlCore} from "./AccessControlCore.sol";
|
|
3
9
|
|
|
4
10
|
/**
|
|
5
11
|
* @title Role-based Access Control (RBAC)
|
|
@@ -50,189 +56,14 @@ pragma solidity >=0.4.22; // require with message (0.4.22), pure/view modifiers
|
|
|
50
56
|
*
|
|
51
57
|
* @author Basil Gorin
|
|
52
58
|
*/
|
|
53
|
-
|
|
54
|
-
/**
|
|
55
|
-
* @dev Privileged addresses with defined roles/permissions
|
|
56
|
-
* @dev In the context of ERC20/ERC721 tokens these can be permissions to
|
|
57
|
-
* allow minting or burning tokens, transferring on behalf and so on
|
|
58
|
-
*
|
|
59
|
-
* @dev Maps user address to the permissions bitmask (role), where each bit
|
|
60
|
-
* represents a permission
|
|
61
|
-
* @dev Bitmask 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
|
|
62
|
-
* represents all possible permissions
|
|
63
|
-
* @dev 'This' address mapping represents global features of the smart contract
|
|
64
|
-
*
|
|
65
|
-
* @dev We keep the mapping private to prevent direct writes to it from the inheriting
|
|
66
|
-
* contracts, `getRole()` and `updateRole()` functions should be used instead
|
|
67
|
-
*/
|
|
68
|
-
mapping(address => uint256) private userRoles;
|
|
69
|
-
|
|
70
|
-
/**
|
|
71
|
-
* @notice Access manager is responsible for assigning the roles to users,
|
|
72
|
-
* enabling/disabling global features of the smart contract
|
|
73
|
-
* @notice Access manager can add, remove and update user roles,
|
|
74
|
-
* remove and update global features
|
|
75
|
-
*
|
|
76
|
-
* @dev Role ROLE_ACCESS_MANAGER allows modifying user roles and global features
|
|
77
|
-
* @dev Role ROLE_ACCESS_MANAGER has single bit at position 255 enabled
|
|
78
|
-
*/
|
|
79
|
-
uint256 public constant ROLE_ACCESS_MANAGER = 0x8000000000000000000000000000000000000000000000000000000000000000;
|
|
80
|
-
|
|
81
|
-
/**
|
|
82
|
-
* @dev Bitmask representing all the possible permissions (super admin role)
|
|
83
|
-
* @dev Has all the bits are enabled (2^256 - 1 value)
|
|
84
|
-
*/
|
|
85
|
-
uint256 internal constant FULL_PRIVILEGES_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
|
|
86
|
-
|
|
87
|
-
/**
|
|
88
|
-
* @dev Fired in updateRole() and updateFeatures()
|
|
89
|
-
*
|
|
90
|
-
* @param operator address which was granted/revoked permissions
|
|
91
|
-
* @param requested permissions requested
|
|
92
|
-
* @param assigned permissions effectively set
|
|
93
|
-
*/
|
|
94
|
-
event RoleUpdated(address indexed operator, uint256 requested, uint256 assigned);
|
|
95
|
-
|
|
96
|
-
/**
|
|
97
|
-
* @notice Function modifier making a function defined as public behave as restricted
|
|
98
|
-
* (so that only a pre-configured set of accounts can execute it)
|
|
99
|
-
*
|
|
100
|
-
* @param role the role transaction executor is required to have;
|
|
101
|
-
* the function throws an "access denied" exception if this condition is not met
|
|
102
|
-
*/
|
|
103
|
-
modifier restrictedTo(uint256 role) {
|
|
104
|
-
// verify the access permission
|
|
105
|
-
require(isSenderInRole(role), "access denied");
|
|
106
|
-
|
|
107
|
-
// execute the rest of the function
|
|
108
|
-
_;
|
|
109
|
-
}
|
|
110
|
-
|
|
59
|
+
contract AccessControl is AccessControlCore {
|
|
111
60
|
/**
|
|
112
61
|
* @notice Creates an access control instance, setting the contract owner to have full privileges
|
|
113
62
|
*
|
|
114
63
|
* @param _owner smart contract owner having full privileges, can be zero
|
|
115
64
|
* @param _features initial features mask of the contract, can be zero
|
|
116
65
|
*/
|
|
117
|
-
constructor(address _owner, uint256 _features)
|
|
118
|
-
// grant owner full privileges
|
|
119
|
-
__setRole(_owner, FULL_PRIVILEGES_MASK, FULL_PRIVILEGES_MASK);
|
|
120
|
-
// update initial features bitmask
|
|
121
|
-
__setRole(address(this), _features, _features);
|
|
122
|
-
}
|
|
123
|
-
|
|
124
|
-
/**
|
|
125
|
-
* @notice Retrieves globally set of features enabled
|
|
126
|
-
*
|
|
127
|
-
* @dev Effectively reads userRoles role for the contract itself
|
|
128
|
-
*
|
|
129
|
-
* @return 256-bit bitmask of the features enabled
|
|
130
|
-
*/
|
|
131
|
-
function features() public view returns (uint256) {
|
|
132
|
-
// features are stored in 'this' address mapping of `userRoles`
|
|
133
|
-
return getRole(address(this));
|
|
134
|
-
}
|
|
135
|
-
|
|
136
|
-
/**
|
|
137
|
-
* @notice Updates set of the globally enabled features (`features`),
|
|
138
|
-
* taking into account sender's permissions
|
|
139
|
-
*
|
|
140
|
-
* @dev Requires transaction sender to have `ROLE_ACCESS_MANAGER` permission
|
|
141
|
-
* @dev Function is left for backward compatibility with older versions
|
|
142
|
-
*
|
|
143
|
-
* @param _mask bitmask representing a set of features to enable/disable
|
|
144
|
-
*/
|
|
145
|
-
function updateFeatures(uint256 _mask) public {
|
|
146
|
-
// delegate call to `updateRole`
|
|
147
|
-
updateRole(address(this), _mask);
|
|
148
|
-
}
|
|
149
|
-
|
|
150
|
-
/**
|
|
151
|
-
* @notice Reads the permissions (role) for a given user from the `userRoles` mapping
|
|
152
|
-
* (privileged addresses with defined roles/permissions)
|
|
153
|
-
* @notice In the context of ERC20/ERC721 tokens these can be permissions to
|
|
154
|
-
* allow minting or burning tokens, transferring on behalf and so on
|
|
155
|
-
*
|
|
156
|
-
* @dev Having a simple getter instead of making the mapping public
|
|
157
|
-
* allows enforcing the encapsulation of the mapping and protects from
|
|
158
|
-
* writing to it directly in the inheriting smart contracts
|
|
159
|
-
*
|
|
160
|
-
* @param operator address of a user to read permissions for,
|
|
161
|
-
* or self address to read global features of the smart contract
|
|
162
|
-
*/
|
|
163
|
-
function getRole(address operator) public view returns(uint256) {
|
|
164
|
-
// read the value from `userRoles` and return
|
|
165
|
-
return userRoles[operator];
|
|
166
|
-
}
|
|
167
|
-
|
|
168
|
-
/**
|
|
169
|
-
* @notice Updates set of permissions (role) for a given user,
|
|
170
|
-
* taking into account sender's permissions.
|
|
171
|
-
*
|
|
172
|
-
* @dev Setting role to zero is equivalent to removing an all permissions
|
|
173
|
-
* @dev Setting role to `FULL_PRIVILEGES_MASK` is equivalent to
|
|
174
|
-
* copying senders' permissions (role) to the user
|
|
175
|
-
* @dev Requires transaction sender to have `ROLE_ACCESS_MANAGER` permission
|
|
176
|
-
*
|
|
177
|
-
* @param operator address of a user to alter permissions for,
|
|
178
|
-
* or self address to alter global features of the smart contract
|
|
179
|
-
* @param role bitmask representing a set of permissions to
|
|
180
|
-
* enable/disable for a user specified
|
|
181
|
-
*/
|
|
182
|
-
function updateRole(address operator, uint256 role) public {
|
|
183
|
-
// caller must have a permission to update user roles
|
|
184
|
-
require(isSenderInRole(ROLE_ACCESS_MANAGER), "access denied");
|
|
185
|
-
|
|
186
|
-
// evaluate the role and reassign it
|
|
187
|
-
__setRole(operator, role, _evaluateBy(msg.sender, getRole(operator), role));
|
|
188
|
-
}
|
|
189
|
-
|
|
190
|
-
/**
|
|
191
|
-
* @notice Determines the permission bitmask an operator can set on the
|
|
192
|
-
* target permission set
|
|
193
|
-
* @notice Used to calculate the permission bitmask to be set when requested
|
|
194
|
-
* in `updateRole` and `updateFeatures` functions
|
|
195
|
-
*
|
|
196
|
-
* @dev Calculated based on:
|
|
197
|
-
* 1) operator's own permission set read from userRoles[operator]
|
|
198
|
-
* 2) target permission set - what is already set on the target
|
|
199
|
-
* 3) desired permission set - what do we want set target to
|
|
200
|
-
*
|
|
201
|
-
* @dev Corner cases:
|
|
202
|
-
* 1) Operator is super admin and its permission set is `FULL_PRIVILEGES_MASK`:
|
|
203
|
-
* `desired` bitset is returned regardless of the `target` permission set value
|
|
204
|
-
* (what operator sets is what they get)
|
|
205
|
-
* 2) Operator with no permissions (zero bitset):
|
|
206
|
-
* `target` bitset is returned regardless of the `desired` value
|
|
207
|
-
* (operator has no authority and cannot modify anything)
|
|
208
|
-
*
|
|
209
|
-
* @dev Example:
|
|
210
|
-
* Consider an operator with the permissions bitmask 00001111
|
|
211
|
-
* is about to modify the target permission set 01010101
|
|
212
|
-
* Operator wants to set that permission set to 00110011
|
|
213
|
-
* Based on their role, an operator has the permissions
|
|
214
|
-
* to update only lowest 4 bits on the target, meaning that
|
|
215
|
-
* high 4 bits of the target set in this example is left
|
|
216
|
-
* unchanged and low 4 bits get changed as desired: 01010011
|
|
217
|
-
*
|
|
218
|
-
* @param operator address of the contract operator which is about to set the permissions
|
|
219
|
-
* @param target input set of permissions to operator is going to modify
|
|
220
|
-
* @param desired desired set of permissions operator would like to set
|
|
221
|
-
* @return resulting set of permissions given operator will set
|
|
222
|
-
*/
|
|
223
|
-
function _evaluateBy(address operator, uint256 target, uint256 desired) internal view returns (uint256) {
|
|
224
|
-
// read operator's permissions
|
|
225
|
-
uint256 p = getRole(operator);
|
|
226
|
-
|
|
227
|
-
// taking into account operator's permissions,
|
|
228
|
-
// 1) enable the permissions desired on the `target`
|
|
229
|
-
target |= p & desired;
|
|
230
|
-
// 2) disable the permissions desired on the `target`
|
|
231
|
-
target &= FULL_PRIVILEGES_MASK ^ (p & (FULL_PRIVILEGES_MASK ^ desired));
|
|
232
|
-
|
|
233
|
-
// return calculated result
|
|
234
|
-
return target;
|
|
235
|
-
}
|
|
66
|
+
constructor(address _owner, uint256 _features) AccessControlCore(_owner, _features) {} // visibility modifier is required to be compilable with 0.6.x
|
|
236
67
|
|
|
237
68
|
/**
|
|
238
69
|
* @notice Checks if requested set of features is enabled globally on the contract
|
|
@@ -241,8 +72,8 @@ abstract contract AccessControl {
|
|
|
241
72
|
* @return true if all the features requested are enabled, false otherwise
|
|
242
73
|
*/
|
|
243
74
|
function isFeatureEnabled(uint256 required) public view returns (bool) {
|
|
244
|
-
// delegate
|
|
245
|
-
return
|
|
75
|
+
// delegate to internal `_isFeatureEnabled`
|
|
76
|
+
return _isFeatureEnabled(required);
|
|
246
77
|
}
|
|
247
78
|
|
|
248
79
|
/**
|
|
@@ -252,8 +83,8 @@ abstract contract AccessControl {
|
|
|
252
83
|
* @return true if all the permissions requested are enabled, false otherwise
|
|
253
84
|
*/
|
|
254
85
|
function isSenderInRole(uint256 required) public view returns (bool) {
|
|
255
|
-
// delegate
|
|
256
|
-
return
|
|
86
|
+
// delegate to internal `_isSenderInRole`
|
|
87
|
+
return _isSenderInRole(required);
|
|
257
88
|
}
|
|
258
89
|
|
|
259
90
|
/**
|
|
@@ -264,42 +95,7 @@ abstract contract AccessControl {
|
|
|
264
95
|
* @return true if all the permissions requested are enabled, false otherwise
|
|
265
96
|
*/
|
|
266
97
|
function isOperatorInRole(address operator, uint256 required) public view returns (bool) {
|
|
267
|
-
// delegate
|
|
268
|
-
return
|
|
269
|
-
}
|
|
270
|
-
|
|
271
|
-
/**
|
|
272
|
-
* @dev Sets the `assignedRole` role to the operator, logs both `requestedRole` and `actualRole`
|
|
273
|
-
*
|
|
274
|
-
* @dev Unsafe:
|
|
275
|
-
* provides direct write access to `userRoles` mapping without any security checks,
|
|
276
|
-
* doesn't verify the executor (msg.sender) permissions,
|
|
277
|
-
* must be kept private at all times
|
|
278
|
-
*
|
|
279
|
-
* @param operator address of a user to alter permissions for,
|
|
280
|
-
* or self address to alter global features of the smart contract
|
|
281
|
-
* @param requestedRole bitmask representing a set of permissions requested
|
|
282
|
-
* to be enabled/disabled for a user specified, used only to be logged into event
|
|
283
|
-
* @param assignedRole bitmask representing a set of permissions to
|
|
284
|
-
* enable/disable for a user specified, used to update the mapping and to be logged into event
|
|
285
|
-
*/
|
|
286
|
-
function __setRole(address operator, uint256 requestedRole, uint256 assignedRole) private {
|
|
287
|
-
// assign the role to the operator
|
|
288
|
-
userRoles[operator] = assignedRole;
|
|
289
|
-
|
|
290
|
-
// fire an event
|
|
291
|
-
emit RoleUpdated(operator, requestedRole, assignedRole);
|
|
292
|
-
}
|
|
293
|
-
|
|
294
|
-
/**
|
|
295
|
-
* @dev Checks if role `actual` contains all the permissions required `required`
|
|
296
|
-
*
|
|
297
|
-
* @param actual existent role
|
|
298
|
-
* @param required required role
|
|
299
|
-
* @return true if actual has required role (all permissions), false otherwise
|
|
300
|
-
*/
|
|
301
|
-
function __hasRole(uint256 actual, uint256 required) private pure returns (bool) {
|
|
302
|
-
// check the bitmask for the role required and return the result
|
|
303
|
-
return actual & required == required;
|
|
98
|
+
// delegate to internal `_isOperatorInRole`
|
|
99
|
+
return _isOperatorInRole(operator, required);
|
|
304
100
|
}
|
|
305
101
|
}
|
|
@@ -0,0 +1,353 @@
|
|
|
1
|
+
// SPDX-License-Identifier: MIT
|
|
2
|
+
// custom errors (0.8.4)
|
|
3
|
+
// require with message (0.4.22)
|
|
4
|
+
// pure/view modifiers (0.4.16)
|
|
5
|
+
// hardhat (0.4.11)
|
|
6
|
+
pragma solidity >=0.8.4;
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* @title Role-based Access Control Core (RBAC-C)
|
|
10
|
+
*
|
|
11
|
+
* @notice Access control smart contract provides an API to check
|
|
12
|
+
* if a specific operation is permitted globally and/or
|
|
13
|
+
* if a particular user has a permission to execute it.
|
|
14
|
+
*
|
|
15
|
+
* @notice This contract is inherited by other contracts requiring the role-based access control (RBAC)
|
|
16
|
+
* protection for the restricted access functions
|
|
17
|
+
*
|
|
18
|
+
* @notice It deals with two main entities: features and roles.
|
|
19
|
+
*
|
|
20
|
+
* @notice Features are designed to be used to enable/disable public functions
|
|
21
|
+
* of the smart contract (used by a wide audience).
|
|
22
|
+
* @notice User roles are designed to control the access to restricted functions
|
|
23
|
+
* of the smart contract (used by a limited set of maintainers).
|
|
24
|
+
*
|
|
25
|
+
* @notice Terms "role", "permissions" and "set of permissions" have equal meaning
|
|
26
|
+
* in the documentation text and may be used interchangeably.
|
|
27
|
+
* @notice Terms "permission", "single permission" implies only one permission bit set.
|
|
28
|
+
*
|
|
29
|
+
* @notice Access manager is a special role which allows to grant/revoke other roles.
|
|
30
|
+
* Access managers can only grant/revoke permissions which they have themselves.
|
|
31
|
+
* As an example, access manager with no other roles set can only grant/revoke its own
|
|
32
|
+
* access manager permission and nothing else.
|
|
33
|
+
*
|
|
34
|
+
* @notice Access manager permission should be treated carefully, as a super admin permission:
|
|
35
|
+
* Access manager with even no other permission can interfere with another account by
|
|
36
|
+
* granting own access manager permission to it and effectively creating more powerful
|
|
37
|
+
* permission set than its own.
|
|
38
|
+
*
|
|
39
|
+
* @dev Both current and OpenZeppelin AccessControl implementations feature a similar API
|
|
40
|
+
* to check/know "who is allowed to do this thing".
|
|
41
|
+
* @dev Zeppelin implementation is more flexible:
|
|
42
|
+
* - it allows setting unlimited number of roles, while current is limited to 256 different roles
|
|
43
|
+
* - it allows setting an admin for each role, while current allows having only one global admin
|
|
44
|
+
* @dev Current implementation is more lightweight:
|
|
45
|
+
* - it uses only 1 bit per role, while Zeppelin uses 256 bits
|
|
46
|
+
* - it allows setting up to 256 roles at once, in a single transaction, while Zeppelin allows
|
|
47
|
+
* setting only one role in a single transaction
|
|
48
|
+
*
|
|
49
|
+
* @dev This smart contract is designed to be inherited by other
|
|
50
|
+
* smart contracts which require access control management capabilities.
|
|
51
|
+
*
|
|
52
|
+
* @dev Access manager permission has a bit 255 set.
|
|
53
|
+
* This bit must not be used by inheriting contracts for any other permissions/features.
|
|
54
|
+
*
|
|
55
|
+
* @dev The 'core' version of the RBAC contract hides three rarely used external functions from the public ABI,
|
|
56
|
+
* making them internal and thus reducing the overall compiled implementation size.
|
|
57
|
+
* isFeatureEnabled() public -> _isFeatureEnabled() internal
|
|
58
|
+
* isSenderInRole() public -> _isSenderInRole() internal
|
|
59
|
+
* isOperatorInRole() public -> _isOperatorInRole() internal
|
|
60
|
+
*
|
|
61
|
+
* @custom:since 1.1.0
|
|
62
|
+
*
|
|
63
|
+
* @author Basil Gorin
|
|
64
|
+
*/
|
|
65
|
+
abstract contract AccessControlCore {
|
|
66
|
+
/**
|
|
67
|
+
* @dev Privileged addresses with defined roles/permissions
|
|
68
|
+
* @dev In the context of ERC20/ERC721 tokens these can be permissions to
|
|
69
|
+
* allow minting or burning tokens, transferring on behalf and so on
|
|
70
|
+
*
|
|
71
|
+
* @dev Maps user address to the permissions bitmask (role), where each bit
|
|
72
|
+
* represents a permission
|
|
73
|
+
* @dev Bitmask 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
|
|
74
|
+
* represents all possible permissions
|
|
75
|
+
* @dev 'This' address mapping represents global features of the smart contract
|
|
76
|
+
*
|
|
77
|
+
* @dev We keep the mapping private to prevent direct writes to it from the inheriting
|
|
78
|
+
* contracts, `getRole()` and `updateRole()` functions should be used instead
|
|
79
|
+
*/
|
|
80
|
+
mapping(address => uint256) private userRoles;
|
|
81
|
+
|
|
82
|
+
/**
|
|
83
|
+
* @notice Access manager is responsible for assigning the roles to users,
|
|
84
|
+
* enabling/disabling global features of the smart contract
|
|
85
|
+
* @notice Access manager can add, remove and update user roles,
|
|
86
|
+
* remove and update global features
|
|
87
|
+
*
|
|
88
|
+
* @dev Role ROLE_ACCESS_MANAGER allows modifying user roles and global features
|
|
89
|
+
* @dev Role ROLE_ACCESS_MANAGER has single bit at position 255 enabled
|
|
90
|
+
*/
|
|
91
|
+
uint256 public constant ROLE_ACCESS_MANAGER = 0x8000000000000000000000000000000000000000000000000000000000000000;
|
|
92
|
+
|
|
93
|
+
/**
|
|
94
|
+
* @dev Bitmask representing all the possible permissions (super admin role)
|
|
95
|
+
* @dev Has all the bits are enabled (2^256 - 1 value)
|
|
96
|
+
*/
|
|
97
|
+
uint256 internal constant FULL_PRIVILEGES_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
|
|
98
|
+
|
|
99
|
+
/**
|
|
100
|
+
* @notice Thrown when a function is executed by an account that does not have
|
|
101
|
+
* the required access permission(s) (role)
|
|
102
|
+
*
|
|
103
|
+
* @dev This error is used to enforce role-based access control (RBAC) restrictions
|
|
104
|
+
*/
|
|
105
|
+
error AccessDenied();
|
|
106
|
+
|
|
107
|
+
/**
|
|
108
|
+
* @dev Fired in updateRole() and updateFeatures()
|
|
109
|
+
*
|
|
110
|
+
* @param operator address which was granted/revoked permissions
|
|
111
|
+
* @param requested permissions requested
|
|
112
|
+
* @param assigned permissions effectively set
|
|
113
|
+
*/
|
|
114
|
+
event RoleUpdated(address indexed operator, uint256 requested, uint256 assigned);
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* @notice Function modifier making a function defined as public behave as restricted
|
|
118
|
+
* (so that only a pre-configured set of accounts can execute it)
|
|
119
|
+
*
|
|
120
|
+
* @param role the role transaction executor is required to have;
|
|
121
|
+
* the function throws an "access denied" exception if this condition is not met
|
|
122
|
+
*/
|
|
123
|
+
modifier restrictedTo(uint256 role) {
|
|
124
|
+
// verify the access permission
|
|
125
|
+
_requireSenderInRole(role);
|
|
126
|
+
|
|
127
|
+
// execute the rest of the function
|
|
128
|
+
_;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
/**
|
|
132
|
+
* @notice Creates an access control instance, setting the contract owner to have full privileges
|
|
133
|
+
*
|
|
134
|
+
* @param _owner smart contract owner having full privileges, can be zero
|
|
135
|
+
* @param _features initial features mask of the contract, can be zero
|
|
136
|
+
*/
|
|
137
|
+
constructor(address _owner, uint256 _features) { // visibility modifier is required to be compilable with 0.6.x
|
|
138
|
+
// grant owner full privileges
|
|
139
|
+
__setRole(_owner, FULL_PRIVILEGES_MASK, FULL_PRIVILEGES_MASK);
|
|
140
|
+
// update initial features bitmask
|
|
141
|
+
__setRole(address(this), _features, _features);
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
/**
|
|
145
|
+
* @notice Retrieves globally set of features enabled
|
|
146
|
+
*
|
|
147
|
+
* @dev Effectively reads userRoles role for the contract itself
|
|
148
|
+
*
|
|
149
|
+
* @return 256-bit bitmask of the features enabled
|
|
150
|
+
*/
|
|
151
|
+
function features() public view returns (uint256) {
|
|
152
|
+
// features are stored in 'this' address mapping of `userRoles`
|
|
153
|
+
return getRole(address(this));
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
/**
|
|
157
|
+
* @notice Updates set of the globally enabled features (`features`),
|
|
158
|
+
* taking into account sender's permissions
|
|
159
|
+
*
|
|
160
|
+
* @dev Requires transaction sender to have `ROLE_ACCESS_MANAGER` permission
|
|
161
|
+
* @dev Function is left for backward compatibility with older versions
|
|
162
|
+
*
|
|
163
|
+
* @param _mask bitmask representing a set of features to enable/disable
|
|
164
|
+
*/
|
|
165
|
+
function updateFeatures(uint256 _mask) public {
|
|
166
|
+
// delegate call to `updateRole`
|
|
167
|
+
updateRole(address(this), _mask);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
/**
|
|
171
|
+
* @notice Reads the permissions (role) for a given user from the `userRoles` mapping
|
|
172
|
+
* (privileged addresses with defined roles/permissions)
|
|
173
|
+
* @notice In the context of ERC20/ERC721 tokens these can be permissions to
|
|
174
|
+
* allow minting or burning tokens, transferring on behalf and so on
|
|
175
|
+
*
|
|
176
|
+
* @dev Having a simple getter instead of making the mapping public
|
|
177
|
+
* allows enforcing the encapsulation of the mapping and protects from
|
|
178
|
+
* writing to it directly in the inheriting smart contracts
|
|
179
|
+
*
|
|
180
|
+
* @param operator address of a user to read permissions for,
|
|
181
|
+
* or self address to read global features of the smart contract
|
|
182
|
+
*/
|
|
183
|
+
function getRole(address operator) public view returns(uint256) {
|
|
184
|
+
// read the value from `userRoles` and return
|
|
185
|
+
return userRoles[operator];
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
/**
|
|
189
|
+
* @notice Updates set of permissions (role) for a given user,
|
|
190
|
+
* taking into account sender's permissions.
|
|
191
|
+
*
|
|
192
|
+
* @dev Setting role to zero is equivalent to removing an all permissions
|
|
193
|
+
* @dev Setting role to `FULL_PRIVILEGES_MASK` is equivalent to
|
|
194
|
+
* copying senders' permissions (role) to the user
|
|
195
|
+
* @dev Requires transaction sender to have `ROLE_ACCESS_MANAGER` permission
|
|
196
|
+
*
|
|
197
|
+
* @param operator address of a user to alter permissions for,
|
|
198
|
+
* or self address to alter global features of the smart contract
|
|
199
|
+
* @param role bitmask representing a set of permissions to
|
|
200
|
+
* enable/disable for a user specified
|
|
201
|
+
*/
|
|
202
|
+
function updateRole(address operator, uint256 role) public {
|
|
203
|
+
// caller must have a permission to update user roles
|
|
204
|
+
_requireSenderInRole(ROLE_ACCESS_MANAGER);
|
|
205
|
+
|
|
206
|
+
// evaluate the role and reassign it
|
|
207
|
+
__setRole(operator, role, _evaluateBy(msg.sender, getRole(operator), role));
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
/**
|
|
211
|
+
* @notice Determines the permission bitmask an operator can set on the
|
|
212
|
+
* target permission set
|
|
213
|
+
* @notice Used to calculate the permission bitmask to be set when requested
|
|
214
|
+
* in `updateRole` and `updateFeatures` functions
|
|
215
|
+
*
|
|
216
|
+
* @dev Calculated based on:
|
|
217
|
+
* 1) operator's own permission set read from userRoles[operator]
|
|
218
|
+
* 2) target permission set - what is already set on the target
|
|
219
|
+
* 3) desired permission set - what do we want set target to
|
|
220
|
+
*
|
|
221
|
+
* @dev Corner cases:
|
|
222
|
+
* 1) Operator is super admin and its permission set is `FULL_PRIVILEGES_MASK`:
|
|
223
|
+
* `desired` bitset is returned regardless of the `target` permission set value
|
|
224
|
+
* (what operator sets is what they get)
|
|
225
|
+
* 2) Operator with no permissions (zero bitset):
|
|
226
|
+
* `target` bitset is returned regardless of the `desired` value
|
|
227
|
+
* (operator has no authority and cannot modify anything)
|
|
228
|
+
*
|
|
229
|
+
* @dev Example:
|
|
230
|
+
* Consider an operator with the permissions bitmask 00001111
|
|
231
|
+
* is about to modify the target permission set 01010101
|
|
232
|
+
* Operator wants to set that permission set to 00110011
|
|
233
|
+
* Based on their role, an operator has the permissions
|
|
234
|
+
* to update only lowest 4 bits on the target, meaning that
|
|
235
|
+
* high 4 bits of the target set in this example is left
|
|
236
|
+
* unchanged and low 4 bits get changed as desired: 01010011
|
|
237
|
+
*
|
|
238
|
+
* @param operator address of the contract operator which is about to set the permissions
|
|
239
|
+
* @param target input set of permissions to operator is going to modify
|
|
240
|
+
* @param desired desired set of permissions operator would like to set
|
|
241
|
+
* @return resulting set of permissions given operator will set
|
|
242
|
+
*/
|
|
243
|
+
function _evaluateBy(address operator, uint256 target, uint256 desired) internal view returns (uint256) {
|
|
244
|
+
// read operator's permissions
|
|
245
|
+
uint256 p = getRole(operator);
|
|
246
|
+
|
|
247
|
+
// taking into account operator's permissions,
|
|
248
|
+
// 1) enable the permissions desired on the `target`
|
|
249
|
+
target |= p & desired;
|
|
250
|
+
// 2) disable the permissions desired on the `target`
|
|
251
|
+
target &= FULL_PRIVILEGES_MASK ^ (p & (FULL_PRIVILEGES_MASK ^ desired));
|
|
252
|
+
|
|
253
|
+
// return calculated result
|
|
254
|
+
return target;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
/**
|
|
258
|
+
* @notice Ensures that the transaction sender has the required access permission(s) (role)
|
|
259
|
+
*
|
|
260
|
+
* @dev Reverts with an `AccessDenied` error if the sender does not have the required role
|
|
261
|
+
*
|
|
262
|
+
* @param required the set of permissions (role) that the transaction sender is required to have
|
|
263
|
+
*/
|
|
264
|
+
function _requireSenderInRole(uint256 required) internal view {
|
|
265
|
+
// check if the transaction has the required permission(s),
|
|
266
|
+
// reverting with the "access denied" error if not
|
|
267
|
+
_requireAccessCondition(_isSenderInRole(required));
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
/**
|
|
271
|
+
* @notice Ensures that a specific condition is met
|
|
272
|
+
*
|
|
273
|
+
* @dev Reverts with an `AccessDenied` error if the condition is not met
|
|
274
|
+
*
|
|
275
|
+
* @param condition the condition that needs to be true for the function to proceed
|
|
276
|
+
*/
|
|
277
|
+
function _requireAccessCondition(bool condition) internal pure {
|
|
278
|
+
// check if the condition holds
|
|
279
|
+
if(!condition) {
|
|
280
|
+
// revert with the "access denied" error if not
|
|
281
|
+
revert AccessDenied();
|
|
282
|
+
}
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
/**
|
|
286
|
+
* @notice Checks if requested set of features is enabled globally on the contract
|
|
287
|
+
*
|
|
288
|
+
* @param required set of features to check against
|
|
289
|
+
* @return true if all the features requested are enabled, false otherwise
|
|
290
|
+
*/
|
|
291
|
+
function _isFeatureEnabled(uint256 required) internal view returns (bool) {
|
|
292
|
+
// delegate call to `__hasRole`, passing `features` property
|
|
293
|
+
return __hasRole(features(), required);
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
/**
|
|
297
|
+
* @notice Checks if transaction sender `msg.sender` has all the permissions required
|
|
298
|
+
*
|
|
299
|
+
* @param required set of permissions (role) to check against
|
|
300
|
+
* @return true if all the permissions requested are enabled, false otherwise
|
|
301
|
+
*/
|
|
302
|
+
function _isSenderInRole(uint256 required) internal view returns (bool) {
|
|
303
|
+
// delegate call to `isOperatorInRole`, passing transaction sender
|
|
304
|
+
return _isOperatorInRole(msg.sender, required);
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
/**
|
|
308
|
+
* @notice Checks if operator has all the permissions (role) required
|
|
309
|
+
*
|
|
310
|
+
* @param operator address of the user to check role for
|
|
311
|
+
* @param required set of permissions (role) to check
|
|
312
|
+
* @return true if all the permissions requested are enabled, false otherwise
|
|
313
|
+
*/
|
|
314
|
+
function _isOperatorInRole(address operator, uint256 required) internal view returns (bool) {
|
|
315
|
+
// delegate call to `__hasRole`, passing operator's permissions (role)
|
|
316
|
+
return __hasRole(getRole(operator), required);
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
/**
|
|
320
|
+
* @dev Sets the `assignedRole` role to the operator, logs both `requestedRole` and `actualRole`
|
|
321
|
+
*
|
|
322
|
+
* @dev Unsafe:
|
|
323
|
+
* provides direct write access to `userRoles` mapping without any security checks,
|
|
324
|
+
* doesn't verify the executor (msg.sender) permissions,
|
|
325
|
+
* must be kept private at all times
|
|
326
|
+
*
|
|
327
|
+
* @param operator address of a user to alter permissions for,
|
|
328
|
+
* or self address to alter global features of the smart contract
|
|
329
|
+
* @param requestedRole bitmask representing a set of permissions requested
|
|
330
|
+
* to be enabled/disabled for a user specified, used only to be logged into event
|
|
331
|
+
* @param assignedRole bitmask representing a set of permissions to
|
|
332
|
+
* enable/disable for a user specified, used to update the mapping and to be logged into event
|
|
333
|
+
*/
|
|
334
|
+
function __setRole(address operator, uint256 requestedRole, uint256 assignedRole) private {
|
|
335
|
+
// assign the role to the operator
|
|
336
|
+
userRoles[operator] = assignedRole;
|
|
337
|
+
|
|
338
|
+
// fire an event
|
|
339
|
+
emit RoleUpdated(operator, requestedRole, assignedRole);
|
|
340
|
+
}
|
|
341
|
+
|
|
342
|
+
/**
|
|
343
|
+
* @dev Checks if role `actual` contains all the permissions required `required`
|
|
344
|
+
*
|
|
345
|
+
* @param actual existent role
|
|
346
|
+
* @param required required role
|
|
347
|
+
* @return true if actual has required role (all permissions), false otherwise
|
|
348
|
+
*/
|
|
349
|
+
function __hasRole(uint256 actual, uint256 required) private pure returns (bool) {
|
|
350
|
+
// check the bitmask for the role required and return the result
|
|
351
|
+
return actual & required == required;
|
|
352
|
+
}
|
|
353
|
+
}
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
// SPDX-License-Identifier: MIT
|
|
2
|
-
|
|
2
|
+
// breaking changes in .call() (0.5.0)
|
|
3
|
+
// allow .call{}() (0.6.2)
|
|
4
|
+
pragma solidity >=0.8.4;
|
|
3
5
|
|
|
4
6
|
import "./AccessControl.sol";
|
|
5
7
|
|
|
@@ -63,7 +65,7 @@ import "./AccessControl.sol";
|
|
|
63
65
|
*
|
|
64
66
|
* @author Basil Gorin
|
|
65
67
|
*/
|
|
66
|
-
contract OwnableToAccessControlAdapter is
|
|
68
|
+
contract OwnableToAccessControlAdapter is AccessControlCore {
|
|
67
69
|
/**
|
|
68
70
|
* @dev Target OZ Ownable contract AccessControl Adapter executes the transactions on
|
|
69
71
|
*
|
|
@@ -111,7 +113,7 @@ contract OwnableToAccessControlAdapter is AccessControl {
|
|
|
111
113
|
* @param _target target OZ Ownable contract address
|
|
112
114
|
* @param _owner smart contract owner having full privileges
|
|
113
115
|
*/
|
|
114
|
-
constructor(address _target, address _owner)
|
|
116
|
+
constructor(address _target, address _owner) AccessControlCore(_owner, 0) { // visibility modifier is required to be compilable with 0.6.x
|
|
115
117
|
// verify the inputs
|
|
116
118
|
require(_target != address(0), "zero address");
|
|
117
119
|
|
|
@@ -148,7 +150,7 @@ contract OwnableToAccessControlAdapter is AccessControl {
|
|
|
148
150
|
*/
|
|
149
151
|
function updateAccessRole(bytes4 selector, uint256 role) public {
|
|
150
152
|
// verify the access permission
|
|
151
|
-
|
|
153
|
+
_requireSenderInRole(ROLE_ACCESS_ROLES_MANAGER);
|
|
152
154
|
|
|
153
155
|
// update the function access role
|
|
154
156
|
accessRoles[selector] = role;
|
|
@@ -190,7 +192,7 @@ contract OwnableToAccessControlAdapter is AccessControl {
|
|
|
190
192
|
require(roleRequired != 0, "access role not set");
|
|
191
193
|
|
|
192
194
|
// verify the access permission
|
|
193
|
-
|
|
195
|
+
_requireSenderInRole(roleRequired);
|
|
194
196
|
}
|
|
195
197
|
|
|
196
198
|
// execute the call on the target
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
// SPDX-License-Identifier: MIT
|
|
2
|
-
pragma solidity >=0.4
|
|
2
|
+
pragma solidity >=0.8.4;
|
|
3
3
|
|
|
4
4
|
import "../AccessControl.sol";
|
|
5
5
|
|
|
@@ -11,4 +11,10 @@ contract AccessControlMock is AccessControl {
|
|
|
11
11
|
function restricted() public restrictedTo(RESTRICTED_ROLE) {
|
|
12
12
|
emit Restricted();
|
|
13
13
|
}
|
|
14
|
+
function requireSenderInRole(uint256 required) public view {
|
|
15
|
+
_requireSenderInRole(required);
|
|
16
|
+
}
|
|
17
|
+
function requireAccessCondition(bool condition) public pure {
|
|
18
|
+
_requireAccessCondition(condition);
|
|
19
|
+
}
|
|
14
20
|
}
|
package/hardhat.config.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/**
|
|
2
2
|
* default Hardhat configuration which uses account mnemonic to derive accounts
|
|
3
|
-
* script
|
|
3
|
+
* script supports the following environment variables set:
|
|
4
4
|
* - P_KEY1 – mainnet private key, should start with 0x
|
|
5
5
|
* or
|
|
6
6
|
* - MNEMONIC1 – mainnet mnemonic, 12 words
|
|
@@ -53,6 +53,10 @@
|
|
|
53
53
|
* or
|
|
54
54
|
* - MNEMONIC84532 – Base Sepolia (testnet) Optimistic Rollup (L2) mnemonic, 12 words
|
|
55
55
|
*
|
|
56
|
+
* - P_KEY – Custom network (defined by its JSON-RPC) private key, should start with 0x
|
|
57
|
+
* or
|
|
58
|
+
* - MNEMONIC – Custom network (defined by its JSON-RPC) mnemonic, 12 words
|
|
59
|
+
*
|
|
56
60
|
* - ALCHEMY_KEY – Alchemy API key
|
|
57
61
|
* or
|
|
58
62
|
* - INFURA_KEY – Infura API key (Project ID)
|
|
@@ -85,6 +89,13 @@ require("hardhat-gas-reporter");
|
|
|
85
89
|
// https://www.npmjs.com/package/hardhat-deploy
|
|
86
90
|
require("hardhat-deploy");
|
|
87
91
|
|
|
92
|
+
// automatically generate TypeScript bindings for smart contracts while using Hardhat
|
|
93
|
+
// TypeScript bindings help IDEs to properly recognize compiled contracts' ABIs
|
|
94
|
+
// https://github.com/dethcrypto/TypeChain/tree/master/packages/hardhat
|
|
95
|
+
// npm install -D typechain @typechain/hardhat @typechain/truffle-v5
|
|
96
|
+
// run: npx hardhat typechain
|
|
97
|
+
// require("@typechain/hardhat");
|
|
98
|
+
|
|
88
99
|
// verify environment setup, display warning if required, replace missing values with fakes
|
|
89
100
|
const FAKE_MNEMONIC = "test test test test test test test test test test test junk";
|
|
90
101
|
if(!process.env.MNEMONIC1 && !process.env.P_KEY1) {
|
|
@@ -185,19 +196,26 @@ else if(process.env.P_KEY84531 && !process.env.P_KEY84531.startsWith("0x")) {
|
|
|
185
196
|
}
|
|
186
197
|
if(!process.env.MNEMONIC84532 && !process.env.P_KEY84532) {
|
|
187
198
|
console.warn("neither MNEMONIC84532 nor P_KEY84532 is not set. Base Sepolia (testnet) deployments won't be available");
|
|
188
|
-
process.env.
|
|
199
|
+
process.env.MNEMONIC84532 = FAKE_MNEMONIC;
|
|
189
200
|
}
|
|
190
201
|
else if(process.env.P_KEY84532 && !process.env.P_KEY84532.startsWith("0x")) {
|
|
191
202
|
console.warn("P_KEY84532 doesn't start with 0x. Appended 0x");
|
|
192
203
|
process.env.P_KEY84532 = "0x" + process.env.P_KEY84532;
|
|
193
204
|
}
|
|
205
|
+
if(!process.env.MNEMONIC && !process.env.P_KEY) {
|
|
206
|
+
process.env.MNEMONIC = FAKE_MNEMONIC;
|
|
207
|
+
}
|
|
208
|
+
else if(process.env.P_KEY && !process.env.P_KEY.startsWith("0x")) {
|
|
209
|
+
console.warn("P_KEY doesn't start with 0x. Appended 0x");
|
|
210
|
+
process.env.P_KEY = "0x" + process.env.P_KEY;
|
|
211
|
+
}
|
|
194
212
|
if(!process.env.INFURA_KEY && !process.env.ALCHEMY_KEY) {
|
|
195
213
|
console.warn("neither INFURA_KEY nor ALCHEMY_KEY is not set. Deployments may not be available");
|
|
196
214
|
process.env.INFURA_KEY = "";
|
|
197
215
|
process.env.ALCHEMY_KEY = "";
|
|
198
216
|
}
|
|
199
217
|
if(!process.env.ETHERSCAN_KEY) {
|
|
200
|
-
console.warn("ETHERSCAN_KEY is not set. Deployed smart contract code verification won't be available");
|
|
218
|
+
console.warn("ETHERSCAN_KEY is not set. Deployed smart contract code verification won't be available on etherscan");
|
|
201
219
|
process.env.ETHERSCAN_KEY = "";
|
|
202
220
|
}
|
|
203
221
|
if(!process.env.POLYSCAN_KEY) {
|
|
@@ -210,6 +228,7 @@ if(!process.env.BSCSCAN_KEY) {
|
|
|
210
228
|
}
|
|
211
229
|
if(!process.env.BASESCAN_KEY) {
|
|
212
230
|
console.warn("BASESCAN_KEY is not set. Deployed smart contract code verification won't be available on BaseScan");
|
|
231
|
+
process.env.BASESCAN_KEY = "";
|
|
213
232
|
}
|
|
214
233
|
|
|
215
234
|
/**
|
|
@@ -303,6 +322,10 @@ module.exports = {
|
|
|
303
322
|
url: get_endpoint_url("base_sepolia"),
|
|
304
323
|
accounts: get_accounts(process.env.P_KEY84532, process.env.MNEMONIC84532),
|
|
305
324
|
},
|
|
325
|
+
custom: {
|
|
326
|
+
url: get_endpoint_url(),
|
|
327
|
+
accounts: get_accounts(process.env.P_KEY, process.env.MNEMONIC),
|
|
328
|
+
},
|
|
306
329
|
},
|
|
307
330
|
|
|
308
331
|
// Configure Solidity compiler
|
|
@@ -348,6 +371,12 @@ module.exports = {
|
|
|
348
371
|
]
|
|
349
372
|
},
|
|
350
373
|
|
|
374
|
+
// configure typechain to generate Truffle v5 bindings
|
|
375
|
+
typechain: {
|
|
376
|
+
outDir: "typechain",
|
|
377
|
+
target: "truffle-v5",
|
|
378
|
+
},
|
|
379
|
+
|
|
351
380
|
// Set default mocha options here, use special reporters etc.
|
|
352
381
|
mocha: {
|
|
353
382
|
// timeout: 100000,
|
|
@@ -424,12 +453,12 @@ function get_endpoint_url(network_name) {
|
|
|
424
453
|
// create a key: https://www.alchemy.com/
|
|
425
454
|
if(process.env.ALCHEMY_KEY) {
|
|
426
455
|
switch(network_name) {
|
|
427
|
-
case "mainnet": return "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
428
|
-
case "ropsten": return "https://eth-ropsten.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
429
|
-
case "rinkeby": return "https://eth-rinkeby.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
430
|
-
case "kovan": return "https://eth-kovan.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
431
|
-
case "goerli": return "https://eth-goerli.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
432
|
-
case "sepolia": return "https://eth-sepolia.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
456
|
+
case "mainnet": return "https://eth-mainnet.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
457
|
+
case "ropsten": return "https://eth-ropsten.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
458
|
+
case "rinkeby": return "https://eth-rinkeby.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
459
|
+
case "kovan": return "https://eth-kovan.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
460
|
+
case "goerli": return "https://eth-goerli.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
461
|
+
case "sepolia": return "https://eth-sepolia.g.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY;
|
|
433
462
|
case "polygon": return "https://polygon-mainnet.g.alchemy.com/v2/" + process.env.ALCHEMY_KEY;
|
|
434
463
|
case "mumbai": return "https://polygon-mumbai.g.alchemy.com/v2/" + process.env.ALCHEMY_KEY;
|
|
435
464
|
case "base_mainnet": return "https://base-mainnet.g.alchemy.com/v2/" + process.env.ALCHEMY_KEY;
|
package/index.js
CHANGED
|
@@ -9,6 +9,9 @@ const {
|
|
|
9
9
|
not,
|
|
10
10
|
} = require("./scripts/include/features_roles");
|
|
11
11
|
|
|
12
|
+
// RBAC behaviours
|
|
13
|
+
const {behavesLikeRBAC} = require("./test/include/rbac.behaviour");
|
|
14
|
+
|
|
12
15
|
// Re-export the functions
|
|
13
16
|
module.exports = {
|
|
14
17
|
ROLE_ACCESS_MANAGER,
|
|
@@ -16,4 +19,5 @@ module.exports = {
|
|
|
16
19
|
FULL_PRIVILEGES_MASK,
|
|
17
20
|
or,
|
|
18
21
|
not,
|
|
22
|
+
behavesLikeRBAC,
|
|
19
23
|
};
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@lazy-sol/access-control",
|
|
3
|
-
"version": "1.0
|
|
3
|
+
"version": "1.1.0",
|
|
4
4
|
"description": "Enable the modular plug and play (PnP) architecture for your dapp by incorporating the role-based access control (RBAC) into the smart contracts",
|
|
5
5
|
"main": "index.js",
|
|
6
6
|
"scripts": {
|
|
@@ -22,18 +22,22 @@
|
|
|
22
22
|
"author": "Basil Gorin",
|
|
23
23
|
"license": "MIT",
|
|
24
24
|
"dependencies": {
|
|
25
|
-
"@lazy-sol/a-missing-gem": "^1.0.
|
|
25
|
+
"@lazy-sol/a-missing-gem": "^1.0.9",
|
|
26
26
|
"@nomiclabs/hardhat-truffle5": "^2.0.7",
|
|
27
|
-
"hardhat": "^2.22.
|
|
27
|
+
"hardhat": "^2.22.9",
|
|
28
28
|
"hardhat-deploy": "^0.11.45"
|
|
29
29
|
},
|
|
30
30
|
"devDependencies": {
|
|
31
|
-
"@lazy-sol/zeppelin-test-helpers": "^1.0.
|
|
31
|
+
"@lazy-sol/zeppelin-test-helpers": "^1.0.5",
|
|
32
32
|
"hardhat-gas-reporter": "^1.0.10",
|
|
33
|
-
"solidity-coverage": "^0.8.
|
|
33
|
+
"solidity-coverage": "^0.8.13"
|
|
34
34
|
},
|
|
35
35
|
"overrides": {
|
|
36
|
+
"axios": ">=1.7.5",
|
|
37
|
+
"micromatch": "^4.0.8",
|
|
38
|
+
"tar": "^6.2.1",
|
|
36
39
|
"tough-cookie": "^4.1.3",
|
|
37
|
-
"yargs-parser": "^5.0.1"
|
|
40
|
+
"yargs-parser": "^5.0.1",
|
|
41
|
+
"ws": "^8.0.0"
|
|
38
42
|
}
|
|
39
43
|
}
|
|
@@ -15,16 +15,17 @@ const {
|
|
|
15
15
|
MAX_UINT256,
|
|
16
16
|
} = constants;
|
|
17
17
|
|
|
18
|
-
// BN
|
|
18
|
+
// BN constants and utilities
|
|
19
19
|
const {
|
|
20
20
|
random_bn255,
|
|
21
21
|
random_bn256,
|
|
22
|
-
} = require("@lazy-sol/a-missing-gem
|
|
22
|
+
} = require("@lazy-sol/a-missing-gem");
|
|
23
23
|
|
|
24
24
|
// RBAC core features and roles
|
|
25
25
|
const {
|
|
26
26
|
not,
|
|
27
|
-
ROLE_ACCESS_MANAGER,
|
|
27
|
+
ROLE_ACCESS_MANAGER,
|
|
28
|
+
FULL_PRIVILEGES_MASK,
|
|
28
29
|
} = require("../../scripts/include/features_roles");
|
|
29
30
|
|
|
30
31
|
/**
|
|
@@ -40,6 +41,18 @@ function behavesLikeRBAC(deployment_fn, a0, a1, a2) {
|
|
|
40
41
|
const by = a1;
|
|
41
42
|
const to = a2;
|
|
42
43
|
|
|
44
|
+
describe("requireAccessCondition(condition) pure function", function() {
|
|
45
|
+
let access_control;
|
|
46
|
+
beforeEach(async function() {
|
|
47
|
+
access_control = await deployment_fn.call(this, a0, ZERO_ADDRESS, 0);
|
|
48
|
+
});
|
|
49
|
+
it("throws if condition is false", async function() {
|
|
50
|
+
await expectRevert(access_control.requireAccessCondition(false, {from: a0}), "AccessDenied()");
|
|
51
|
+
});
|
|
52
|
+
it("succeeds if condition is true", async function() {
|
|
53
|
+
await access_control.requireAccessCondition(true, {from: a0});
|
|
54
|
+
});
|
|
55
|
+
});
|
|
43
56
|
describe("deployment and initial state", function() {
|
|
44
57
|
function deploy_and_check(owner, features) {
|
|
45
58
|
let access_control;
|
|
@@ -81,7 +94,7 @@ function behavesLikeRBAC(deployment_fn, a0, a1, a2) {
|
|
|
81
94
|
deploy_and_check(a1, random_bn256());
|
|
82
95
|
});
|
|
83
96
|
});
|
|
84
|
-
describe("when deployed with
|
|
97
|
+
describe("when deployed with no initial features", function() {
|
|
85
98
|
let access_control;
|
|
86
99
|
beforeEach(async function() {
|
|
87
100
|
access_control = await deployment_fn.call(this, a0);
|
|
@@ -92,7 +105,7 @@ function behavesLikeRBAC(deployment_fn, a0, a1, a2) {
|
|
|
92
105
|
beforeEach(async function() {
|
|
93
106
|
await access_control.updateRole(by, ROLE_ACCESS_MANAGER, {from: a0});
|
|
94
107
|
});
|
|
95
|
-
describe("when ACCESS_MANAGER has full set of permissions", function() {
|
|
108
|
+
describe("when ACCESS_MANAGER has the full set of permissions", function() {
|
|
96
109
|
beforeEach(async function() {
|
|
97
110
|
await access_control.updateRole(by, MAX_UINT256, {from: a0});
|
|
98
111
|
});
|
|
@@ -271,6 +284,7 @@ function behavesLikeRBAC(deployment_fn, a0, a1, a2) {
|
|
|
271
284
|
it("operator becomes an ACCESS_MANAGER", async function() {
|
|
272
285
|
expect(await access_control.isOperatorInRole(to, ROLE_ACCESS_MANAGER), "operator").to.be.true;
|
|
273
286
|
expect(await access_control.isSenderInRole(ROLE_ACCESS_MANAGER, {from: to}), "sender").to.be.true;
|
|
287
|
+
await access_control.requireSenderInRole(ROLE_ACCESS_MANAGER, {from: to});
|
|
274
288
|
});
|
|
275
289
|
});
|
|
276
290
|
describe("when ACCESS_MANAGER revokes ACCESS_MANAGER permission from itself", function() {
|
|
@@ -280,15 +294,16 @@ function behavesLikeRBAC(deployment_fn, a0, a1, a2) {
|
|
|
280
294
|
it("operator ceases to be an ACCESS_MANAGER", async function() {
|
|
281
295
|
expect(await access_control.isOperatorInRole(by, ROLE_ACCESS_MANAGER), "operator").to.be.false;
|
|
282
296
|
expect(await access_control.isSenderInRole(ROLE_ACCESS_MANAGER, {from: by}), "sender").to.be.false;
|
|
297
|
+
await expectRevert(access_control.requireSenderInRole(ROLE_ACCESS_MANAGER, {from: to}), "AccessDenied()");
|
|
283
298
|
});
|
|
284
299
|
});
|
|
285
300
|
});
|
|
286
301
|
describe("otherwise (no ACCESS_MANAGER permission)", function() {
|
|
287
302
|
it("updateFeatures reverts", async function() {
|
|
288
|
-
await expectRevert(access_control.updateFeatures(1, {from: by}), "
|
|
303
|
+
await expectRevert(access_control.updateFeatures(1, {from: by}), "AccessDenied()");
|
|
289
304
|
});
|
|
290
305
|
it("updateRole reverts", async function() {
|
|
291
|
-
await expectRevert(access_control.updateRole(to, 1, {from: by}), "
|
|
306
|
+
await expectRevert(access_control.updateRole(to, 1, {from: by}), "AccessDenied()");
|
|
292
307
|
});
|
|
293
308
|
});
|
|
294
309
|
}
|
|
@@ -72,7 +72,7 @@ contract("OwnableToAccessControlAdapter tests", function(accounts) {
|
|
|
72
72
|
from: a1,
|
|
73
73
|
to: adapter.address,
|
|
74
74
|
data: target.contract.methods.transferOwnership(a2).encodeABI(),
|
|
75
|
-
}), "
|
|
75
|
+
}), "AccessDenied()");
|
|
76
76
|
});
|
|
77
77
|
describe("once an account has authorization to execute transferOwnership function", function() {
|
|
78
78
|
beforeEach(async function() {
|
|
@@ -43,12 +43,12 @@ contract("OwnableToAccessControlAdapter: RBAC tests", function(accounts) {
|
|
|
43
43
|
({target, adapter} = await deploy_ownable_to_ac_adapter(a0));
|
|
44
44
|
});
|
|
45
45
|
|
|
46
|
-
it("it is impossible to configure the access role from unauthorized account", async function() {
|
|
46
|
+
it("it is impossible to configure the access role from an unauthorized account", async function() {
|
|
47
47
|
const operator = a1;
|
|
48
48
|
await adapter.updateRole(operator, not(ROLE_ACCESS_ROLES_MANAGER), {from: a0});
|
|
49
|
-
await expectRevert(adapter.updateAccessRole("1", 1, {from: operator}), "
|
|
49
|
+
await expectRevert(adapter.updateAccessRole("1", 1, {from: operator}), "AccessDenied()");
|
|
50
50
|
});
|
|
51
|
-
it("it is possible to configure the access role from authorized account", async function() {
|
|
51
|
+
it("it is possible to configure the access role from the authorized account", async function() {
|
|
52
52
|
const operator = a1;
|
|
53
53
|
await adapter.updateRole(operator, ROLE_ACCESS_ROLES_MANAGER, {from: a0});
|
|
54
54
|
adapter.updateAccessRole("1", 1, {from: operator});
|
package/test/rbac_modifier.js
CHANGED
|
@@ -38,7 +38,7 @@ contract('AccessControl (RBAC) "restrictedTo" Modifier tests', function(accounts
|
|
|
38
38
|
access_control = await deploy_access_control(a0);
|
|
39
39
|
});
|
|
40
40
|
it("function protected with restrictedTo modifier fails when run not by an admin", async function() {
|
|
41
|
-
await expectRevert(access_control.restricted({from: a1}), "
|
|
41
|
+
await expectRevert(access_control.restricted({from: a1}), "AccessDenied()");
|
|
42
42
|
});
|
|
43
43
|
describe("function protected with restrictedTo modifier succeeds when run by admin", async function() {
|
|
44
44
|
let receipt;
|